← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/ndr_samr.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/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_enum_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_enum_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_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t 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_AcctFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *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_AcctFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 
50
{
 
51
        ndr_print_uint32(ndr, name, r);
 
52
        ndr->depth++;
 
53
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DISABLED", ACB_DISABLED, r);
 
54
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_HOMDIRREQ", ACB_HOMDIRREQ, r);
 
55
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOTREQ", ACB_PWNOTREQ, r);
 
56
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TEMPDUP", ACB_TEMPDUP, r);
 
57
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NORMAL", ACB_NORMAL, r);
 
58
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_MNS", ACB_MNS, r);
 
59
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DOMTRUST", ACB_DOMTRUST, r);
 
60
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_WSTRUST", ACB_WSTRUST, r);
 
61
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SVRTRUST", ACB_SVRTRUST, r);
 
62
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOEXP", ACB_PWNOEXP, r);
 
63
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_AUTOLOCK", ACB_AUTOLOCK, r);
 
64
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_ENC_TXT_PWD_ALLOWED", ACB_ENC_TXT_PWD_ALLOWED, r);
 
65
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SMARTCARD_REQUIRED", ACB_SMARTCARD_REQUIRED, r);
 
66
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_FOR_DELEGATION", ACB_TRUSTED_FOR_DELEGATION, r);
 
67
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NOT_DELEGATED", ACB_NOT_DELEGATED, r);
 
68
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_DES_KEY_ONLY", ACB_USE_DES_KEY_ONLY, r);
 
69
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DONT_REQUIRE_PREAUTH", ACB_DONT_REQUIRE_PREAUTH, r);
 
70
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PW_EXPIRED", ACB_PW_EXPIRED, r);
 
71
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION", ACB_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION, r);
 
72
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NO_AUTH_DATA_REQD", ACB_NO_AUTH_DATA_REQD, r);
 
73
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PARTIAL_SECRETS_ACCOUNT", ACB_PARTIAL_SECRETS_ACCOUNT, r);
 
74
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_AES_KEYS", ACB_USE_AES_KEYS, r);
 
75
        ndr->depth--;
 
76
}
 
77
 
 
78
static enum ndr_err_code ndr_push_samr_ConnectAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
79
{
 
80
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
81
        return NDR_ERR_SUCCESS;
 
82
}
 
83
 
 
84
static enum ndr_err_code ndr_pull_samr_ConnectAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
85
{
 
86
        uint32_t v;
 
87
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
88
        *r = v;
 
89
        return NDR_ERR_SUCCESS;
 
90
}
 
91
 
 
92
_PUBLIC_ void ndr_print_samr_ConnectAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
93
{
 
94
        ndr_print_uint32(ndr, name, r);
 
95
        ndr->depth++;
 
96
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CONNECT_TO_SERVER", SAMR_ACCESS_CONNECT_TO_SERVER, r);
 
97
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_SHUTDOWN_SERVER", SAMR_ACCESS_SHUTDOWN_SERVER, r);
 
98
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_INITIALIZE_SERVER", SAMR_ACCESS_INITIALIZE_SERVER, r);
 
99
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CREATE_DOMAIN", SAMR_ACCESS_CREATE_DOMAIN, r);
 
100
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_ENUM_DOMAINS", SAMR_ACCESS_ENUM_DOMAINS, r);
 
101
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_LOOKUP_DOMAIN", SAMR_ACCESS_LOOKUP_DOMAIN, r);
 
102
        ndr->depth--;
 
103
}
 
104
 
 
105
static enum ndr_err_code ndr_push_samr_UserAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
106
{
 
107
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
108
        return NDR_ERR_SUCCESS;
 
109
}
 
110
 
 
111
static enum ndr_err_code ndr_pull_samr_UserAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
112
{
 
113
        uint32_t v;
 
114
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
115
        *r = v;
 
116
        return NDR_ERR_SUCCESS;
 
117
}
 
118
 
 
119
_PUBLIC_ void ndr_print_samr_UserAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
120
{
 
121
        ndr_print_uint32(ndr, name, r);
 
122
        ndr->depth++;
 
123
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_NAME_ETC", SAMR_USER_ACCESS_GET_NAME_ETC, r);
 
124
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOCALE", SAMR_USER_ACCESS_GET_LOCALE, r);
 
125
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_LOC_COM", SAMR_USER_ACCESS_SET_LOC_COM, r);
 
126
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOGONINFO", SAMR_USER_ACCESS_GET_LOGONINFO, r);
 
127
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_ATTRIBUTES", SAMR_USER_ACCESS_GET_ATTRIBUTES, r);
 
128
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_ATTRIBUTES", SAMR_USER_ACCESS_SET_ATTRIBUTES, r);
 
129
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_PASSWORD", SAMR_USER_ACCESS_CHANGE_PASSWORD, r);
 
130
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_PASSWORD", SAMR_USER_ACCESS_SET_PASSWORD, r);
 
131
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUPS", SAMR_USER_ACCESS_GET_GROUPS, r);
 
132
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP, r);
 
133
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP, r);
 
134
        ndr->depth--;
 
135
}
 
136
 
 
137
static enum ndr_err_code ndr_push_samr_DomainAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
138
{
 
139
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
140
        return NDR_ERR_SUCCESS;
 
141
}
 
142
 
 
143
static enum ndr_err_code ndr_pull_samr_DomainAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
144
{
 
145
        uint32_t v;
 
146
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
147
        *r = v;
 
148
        return NDR_ERR_SUCCESS;
 
149
}
 
150
 
 
151
_PUBLIC_ void ndr_print_samr_DomainAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
152
{
 
153
        ndr_print_uint32(ndr, name, r);
 
154
        ndr->depth++;
 
155
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1, r);
 
156
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_1", SAMR_DOMAIN_ACCESS_SET_INFO_1, r);
 
157
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2, r);
 
158
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_2", SAMR_DOMAIN_ACCESS_SET_INFO_2, r);
 
159
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_USER", SAMR_DOMAIN_ACCESS_CREATE_USER, r);
 
160
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_GROUP", SAMR_DOMAIN_ACCESS_CREATE_GROUP, r);
 
161
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_ALIAS", SAMR_DOMAIN_ACCESS_CREATE_ALIAS, r);
 
162
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS", SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS, r);
 
163
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS", SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS, r);
 
164
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT", SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, r);
 
165
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_3", SAMR_DOMAIN_ACCESS_SET_INFO_3, r);
 
166
        ndr->depth--;
 
167
}
 
168
 
 
169
static enum ndr_err_code ndr_push_samr_GroupAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
170
{
 
171
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
172
        return NDR_ERR_SUCCESS;
 
173
}
 
174
 
 
175
static enum ndr_err_code ndr_pull_samr_GroupAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
176
{
 
177
        uint32_t v;
 
178
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
179
        *r = v;
 
180
        return NDR_ERR_SUCCESS;
 
181
}
 
182
 
 
183
_PUBLIC_ void ndr_print_samr_GroupAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
184
{
 
185
        ndr_print_uint32(ndr, name, r);
 
186
        ndr->depth++;
 
187
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_LOOKUP_INFO", SAMR_GROUP_ACCESS_LOOKUP_INFO, r);
 
188
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_SET_INFO", SAMR_GROUP_ACCESS_SET_INFO, r);
 
189
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_ADD_MEMBER", SAMR_GROUP_ACCESS_ADD_MEMBER, r);
 
190
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_REMOVE_MEMBER", SAMR_GROUP_ACCESS_REMOVE_MEMBER, r);
 
191
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_GET_MEMBERS", SAMR_GROUP_ACCESS_GET_MEMBERS, r);
 
192
        ndr->depth--;
 
193
}
 
194
 
 
195
static enum ndr_err_code ndr_push_samr_AliasAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
196
{
 
197
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
198
        return NDR_ERR_SUCCESS;
 
199
}
 
200
 
 
201
static enum ndr_err_code ndr_pull_samr_AliasAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
202
{
 
203
        uint32_t v;
 
204
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
205
        *r = v;
 
206
        return NDR_ERR_SUCCESS;
 
207
}
 
208
 
 
209
_PUBLIC_ void ndr_print_samr_AliasAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 
210
{
 
211
        ndr_print_uint32(ndr, name, r);
 
212
        ndr->depth++;
 
213
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_ADD_MEMBER", SAMR_ALIAS_ACCESS_ADD_MEMBER, r);
 
214
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_REMOVE_MEMBER", SAMR_ALIAS_ACCESS_REMOVE_MEMBER, r);
 
215
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_GET_MEMBERS", SAMR_ALIAS_ACCESS_GET_MEMBERS, r);
 
216
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_LOOKUP_INFO", SAMR_ALIAS_ACCESS_LOOKUP_INFO, r);
 
217
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_SET_INFO", SAMR_ALIAS_ACCESS_SET_INFO, r);
 
218
        ndr->depth--;
 
219
}
 
220
 
 
221
static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_flags, const struct samr_SamEntry *r)
 
222
{
 
223
        if (ndr_flags & NDR_SCALARS) {
 
224
                NDR_CHECK(ndr_push_align(ndr, 5));
 
225
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
226
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
227
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
228
        }
 
229
        if (ndr_flags & NDR_BUFFERS) {
 
230
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
231
        }
 
232
        return NDR_ERR_SUCCESS;
 
233
}
 
234
 
 
235
static enum ndr_err_code ndr_pull_samr_SamEntry(struct ndr_pull *ndr, int ndr_flags, struct samr_SamEntry *r)
 
236
{
 
237
        if (ndr_flags & NDR_SCALARS) {
 
238
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
239
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
240
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
241
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
242
        }
 
243
        if (ndr_flags & NDR_BUFFERS) {
 
244
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
245
        }
 
246
        return NDR_ERR_SUCCESS;
 
247
}
 
248
 
 
249
_PUBLIC_ void ndr_print_samr_SamEntry(struct ndr_print *ndr, const char *name, const struct samr_SamEntry *r)
 
250
{
 
251
        ndr_print_struct(ndr, name, "samr_SamEntry");
 
252
        if (r == NULL) { ndr_print_null(ndr); return; }
 
253
        ndr->depth++;
 
254
        ndr_print_uint32(ndr, "idx", r->idx);
 
255
        ndr_print_lsa_String(ndr, "name", &r->name);
 
256
        ndr->depth--;
 
257
}
 
258
 
 
259
static enum ndr_err_code ndr_push_samr_SamArray(struct ndr_push *ndr, int ndr_flags, const struct samr_SamArray *r)
 
260
{
 
261
        uint32_t cntr_entries_1;
 
262
        if (ndr_flags & NDR_SCALARS) {
 
263
                NDR_CHECK(ndr_push_align(ndr, 5));
 
264
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
265
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
266
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
267
        }
 
268
        if (ndr_flags & NDR_BUFFERS) {
 
269
                if (r->entries) {
 
270
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
271
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
272
                                NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
273
                        }
 
274
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
275
                                NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
276
                        }
 
277
                }
 
278
        }
 
279
        return NDR_ERR_SUCCESS;
 
280
}
 
281
 
 
282
static enum ndr_err_code ndr_pull_samr_SamArray(struct ndr_pull *ndr, int ndr_flags, struct samr_SamArray *r)
 
283
{
 
284
        uint32_t _ptr_entries;
 
285
        uint32_t cntr_entries_1;
 
286
        TALLOC_CTX *_mem_save_entries_0;
 
287
        TALLOC_CTX *_mem_save_entries_1;
 
288
        if (ndr_flags & NDR_SCALARS) {
 
289
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
290
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
291
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
292
                if (_ptr_entries) {
 
293
                        NDR_PULL_ALLOC(ndr, r->entries);
 
294
                } else {
 
295
                        r->entries = NULL;
 
296
                }
 
297
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
298
        }
 
299
        if (ndr_flags & NDR_BUFFERS) {
 
300
                if (r->entries) {
 
301
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
302
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
303
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
304
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
305
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
306
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
307
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
308
                                NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
309
                        }
 
310
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
311
                                NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
312
                        }
 
313
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
314
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
315
                }
 
316
                if (r->entries) {
 
317
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
318
                }
 
319
        }
 
320
        return NDR_ERR_SUCCESS;
 
321
}
 
322
 
 
323
_PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, const struct samr_SamArray *r)
 
324
{
 
325
        uint32_t cntr_entries_1;
 
326
        ndr_print_struct(ndr, name, "samr_SamArray");
 
327
        if (r == NULL) { ndr_print_null(ndr); return; }
 
328
        ndr->depth++;
 
329
        ndr_print_uint32(ndr, "count", r->count);
 
330
        ndr_print_ptr(ndr, "entries", r->entries);
 
331
        ndr->depth++;
 
332
        if (r->entries) {
 
333
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
334
                ndr->depth++;
 
335
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
336
                        ndr_print_samr_SamEntry(ndr, "entries", &r->entries[cntr_entries_1]);
 
337
                }
 
338
                ndr->depth--;
 
339
        }
 
340
        ndr->depth--;
 
341
        ndr->depth--;
 
342
}
 
343
 
 
344
static enum ndr_err_code ndr_push_samr_DomainInfoClass(struct ndr_push *ndr, int ndr_flags, enum samr_DomainInfoClass r)
 
345
{
 
346
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
347
        return NDR_ERR_SUCCESS;
 
348
}
 
349
 
 
350
static enum ndr_err_code ndr_pull_samr_DomainInfoClass(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainInfoClass *r)
 
351
{
 
352
        uint16_t v;
 
353
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
354
        *r = v;
 
355
        return NDR_ERR_SUCCESS;
 
356
}
 
357
 
 
358
_PUBLIC_ void ndr_print_samr_DomainInfoClass(struct ndr_print *ndr, const char *name, enum samr_DomainInfoClass r)
 
359
{
 
360
        const char *val = NULL;
 
361
 
 
362
        switch (r) {
 
363
                case DomainPasswordInformation: val = "DomainPasswordInformation"; break;
 
364
                case DomainGeneralInformation: val = "DomainGeneralInformation"; break;
 
365
                case DomainLogoffInformation: val = "DomainLogoffInformation"; break;
 
366
                case DomainOemInformation: val = "DomainOemInformation"; break;
 
367
                case DomainNameInformation: val = "DomainNameInformation"; break;
 
368
                case DomainReplicationInformation: val = "DomainReplicationInformation"; break;
 
369
                case DomainServerRoleInformation: val = "DomainServerRoleInformation"; break;
 
370
                case DomainModifiedInformation: val = "DomainModifiedInformation"; break;
 
371
                case DomainStateInformation: val = "DomainStateInformation"; break;
 
372
                case DomainUasInformation: val = "DomainUasInformation"; break;
 
373
                case DomainGeneralInformation2: val = "DomainGeneralInformation2"; break;
 
374
                case DomainLockoutInformation: val = "DomainLockoutInformation"; break;
 
375
                case DomainModifiedInformation2: val = "DomainModifiedInformation2"; break;
 
376
        }
 
377
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
378
}
 
379
 
 
380
static enum ndr_err_code ndr_push_samr_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)
 
381
{
 
382
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
383
        return NDR_ERR_SUCCESS;
 
384
}
 
385
 
 
386
static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)
 
387
{
 
388
        uint32_t v;
 
389
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
390
        *r = v;
 
391
        return NDR_ERR_SUCCESS;
 
392
}
 
393
 
 
394
_PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)
 
395
{
 
396
        const char *val = NULL;
 
397
 
 
398
        switch (r) {
 
399
                case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;
 
400
                case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;
 
401
                case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;
 
402
                case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;
 
403
        }
 
404
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
405
}
 
406
 
 
407
_PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
408
{
 
409
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
410
        return NDR_ERR_SUCCESS;
 
411
}
 
412
 
 
413
_PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
414
{
 
415
        uint32_t v;
 
416
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
417
        *r = v;
 
418
        return NDR_ERR_SUCCESS;
 
419
}
 
420
 
 
421
_PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)
 
422
{
 
423
        ndr_print_uint32(ndr, name, r);
 
424
        ndr->depth++;
 
425
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);
 
426
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);
 
427
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);
 
428
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);
 
429
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);
 
430
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);
 
431
        ndr->depth--;
 
432
}
 
433
 
 
434
static enum ndr_err_code ndr_push_samr_DomainServerState(struct ndr_push *ndr, int ndr_flags, enum samr_DomainServerState r)
 
435
{
 
436
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
437
        return NDR_ERR_SUCCESS;
 
438
}
 
439
 
 
440
static enum ndr_err_code ndr_pull_samr_DomainServerState(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainServerState *r)
 
441
{
 
442
        uint32_t v;
 
443
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
444
        *r = v;
 
445
        return NDR_ERR_SUCCESS;
 
446
}
 
447
 
 
448
_PUBLIC_ void ndr_print_samr_DomainServerState(struct ndr_print *ndr, const char *name, enum samr_DomainServerState r)
 
449
{
 
450
        const char *val = NULL;
 
451
 
 
452
        switch (r) {
 
453
                case DOMAIN_SERVER_ENABLED: val = "DOMAIN_SERVER_ENABLED"; break;
 
454
                case DOMAIN_SERVER_DISABLED: val = "DOMAIN_SERVER_DISABLED"; break;
 
455
        }
 
456
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
457
}
 
458
 
 
459
static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)
 
460
{
 
461
        if (ndr_flags & NDR_SCALARS) {
 
462
                NDR_CHECK(ndr_push_align(ndr, 4));
 
463
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 
464
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));
 
465
                NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 
466
                NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));
 
467
                NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));
 
468
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
469
        }
 
470
        if (ndr_flags & NDR_BUFFERS) {
 
471
        }
 
472
        return NDR_ERR_SUCCESS;
 
473
}
 
474
 
 
475
static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)
 
476
{
 
477
        if (ndr_flags & NDR_SCALARS) {
 
478
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
479
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 
480
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));
 
481
                NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 
482
                NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));
 
483
                NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));
 
484
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
485
        }
 
486
        if (ndr_flags & NDR_BUFFERS) {
 
487
        }
 
488
        return NDR_ERR_SUCCESS;
 
489
}
 
490
 
 
491
_PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)
 
492
{
 
493
        ndr_print_struct(ndr, name, "samr_DomInfo1");
 
494
        if (r == NULL) { ndr_print_null(ndr); return; }
 
495
        ndr->depth++;
 
496
        ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 
497
        ndr_print_uint16(ndr, "password_history_length", r->password_history_length);
 
498
        ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 
499
        ndr_print_dlong(ndr, "max_password_age", r->max_password_age);
 
500
        ndr_print_dlong(ndr, "min_password_age", r->min_password_age);
 
501
        ndr->depth--;
 
502
}
 
503
 
 
504
static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)
 
505
{
 
506
        if (ndr_flags & NDR_SCALARS) {
 
507
                NDR_CHECK(ndr_push_align(ndr, 5));
 
508
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 
509
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 
510
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 
511
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 
512
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));
 
513
                NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 
514
                NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 
515
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
 
516
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
 
517
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));
 
518
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));
 
519
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
520
        }
 
521
        if (ndr_flags & NDR_BUFFERS) {
 
522
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 
523
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 
524
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 
525
        }
 
526
        return NDR_ERR_SUCCESS;
 
527
}
 
528
 
 
529
static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)
 
530
{
 
531
        if (ndr_flags & NDR_SCALARS) {
 
532
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
533
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 
534
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 
535
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 
536
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 
537
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));
 
538
                NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 
539
                NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 
540
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
 
541
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
 
542
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));
 
543
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));
 
544
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
545
        }
 
546
        if (ndr_flags & NDR_BUFFERS) {
 
547
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 
548
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 
549
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 
550
        }
 
551
        return NDR_ERR_SUCCESS;
 
552
}
 
553
 
 
554
_PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)
 
555
{
 
556
        ndr_print_struct(ndr, name, "samr_DomGeneralInformation");
 
557
        if (r == NULL) { ndr_print_null(ndr); return; }
 
558
        ndr->depth++;
 
559
        ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 
560
        ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 
561
        ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 
562
        ndr_print_lsa_String(ndr, "primary", &r->primary);
 
563
        ndr_print_udlong(ndr, "sequence_num", r->sequence_num);
 
564
        ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 
565
        ndr_print_samr_Role(ndr, "role", r->role);
 
566
        ndr_print_uint32(ndr, "unknown3", r->unknown3);
 
567
        ndr_print_uint32(ndr, "num_users", r->num_users);
 
568
        ndr_print_uint32(ndr, "num_groups", r->num_groups);
 
569
        ndr_print_uint32(ndr, "num_aliases", r->num_aliases);
 
570
        ndr->depth--;
 
571
}
 
572
 
 
573
static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)
 
574
{
 
575
        if (ndr_flags & NDR_SCALARS) {
 
576
                NDR_CHECK(ndr_push_align(ndr, 4));
 
577
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));
 
578
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
579
        }
 
580
        if (ndr_flags & NDR_BUFFERS) {
 
581
        }
 
582
        return NDR_ERR_SUCCESS;
 
583
}
 
584
 
 
585
static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)
 
586
{
 
587
        if (ndr_flags & NDR_SCALARS) {
 
588
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
589
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));
 
590
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
591
        }
 
592
        if (ndr_flags & NDR_BUFFERS) {
 
593
        }
 
594
        return NDR_ERR_SUCCESS;
 
595
}
 
596
 
 
597
_PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)
 
598
{
 
599
        ndr_print_struct(ndr, name, "samr_DomInfo3");
 
600
        if (r == NULL) { ndr_print_null(ndr); return; }
 
601
        ndr->depth++;
 
602
        ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);
 
603
        ndr->depth--;
 
604
}
 
605
 
 
606
static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)
 
607
{
 
608
        if (ndr_flags & NDR_SCALARS) {
 
609
                NDR_CHECK(ndr_push_align(ndr, 5));
 
610
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 
611
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
612
        }
 
613
        if (ndr_flags & NDR_BUFFERS) {
 
614
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 
615
        }
 
616
        return NDR_ERR_SUCCESS;
 
617
}
 
618
 
 
619
static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)
 
620
{
 
621
        if (ndr_flags & NDR_SCALARS) {
 
622
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
623
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));
 
624
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
625
        }
 
626
        if (ndr_flags & NDR_BUFFERS) {
 
627
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));
 
628
        }
 
629
        return NDR_ERR_SUCCESS;
 
630
}
 
631
 
 
632
_PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)
 
633
{
 
634
        ndr_print_struct(ndr, name, "samr_DomOEMInformation");
 
635
        if (r == NULL) { ndr_print_null(ndr); return; }
 
636
        ndr->depth++;
 
637
        ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);
 
638
        ndr->depth--;
 
639
}
 
640
 
 
641
static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)
 
642
{
 
643
        if (ndr_flags & NDR_SCALARS) {
 
644
                NDR_CHECK(ndr_push_align(ndr, 5));
 
645
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 
646
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
647
        }
 
648
        if (ndr_flags & NDR_BUFFERS) {
 
649
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 
650
        }
 
651
        return NDR_ERR_SUCCESS;
 
652
}
 
653
 
 
654
static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)
 
655
{
 
656
        if (ndr_flags & NDR_SCALARS) {
 
657
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
658
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));
 
659
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
660
        }
 
661
        if (ndr_flags & NDR_BUFFERS) {
 
662
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));
 
663
        }
 
664
        return NDR_ERR_SUCCESS;
 
665
}
 
666
 
 
667
_PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)
 
668
{
 
669
        ndr_print_struct(ndr, name, "samr_DomInfo5");
 
670
        if (r == NULL) { ndr_print_null(ndr); return; }
 
671
        ndr->depth++;
 
672
        ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);
 
673
        ndr->depth--;
 
674
}
 
675
 
 
676
static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)
 
677
{
 
678
        if (ndr_flags & NDR_SCALARS) {
 
679
                NDR_CHECK(ndr_push_align(ndr, 5));
 
680
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));
 
681
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
682
        }
 
683
        if (ndr_flags & NDR_BUFFERS) {
 
684
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 
685
        }
 
686
        return NDR_ERR_SUCCESS;
 
687
}
 
688
 
 
689
static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)
 
690
{
 
691
        if (ndr_flags & NDR_SCALARS) {
 
692
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
693
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));
 
694
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
695
        }
 
696
        if (ndr_flags & NDR_BUFFERS) {
 
697
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));
 
698
        }
 
699
        return NDR_ERR_SUCCESS;
 
700
}
 
701
 
 
702
_PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)
 
703
{
 
704
        ndr_print_struct(ndr, name, "samr_DomInfo6");
 
705
        if (r == NULL) { ndr_print_null(ndr); return; }
 
706
        ndr->depth++;
 
707
        ndr_print_lsa_String(ndr, "primary", &r->primary);
 
708
        ndr->depth--;
 
709
}
 
710
 
 
711
static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)
 
712
{
 
713
        if (ndr_flags & NDR_SCALARS) {
 
714
                NDR_CHECK(ndr_push_align(ndr, 4));
 
715
                NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));
 
716
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
717
        }
 
718
        if (ndr_flags & NDR_BUFFERS) {
 
719
        }
 
720
        return NDR_ERR_SUCCESS;
 
721
}
 
722
 
 
723
static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)
 
724
{
 
725
        if (ndr_flags & NDR_SCALARS) {
 
726
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
727
                NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));
 
728
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
729
        }
 
730
        if (ndr_flags & NDR_BUFFERS) {
 
731
        }
 
732
        return NDR_ERR_SUCCESS;
 
733
}
 
734
 
 
735
_PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)
 
736
{
 
737
        ndr_print_struct(ndr, name, "samr_DomInfo7");
 
738
        if (r == NULL) { ndr_print_null(ndr); return; }
 
739
        ndr->depth++;
 
740
        ndr_print_samr_Role(ndr, "role", r->role);
 
741
        ndr->depth--;
 
742
}
 
743
 
 
744
static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)
 
745
{
 
746
        if (ndr_flags & NDR_SCALARS) {
 
747
                NDR_CHECK(ndr_push_align(ndr, 8));
 
748
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 
749
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 
750
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
751
        }
 
752
        if (ndr_flags & NDR_BUFFERS) {
 
753
        }
 
754
        return NDR_ERR_SUCCESS;
 
755
}
 
756
 
 
757
static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)
 
758
{
 
759
        if (ndr_flags & NDR_SCALARS) {
 
760
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
761
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 
762
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 
763
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
764
        }
 
765
        if (ndr_flags & NDR_BUFFERS) {
 
766
        }
 
767
        return NDR_ERR_SUCCESS;
 
768
}
 
769
 
 
770
_PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)
 
771
{
 
772
        ndr_print_struct(ndr, name, "samr_DomInfo8");
 
773
        if (r == NULL) { ndr_print_null(ndr); return; }
 
774
        ndr->depth++;
 
775
        ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 
776
        ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 
777
        ndr->depth--;
 
778
}
 
779
 
 
780
static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)
 
781
{
 
782
        if (ndr_flags & NDR_SCALARS) {
 
783
                NDR_CHECK(ndr_push_align(ndr, 4));
 
784
                NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));
 
785
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
786
        }
 
787
        if (ndr_flags & NDR_BUFFERS) {
 
788
        }
 
789
        return NDR_ERR_SUCCESS;
 
790
}
 
791
 
 
792
static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo9 *r)
 
793
{
 
794
        if (ndr_flags & NDR_SCALARS) {
 
795
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
796
                NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));
 
797
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
798
        }
 
799
        if (ndr_flags & NDR_BUFFERS) {
 
800
        }
 
801
        return NDR_ERR_SUCCESS;
 
802
}
 
803
 
 
804
_PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)
 
805
{
 
806
        ndr_print_struct(ndr, name, "samr_DomInfo9");
 
807
        if (r == NULL) { ndr_print_null(ndr); return; }
 
808
        ndr->depth++;
 
809
        ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);
 
810
        ndr->depth--;
 
811
}
 
812
 
 
813
static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)
 
814
{
 
815
        if (ndr_flags & NDR_SCALARS) {
 
816
                NDR_CHECK(ndr_push_align(ndr, 8));
 
817
                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 
818
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 
819
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 
820
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 
821
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
822
        }
 
823
        if (ndr_flags & NDR_BUFFERS) {
 
824
                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 
825
        }
 
826
        return NDR_ERR_SUCCESS;
 
827
}
 
828
 
 
829
static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)
 
830
{
 
831
        if (ndr_flags & NDR_SCALARS) {
 
832
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
833
                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 
834
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 
835
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 
836
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 
837
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
838
        }
 
839
        if (ndr_flags & NDR_BUFFERS) {
 
840
                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 
841
        }
 
842
        return NDR_ERR_SUCCESS;
 
843
}
 
844
 
 
845
_PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)
 
846
{
 
847
        ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");
 
848
        if (r == NULL) { ndr_print_null(ndr); return; }
 
849
        ndr->depth++;
 
850
        ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 
851
        ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 
852
        ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 
853
        ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 
854
        ndr->depth--;
 
855
}
 
856
 
 
857
static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)
 
858
{
 
859
        if (ndr_flags & NDR_SCALARS) {
 
860
                NDR_CHECK(ndr_push_align(ndr, 8));
 
861
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));
 
862
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));
 
863
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));
 
864
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
865
        }
 
866
        if (ndr_flags & NDR_BUFFERS) {
 
867
        }
 
868
        return NDR_ERR_SUCCESS;
 
869
}
 
870
 
 
871
static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)
 
872
{
 
873
        if (ndr_flags & NDR_SCALARS) {
 
874
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
875
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));
 
876
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));
 
877
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));
 
878
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
879
        }
 
880
        if (ndr_flags & NDR_BUFFERS) {
 
881
        }
 
882
        return NDR_ERR_SUCCESS;
 
883
}
 
884
 
 
885
_PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)
 
886
{
 
887
        ndr_print_struct(ndr, name, "samr_DomInfo12");
 
888
        if (r == NULL) { ndr_print_null(ndr); return; }
 
889
        ndr->depth++;
 
890
        ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);
 
891
        ndr_print_hyper(ndr, "lockout_window", r->lockout_window);
 
892
        ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);
 
893
        ndr->depth--;
 
894
}
 
895
 
 
896
static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)
 
897
{
 
898
        if (ndr_flags & NDR_SCALARS) {
 
899
                NDR_CHECK(ndr_push_align(ndr, 8));
 
900
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));
 
901
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));
 
902
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));
 
903
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
904
        }
 
905
        if (ndr_flags & NDR_BUFFERS) {
 
906
        }
 
907
        return NDR_ERR_SUCCESS;
 
908
}
 
909
 
 
910
static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)
 
911
{
 
912
        if (ndr_flags & NDR_SCALARS) {
 
913
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
914
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));
 
915
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));
 
916
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));
 
917
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
918
        }
 
919
        if (ndr_flags & NDR_BUFFERS) {
 
920
        }
 
921
        return NDR_ERR_SUCCESS;
 
922
}
 
923
 
 
924
_PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)
 
925
{
 
926
        ndr_print_struct(ndr, name, "samr_DomInfo13");
 
927
        if (r == NULL) { ndr_print_null(ndr); return; }
 
928
        ndr->depth++;
 
929
        ndr_print_hyper(ndr, "sequence_num", r->sequence_num);
 
930
        ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);
 
931
        ndr_print_hyper(ndr, "modified_count_at_last_promotion", r->modified_count_at_last_promotion);
 
932
        ndr->depth--;
 
933
}
 
934
 
 
935
static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)
 
936
{
 
937
        if (ndr_flags & NDR_SCALARS) {
 
938
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
939
                NDR_CHECK(ndr_push_union_align(ndr, 8));
 
940
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
941
                NDR_CHECK(ndr_push_union_align(ndr, 8));
 
942
                switch (level) {
 
943
                        case 1: {
 
944
                                NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 
945
                        break; }
 
946
 
 
947
                        case 2: {
 
948
                                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 
949
                        break; }
 
950
 
 
951
                        case 3: {
 
952
                                NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 
953
                        break; }
 
954
 
 
955
                        case 4: {
 
956
                                NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 
957
                        break; }
 
958
 
 
959
                        case 5: {
 
960
                                NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 
961
                        break; }
 
962
 
 
963
                        case 6: {
 
964
                                NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 
965
                        break; }
 
966
 
 
967
                        case 7: {
 
968
                                NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 
969
                        break; }
 
970
 
 
971
                        case 8: {
 
972
                                NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 
973
                        break; }
 
974
 
 
975
                        case 9: {
 
976
                                NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 
977
                        break; }
 
978
 
 
979
                        case 11: {
 
980
                                NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 
981
                        break; }
 
982
 
 
983
                        case 12: {
 
984
                                NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 
985
                        break; }
 
986
 
 
987
                        case 13: {
 
988
                                NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 
989
                        break; }
 
990
 
 
991
                        default:
 
992
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
993
                }
 
994
        }
 
995
        if (ndr_flags & NDR_BUFFERS) {
 
996
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
997
                switch (level) {
 
998
                        case 1:
 
999
                        break;
 
1000
 
 
1001
                        case 2:
 
1002
                                NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 
1003
                        break;
 
1004
 
 
1005
                        case 3:
 
1006
                        break;
 
1007
 
 
1008
                        case 4:
 
1009
                                NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
 
1010
                        break;
 
1011
 
 
1012
                        case 5:
 
1013
                                NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
 
1014
                        break;
 
1015
 
 
1016
                        case 6:
 
1017
                                NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
 
1018
                        break;
 
1019
 
 
1020
                        case 7:
 
1021
                        break;
 
1022
 
 
1023
                        case 8:
 
1024
                        break;
 
1025
 
 
1026
                        case 9:
 
1027
                        break;
 
1028
 
 
1029
                        case 11:
 
1030
                                NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
 
1031
                        break;
 
1032
 
 
1033
                        case 12:
 
1034
                        break;
 
1035
 
 
1036
                        case 13:
 
1037
                        break;
 
1038
 
 
1039
                        default:
 
1040
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1041
                }
 
1042
        }
 
1043
        return NDR_ERR_SUCCESS;
 
1044
}
 
1045
 
 
1046
static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)
 
1047
{
 
1048
        uint32_t level;
 
1049
        uint16_t _level;
 
1050
        level = ndr_pull_get_switch_value(ndr, r);
 
1051
        if (ndr_flags & NDR_SCALARS) {
 
1052
                NDR_CHECK(ndr_pull_union_align(ndr, 8));
 
1053
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
1054
                if (_level != level) {
 
1055
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
1056
                }
 
1057
                NDR_CHECK(ndr_pull_union_align(ndr, 8));
 
1058
                switch (level) {
 
1059
                        case 1: {
 
1060
                                NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));
 
1061
                        break; }
 
1062
 
 
1063
                        case 2: {
 
1064
                                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));
 
1065
                        break; }
 
1066
 
 
1067
                        case 3: {
 
1068
                                NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));
 
1069
                        break; }
 
1070
 
 
1071
                        case 4: {
 
1072
                                NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));
 
1073
                        break; }
 
1074
 
 
1075
                        case 5: {
 
1076
                                NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));
 
1077
                        break; }
 
1078
 
 
1079
                        case 6: {
 
1080
                                NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));
 
1081
                        break; }
 
1082
 
 
1083
                        case 7: {
 
1084
                                NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));
 
1085
                        break; }
 
1086
 
 
1087
                        case 8: {
 
1088
                                NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));
 
1089
                        break; }
 
1090
 
 
1091
                        case 9: {
 
1092
                                NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));
 
1093
                        break; }
 
1094
 
 
1095
                        case 11: {
 
1096
                                NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));
 
1097
                        break; }
 
1098
 
 
1099
                        case 12: {
 
1100
                                NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));
 
1101
                        break; }
 
1102
 
 
1103
                        case 13: {
 
1104
                                NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));
 
1105
                        break; }
 
1106
 
 
1107
                        default:
 
1108
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1109
                }
 
1110
        }
 
1111
        if (ndr_flags & NDR_BUFFERS) {
 
1112
                switch (level) {
 
1113
                        case 1:
 
1114
                        break;
 
1115
 
 
1116
                        case 2:
 
1117
                                NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));
 
1118
                        break;
 
1119
 
 
1120
                        case 3:
 
1121
                        break;
 
1122
 
 
1123
                        case 4:
 
1124
                                NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));
 
1125
                        break;
 
1126
 
 
1127
                        case 5:
 
1128
                                NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));
 
1129
                        break;
 
1130
 
 
1131
                        case 6:
 
1132
                                NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));
 
1133
                        break;
 
1134
 
 
1135
                        case 7:
 
1136
                        break;
 
1137
 
 
1138
                        case 8:
 
1139
                        break;
 
1140
 
 
1141
                        case 9:
 
1142
                        break;
 
1143
 
 
1144
                        case 11:
 
1145
                                NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));
 
1146
                        break;
 
1147
 
 
1148
                        case 12:
 
1149
                        break;
 
1150
 
 
1151
                        case 13:
 
1152
                        break;
 
1153
 
 
1154
                        default:
 
1155
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1156
                }
 
1157
        }
 
1158
        return NDR_ERR_SUCCESS;
 
1159
}
 
1160
 
 
1161
_PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)
 
1162
{
 
1163
        uint32_t level;
 
1164
        level = ndr_print_get_switch_value(ndr, r);
 
1165
        ndr_print_union(ndr, name, level, "samr_DomainInfo");
 
1166
        switch (level) {
 
1167
                case 1:
 
1168
                        ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);
 
1169
                break;
 
1170
 
 
1171
                case 2:
 
1172
                        ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);
 
1173
                break;
 
1174
 
 
1175
                case 3:
 
1176
                        ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);
 
1177
                break;
 
1178
 
 
1179
                case 4:
 
1180
                        ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);
 
1181
                break;
 
1182
 
 
1183
                case 5:
 
1184
                        ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);
 
1185
                break;
 
1186
 
 
1187
                case 6:
 
1188
                        ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);
 
1189
                break;
 
1190
 
 
1191
                case 7:
 
1192
                        ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);
 
1193
                break;
 
1194
 
 
1195
                case 8:
 
1196
                        ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);
 
1197
                break;
 
1198
 
 
1199
                case 9:
 
1200
                        ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);
 
1201
                break;
 
1202
 
 
1203
                case 11:
 
1204
                        ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);
 
1205
                break;
 
1206
 
 
1207
                case 12:
 
1208
                        ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);
 
1209
                break;
 
1210
 
 
1211
                case 13:
 
1212
                        ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);
 
1213
                break;
 
1214
 
 
1215
                default:
 
1216
                        ndr_print_bad_level(ndr, name, level);
 
1217
        }
 
1218
}
 
1219
 
 
1220
static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)
 
1221
{
 
1222
        uint32_t cntr_ids_1;
 
1223
        if (ndr_flags & NDR_SCALARS) {
 
1224
                NDR_CHECK(ndr_push_align(ndr, 5));
 
1225
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
1226
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));
 
1227
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
1228
        }
 
1229
        if (ndr_flags & NDR_BUFFERS) {
 
1230
                if (r->ids) {
 
1231
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
1232
                        for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
 
1233
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));
 
1234
                        }
 
1235
                }
 
1236
        }
 
1237
        return NDR_ERR_SUCCESS;
 
1238
}
 
1239
 
 
1240
static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)
 
1241
{
 
1242
        uint32_t _ptr_ids;
 
1243
        uint32_t cntr_ids_1;
 
1244
        TALLOC_CTX *_mem_save_ids_0;
 
1245
        TALLOC_CTX *_mem_save_ids_1;
 
1246
        if (ndr_flags & NDR_SCALARS) {
 
1247
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
1248
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
1249
                if (r->count > 1024) {
 
1250
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1251
                }
 
1252
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));
 
1253
                if (_ptr_ids) {
 
1254
                        NDR_PULL_ALLOC(ndr, r->ids);
 
1255
                } else {
 
1256
                        r->ids = NULL;
 
1257
                }
 
1258
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
1259
        }
 
1260
        if (ndr_flags & NDR_BUFFERS) {
 
1261
                if (r->ids) {
 
1262
                        _mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1263
                        NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
 
1264
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));
 
1265
                        NDR_PULL_ALLOC_N(ndr, r->ids, ndr_get_array_size(ndr, &r->ids));
 
1266
                        _mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
1267
                        NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);
 
1268
                        for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {
 
1269
                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));
 
1270
                        }
 
1271
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);
 
1272
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);
 
1273
                }
 
1274
                if (r->ids) {
 
1275
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));
 
1276
                }
 
1277
        }
 
1278
        return NDR_ERR_SUCCESS;
 
1279
}
 
1280
 
 
1281
_PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)
 
1282
{
 
1283
        uint32_t cntr_ids_1;
 
1284
        ndr_print_struct(ndr, name, "samr_Ids");
 
1285
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1286
        ndr->depth++;
 
1287
        ndr_print_uint32(ndr, "count", r->count);
 
1288
        ndr_print_ptr(ndr, "ids", r->ids);
 
1289
        ndr->depth++;
 
1290
        if (r->ids) {
 
1291
                ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);
 
1292
                ndr->depth++;
 
1293
                for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {
 
1294
                        ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);
 
1295
                }
 
1296
                ndr->depth--;
 
1297
        }
 
1298
        ndr->depth--;
 
1299
        ndr->depth--;
 
1300
}
 
1301
 
 
1302
_PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
1303
{
 
1304
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
1305
        return NDR_ERR_SUCCESS;
 
1306
}
 
1307
 
 
1308
_PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
1309
{
 
1310
        uint32_t v;
 
1311
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
1312
        *r = v;
 
1313
        return NDR_ERR_SUCCESS;
 
1314
}
 
1315
 
 
1316
_PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)
 
1317
{
 
1318
        ndr_print_uint32(ndr, name, r);
 
1319
        ndr->depth++;
 
1320
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);
 
1321
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);
 
1322
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);
 
1323
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);
 
1324
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);
 
1325
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);
 
1326
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);
 
1327
        ndr->depth--;
 
1328
}
 
1329
 
 
1330
static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)
 
1331
{
 
1332
        if (ndr_flags & NDR_SCALARS) {
 
1333
                NDR_CHECK(ndr_push_align(ndr, 5));
 
1334
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1335
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
 
1336
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
 
1337
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1338
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
1339
        }
 
1340
        if (ndr_flags & NDR_BUFFERS) {
 
1341
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1342
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1343
        }
 
1344
        return NDR_ERR_SUCCESS;
 
1345
}
 
1346
 
 
1347
static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)
 
1348
{
 
1349
        if (ndr_flags & NDR_SCALARS) {
 
1350
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
1351
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1352
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
 
1353
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
 
1354
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1355
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
1356
        }
 
1357
        if (ndr_flags & NDR_BUFFERS) {
 
1358
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1359
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1360
        }
 
1361
        return NDR_ERR_SUCCESS;
 
1362
}
 
1363
 
 
1364
_PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)
 
1365
{
 
1366
        ndr_print_struct(ndr, name, "samr_GroupInfoAll");
 
1367
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1368
        ndr->depth++;
 
1369
        ndr_print_lsa_String(ndr, "name", &r->name);
 
1370
        ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
 
1371
        ndr_print_uint32(ndr, "num_members", r->num_members);
 
1372
        ndr_print_lsa_String(ndr, "description", &r->description);
 
1373
        ndr->depth--;
 
1374
}
 
1375
 
 
1376
static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)
 
1377
{
 
1378
        if (ndr_flags & NDR_SCALARS) {
 
1379
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1380
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
 
1381
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1382
        }
 
1383
        if (ndr_flags & NDR_BUFFERS) {
 
1384
        }
 
1385
        return NDR_ERR_SUCCESS;
 
1386
}
 
1387
 
 
1388
static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)
 
1389
{
 
1390
        if (ndr_flags & NDR_SCALARS) {
 
1391
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1392
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
 
1393
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1394
        }
 
1395
        if (ndr_flags & NDR_BUFFERS) {
 
1396
        }
 
1397
        return NDR_ERR_SUCCESS;
 
1398
}
 
1399
 
 
1400
_PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)
 
1401
{
 
1402
        ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");
 
1403
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1404
        ndr->depth++;
 
1405
        ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
 
1406
        ndr->depth--;
 
1407
}
 
1408
 
 
1409
static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)
 
1410
{
 
1411
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
1412
        return NDR_ERR_SUCCESS;
 
1413
}
 
1414
 
 
1415
static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)
 
1416
{
 
1417
        uint16_t v;
 
1418
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
1419
        *r = v;
 
1420
        return NDR_ERR_SUCCESS;
 
1421
}
 
1422
 
 
1423
_PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)
 
1424
{
 
1425
        const char *val = NULL;
 
1426
 
 
1427
        switch (r) {
 
1428
                case GROUPINFOALL: val = "GROUPINFOALL"; break;
 
1429
                case GROUPINFONAME: val = "GROUPINFONAME"; break;
 
1430
                case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;
 
1431
                case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;
 
1432
                case GROUPINFOALL2: val = "GROUPINFOALL2"; break;
 
1433
        }
 
1434
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1435
}
 
1436
 
 
1437
static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)
 
1438
{
 
1439
        if (ndr_flags & NDR_SCALARS) {
 
1440
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
1441
                NDR_CHECK(ndr_push_union_align(ndr, 5));
 
1442
                NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));
 
1443
                NDR_CHECK(ndr_push_union_align(ndr, 5));
 
1444
                switch (level) {
 
1445
                        case GROUPINFOALL: {
 
1446
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
 
1447
                        break; }
 
1448
 
 
1449
                        case GROUPINFONAME: {
 
1450
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1451
                        break; }
 
1452
 
 
1453
                        case GROUPINFOATTRIBUTES: {
 
1454
                                NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
 
1455
                        break; }
 
1456
 
 
1457
                        case GROUPINFODESCRIPTION: {
 
1458
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1459
                        break; }
 
1460
 
 
1461
                        case GROUPINFOALL2: {
 
1462
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
 
1463
                        break; }
 
1464
 
 
1465
                        default:
 
1466
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1467
                }
 
1468
        }
 
1469
        if (ndr_flags & NDR_BUFFERS) {
 
1470
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
1471
                switch (level) {
 
1472
                        case GROUPINFOALL:
 
1473
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
 
1474
                        break;
 
1475
 
 
1476
                        case GROUPINFONAME:
 
1477
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1478
                        break;
 
1479
 
 
1480
                        case GROUPINFOATTRIBUTES:
 
1481
                        break;
 
1482
 
 
1483
                        case GROUPINFODESCRIPTION:
 
1484
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1485
                        break;
 
1486
 
 
1487
                        case GROUPINFOALL2:
 
1488
                                NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
 
1489
                        break;
 
1490
 
 
1491
                        default:
 
1492
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1493
                }
 
1494
        }
 
1495
        return NDR_ERR_SUCCESS;
 
1496
}
 
1497
 
 
1498
static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)
 
1499
{
 
1500
        uint32_t level;
 
1501
        uint16_t _level;
 
1502
        level = ndr_pull_get_switch_value(ndr, r);
 
1503
        if (ndr_flags & NDR_SCALARS) {
 
1504
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
 
1505
                NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
 
1506
                if (_level != level) {
 
1507
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
1508
                }
 
1509
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
 
1510
                switch (level) {
 
1511
                        case GROUPINFOALL: {
 
1512
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));
 
1513
                        break; }
 
1514
 
 
1515
                        case GROUPINFONAME: {
 
1516
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1517
                        break; }
 
1518
 
 
1519
                        case GROUPINFOATTRIBUTES: {
 
1520
                                NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));
 
1521
                        break; }
 
1522
 
 
1523
                        case GROUPINFODESCRIPTION: {
 
1524
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1525
                        break; }
 
1526
 
 
1527
                        case GROUPINFOALL2: {
 
1528
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));
 
1529
                        break; }
 
1530
 
 
1531
                        default:
 
1532
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1533
                }
 
1534
        }
 
1535
        if (ndr_flags & NDR_BUFFERS) {
 
1536
                switch (level) {
 
1537
                        case GROUPINFOALL:
 
1538
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));
 
1539
                        break;
 
1540
 
 
1541
                        case GROUPINFONAME:
 
1542
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1543
                        break;
 
1544
 
 
1545
                        case GROUPINFOATTRIBUTES:
 
1546
                        break;
 
1547
 
 
1548
                        case GROUPINFODESCRIPTION:
 
1549
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1550
                        break;
 
1551
 
 
1552
                        case GROUPINFOALL2:
 
1553
                                NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));
 
1554
                        break;
 
1555
 
 
1556
                        default:
 
1557
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1558
                }
 
1559
        }
 
1560
        return NDR_ERR_SUCCESS;
 
1561
}
 
1562
 
 
1563
_PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)
 
1564
{
 
1565
        uint32_t level;
 
1566
        level = ndr_print_get_switch_value(ndr, r);
 
1567
        ndr_print_union(ndr, name, level, "samr_GroupInfo");
 
1568
        switch (level) {
 
1569
                case GROUPINFOALL:
 
1570
                        ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);
 
1571
                break;
 
1572
 
 
1573
                case GROUPINFONAME:
 
1574
                        ndr_print_lsa_String(ndr, "name", &r->name);
 
1575
                break;
 
1576
 
 
1577
                case GROUPINFOATTRIBUTES:
 
1578
                        ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);
 
1579
                break;
 
1580
 
 
1581
                case GROUPINFODESCRIPTION:
 
1582
                        ndr_print_lsa_String(ndr, "description", &r->description);
 
1583
                break;
 
1584
 
 
1585
                case GROUPINFOALL2:
 
1586
                        ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);
 
1587
                break;
 
1588
 
 
1589
                default:
 
1590
                        ndr_print_bad_level(ndr, name, level);
 
1591
        }
 
1592
}
 
1593
 
 
1594
static enum ndr_err_code ndr_push_samr_RidAttrArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidAttrArray *r)
 
1595
{
 
1596
        uint32_t cntr_rids_1;
 
1597
        uint32_t cntr_attributes_1;
 
1598
        if (ndr_flags & NDR_SCALARS) {
 
1599
                NDR_CHECK(ndr_push_align(ndr, 5));
 
1600
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
1601
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
 
1602
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
 
1603
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
1604
        }
 
1605
        if (ndr_flags & NDR_BUFFERS) {
 
1606
                if (r->rids) {
 
1607
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
1608
                        for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
 
1609
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));
 
1610
                        }
 
1611
                }
 
1612
                if (r->attributes) {
 
1613
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
1614
                        for (cntr_attributes_1 = 0; cntr_attributes_1 < r->count; cntr_attributes_1++) {
 
1615
                                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes[cntr_attributes_1]));
 
1616
                        }
 
1617
                }
 
1618
        }
 
1619
        return NDR_ERR_SUCCESS;
 
1620
}
 
1621
 
 
1622
static enum ndr_err_code ndr_pull_samr_RidAttrArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidAttrArray *r)
 
1623
{
 
1624
        uint32_t _ptr_rids;
 
1625
        uint32_t cntr_rids_1;
 
1626
        TALLOC_CTX *_mem_save_rids_0;
 
1627
        TALLOC_CTX *_mem_save_rids_1;
 
1628
        uint32_t _ptr_attributes;
 
1629
        uint32_t cntr_attributes_1;
 
1630
        TALLOC_CTX *_mem_save_attributes_0;
 
1631
        TALLOC_CTX *_mem_save_attributes_1;
 
1632
        if (ndr_flags & NDR_SCALARS) {
 
1633
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
1634
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
1635
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
 
1636
                if (_ptr_rids) {
 
1637
                        NDR_PULL_ALLOC(ndr, r->rids);
 
1638
                } else {
 
1639
                        r->rids = NULL;
 
1640
                }
 
1641
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
 
1642
                if (_ptr_attributes) {
 
1643
                        NDR_PULL_ALLOC(ndr, r->attributes);
 
1644
                } else {
 
1645
                        r->attributes = NULL;
 
1646
                }
 
1647
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
1648
        }
 
1649
        if (ndr_flags & NDR_BUFFERS) {
 
1650
                if (r->rids) {
 
1651
                        _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1652
                        NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 
1653
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
 
1654
                        NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
 
1655
                        _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
1656
                        NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 
1657
                        for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
 
1658
                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
 
1659
                        }
 
1660
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
 
1661
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 
1662
                }
 
1663
                if (r->attributes) {
 
1664
                        _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1665
                        NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
 
1666
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
 
1667
                        NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
 
1668
                        _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
1669
                        NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
 
1670
                        for (cntr_attributes_1 = 0; cntr_attributes_1 < r->count; cntr_attributes_1++) {
 
1671
                                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
 
1672
                        }
 
1673
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
 
1674
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
 
1675
                }
 
1676
                if (r->rids) {
 
1677
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
 
1678
                }
 
1679
                if (r->attributes) {
 
1680
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->count));
 
1681
                }
 
1682
        }
 
1683
        return NDR_ERR_SUCCESS;
 
1684
}
 
1685
 
 
1686
_PUBLIC_ void ndr_print_samr_RidAttrArray(struct ndr_print *ndr, const char *name, const struct samr_RidAttrArray *r)
 
1687
{
 
1688
        uint32_t cntr_rids_1;
 
1689
        uint32_t cntr_attributes_1;
 
1690
        ndr_print_struct(ndr, name, "samr_RidAttrArray");
 
1691
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1692
        ndr->depth++;
 
1693
        ndr_print_uint32(ndr, "count", r->count);
 
1694
        ndr_print_ptr(ndr, "rids", r->rids);
 
1695
        ndr->depth++;
 
1696
        if (r->rids) {
 
1697
                ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
 
1698
                ndr->depth++;
 
1699
                for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
 
1700
                        ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);
 
1701
                }
 
1702
                ndr->depth--;
 
1703
        }
 
1704
        ndr->depth--;
 
1705
        ndr_print_ptr(ndr, "attributes", r->attributes);
 
1706
        ndr->depth++;
 
1707
        if (r->attributes) {
 
1708
                ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->count);
 
1709
                ndr->depth++;
 
1710
                for (cntr_attributes_1=0;cntr_attributes_1<r->count;cntr_attributes_1++) {
 
1711
                        ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes[cntr_attributes_1]);
 
1712
                }
 
1713
                ndr->depth--;
 
1714
        }
 
1715
        ndr->depth--;
 
1716
        ndr->depth--;
 
1717
}
 
1718
 
 
1719
static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)
 
1720
{
 
1721
        if (ndr_flags & NDR_SCALARS) {
 
1722
                NDR_CHECK(ndr_push_align(ndr, 5));
 
1723
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1724
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));
 
1725
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1726
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
1727
        }
 
1728
        if (ndr_flags & NDR_BUFFERS) {
 
1729
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1730
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1731
        }
 
1732
        return NDR_ERR_SUCCESS;
 
1733
}
 
1734
 
 
1735
static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)
 
1736
{
 
1737
        if (ndr_flags & NDR_SCALARS) {
 
1738
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
1739
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1740
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));
 
1741
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1742
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
1743
        }
 
1744
        if (ndr_flags & NDR_BUFFERS) {
 
1745
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1746
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1747
        }
 
1748
        return NDR_ERR_SUCCESS;
 
1749
}
 
1750
 
 
1751
_PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)
 
1752
{
 
1753
        ndr_print_struct(ndr, name, "samr_AliasInfoAll");
 
1754
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1755
        ndr->depth++;
 
1756
        ndr_print_lsa_String(ndr, "name", &r->name);
 
1757
        ndr_print_uint32(ndr, "num_members", r->num_members);
 
1758
        ndr_print_lsa_String(ndr, "description", &r->description);
 
1759
        ndr->depth--;
 
1760
}
 
1761
 
 
1762
static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)
 
1763
{
 
1764
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
1765
        return NDR_ERR_SUCCESS;
 
1766
}
 
1767
 
 
1768
static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)
 
1769
{
 
1770
        uint16_t v;
 
1771
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
1772
        *r = v;
 
1773
        return NDR_ERR_SUCCESS;
 
1774
}
 
1775
 
 
1776
_PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)
 
1777
{
 
1778
        const char *val = NULL;
 
1779
 
 
1780
        switch (r) {
 
1781
                case ALIASINFOALL: val = "ALIASINFOALL"; break;
 
1782
                case ALIASINFONAME: val = "ALIASINFONAME"; break;
 
1783
                case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;
 
1784
        }
 
1785
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1786
}
 
1787
 
 
1788
static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)
 
1789
{
 
1790
        if (ndr_flags & NDR_SCALARS) {
 
1791
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
1792
                NDR_CHECK(ndr_push_union_align(ndr, 5));
 
1793
                NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));
 
1794
                NDR_CHECK(ndr_push_union_align(ndr, 5));
 
1795
                switch (level) {
 
1796
                        case ALIASINFOALL: {
 
1797
                                NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
 
1798
                        break; }
 
1799
 
 
1800
                        case ALIASINFONAME: {
 
1801
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1802
                        break; }
 
1803
 
 
1804
                        case ALIASINFODESCRIPTION: {
 
1805
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1806
                        break; }
 
1807
 
 
1808
                        default:
 
1809
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1810
                }
 
1811
        }
 
1812
        if (ndr_flags & NDR_BUFFERS) {
 
1813
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
1814
                switch (level) {
 
1815
                        case ALIASINFOALL:
 
1816
                                NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
 
1817
                        break;
 
1818
 
 
1819
                        case ALIASINFONAME:
 
1820
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1821
                        break;
 
1822
 
 
1823
                        case ALIASINFODESCRIPTION:
 
1824
                                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1825
                        break;
 
1826
 
 
1827
                        default:
 
1828
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1829
                }
 
1830
        }
 
1831
        return NDR_ERR_SUCCESS;
 
1832
}
 
1833
 
 
1834
static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)
 
1835
{
 
1836
        uint32_t level;
 
1837
        uint16_t _level;
 
1838
        level = ndr_pull_get_switch_value(ndr, r);
 
1839
        if (ndr_flags & NDR_SCALARS) {
 
1840
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
 
1841
                NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
 
1842
                if (_level != level) {
 
1843
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
1844
                }
 
1845
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
 
1846
                switch (level) {
 
1847
                        case ALIASINFOALL: {
 
1848
                                NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));
 
1849
                        break; }
 
1850
 
 
1851
                        case ALIASINFONAME: {
 
1852
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 
1853
                        break; }
 
1854
 
 
1855
                        case ALIASINFODESCRIPTION: {
 
1856
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1857
                        break; }
 
1858
 
 
1859
                        default:
 
1860
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1861
                }
 
1862
        }
 
1863
        if (ndr_flags & NDR_BUFFERS) {
 
1864
                switch (level) {
 
1865
                        case ALIASINFOALL:
 
1866
                                NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));
 
1867
                        break;
 
1868
 
 
1869
                        case ALIASINFONAME:
 
1870
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 
1871
                        break;
 
1872
 
 
1873
                        case ALIASINFODESCRIPTION:
 
1874
                                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1875
                        break;
 
1876
 
 
1877
                        default:
 
1878
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1879
                }
 
1880
        }
 
1881
        return NDR_ERR_SUCCESS;
 
1882
}
 
1883
 
 
1884
_PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)
 
1885
{
 
1886
        uint32_t level;
 
1887
        level = ndr_print_get_switch_value(ndr, r);
 
1888
        ndr_print_union(ndr, name, level, "samr_AliasInfo");
 
1889
        switch (level) {
 
1890
                case ALIASINFOALL:
 
1891
                        ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);
 
1892
                break;
 
1893
 
 
1894
                case ALIASINFONAME:
 
1895
                        ndr_print_lsa_String(ndr, "name", &r->name);
 
1896
                break;
 
1897
 
 
1898
                case ALIASINFODESCRIPTION:
 
1899
                        ndr_print_lsa_String(ndr, "description", &r->description);
 
1900
                break;
 
1901
 
 
1902
                default:
 
1903
                        ndr_print_bad_level(ndr, name, level);
 
1904
        }
 
1905
}
 
1906
 
 
1907
static enum ndr_err_code ndr_push_samr_UserInfoLevel(struct ndr_push *ndr, int ndr_flags, enum samr_UserInfoLevel r)
 
1908
{
 
1909
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
1910
        return NDR_ERR_SUCCESS;
 
1911
}
 
1912
 
 
1913
static enum ndr_err_code ndr_pull_samr_UserInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_UserInfoLevel *r)
 
1914
{
 
1915
        uint16_t v;
 
1916
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
1917
        *r = v;
 
1918
        return NDR_ERR_SUCCESS;
 
1919
}
 
1920
 
 
1921
_PUBLIC_ void ndr_print_samr_UserInfoLevel(struct ndr_print *ndr, const char *name, enum samr_UserInfoLevel r)
 
1922
{
 
1923
        const char *val = NULL;
 
1924
 
 
1925
        switch (r) {
 
1926
                case UserGeneralInformation: val = "UserGeneralInformation"; break;
 
1927
                case UserPreferencesInformation: val = "UserPreferencesInformation"; break;
 
1928
                case UserLogonInformation: val = "UserLogonInformation"; break;
 
1929
                case UserLogonHoursInformation: val = "UserLogonHoursInformation"; break;
 
1930
                case UserAccountInformation: val = "UserAccountInformation"; break;
 
1931
                case UserNameInformation: val = "UserNameInformation"; break;
 
1932
                case UserAccountNameInformation: val = "UserAccountNameInformation"; break;
 
1933
                case UserFullNameInformation: val = "UserFullNameInformation"; break;
 
1934
                case UserPrimaryGroupInformation: val = "UserPrimaryGroupInformation"; break;
 
1935
                case UserHomeInformation: val = "UserHomeInformation"; break;
 
1936
                case UserScriptInformation: val = "UserScriptInformation"; break;
 
1937
                case UserProfileInformation: val = "UserProfileInformation"; break;
 
1938
                case UserAdminCommentInformation: val = "UserAdminCommentInformation"; break;
 
1939
                case UserWorkStationsInformation: val = "UserWorkStationsInformation"; break;
 
1940
                case UserControlInformation: val = "UserControlInformation"; break;
 
1941
                case UserExpiresInformation: val = "UserExpiresInformation"; break;
 
1942
                case UserInternal1Information: val = "UserInternal1Information"; break;
 
1943
                case UserParametersInformation: val = "UserParametersInformation"; break;
 
1944
                case UserAllInformation: val = "UserAllInformation"; break;
 
1945
                case UserInternal4Information: val = "UserInternal4Information"; break;
 
1946
                case UserInternal5Information: val = "UserInternal5Information"; break;
 
1947
                case UserInternal4InformationNew: val = "UserInternal4InformationNew"; break;
 
1948
                case UserInternal5InformationNew: val = "UserInternal5InformationNew"; break;
 
1949
        }
 
1950
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1951
}
 
1952
 
 
1953
static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)
 
1954
{
 
1955
        if (ndr_flags & NDR_SCALARS) {
 
1956
                NDR_CHECK(ndr_push_align(ndr, 5));
 
1957
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
1958
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
1959
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
1960
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1961
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
1962
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
1963
        }
 
1964
        if (ndr_flags & NDR_BUFFERS) {
 
1965
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
1966
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
1967
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1968
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
1969
        }
 
1970
        return NDR_ERR_SUCCESS;
 
1971
}
 
1972
 
 
1973
static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)
 
1974
{
 
1975
        if (ndr_flags & NDR_SCALARS) {
 
1976
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
1977
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
1978
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
1979
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
1980
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
1981
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
1982
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
1983
        }
 
1984
        if (ndr_flags & NDR_BUFFERS) {
 
1985
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
1986
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
1987
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
1988
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
1989
        }
 
1990
        return NDR_ERR_SUCCESS;
 
1991
}
 
1992
 
 
1993
_PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)
 
1994
{
 
1995
        ndr_print_struct(ndr, name, "samr_UserInfo1");
 
1996
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1997
        ndr->depth++;
 
1998
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
1999
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2000
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
2001
        ndr_print_lsa_String(ndr, "description", &r->description);
 
2002
        ndr_print_lsa_String(ndr, "comment", &r->comment);
 
2003
        ndr->depth--;
 
2004
}
 
2005
 
 
2006
static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)
 
2007
{
 
2008
        if (ndr_flags & NDR_SCALARS) {
 
2009
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2010
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
2011
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->reserved));
 
2012
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
 
2013
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
 
2014
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2015
        }
 
2016
        if (ndr_flags & NDR_BUFFERS) {
 
2017
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
2018
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->reserved));
 
2019
        }
 
2020
        return NDR_ERR_SUCCESS;
 
2021
}
 
2022
 
 
2023
static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)
 
2024
{
 
2025
        if (ndr_flags & NDR_SCALARS) {
 
2026
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2027
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
2028
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->reserved));
 
2029
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
 
2030
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
 
2031
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2032
        }
 
2033
        if (ndr_flags & NDR_BUFFERS) {
 
2034
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
2035
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->reserved));
 
2036
        }
 
2037
        return NDR_ERR_SUCCESS;
 
2038
}
 
2039
 
 
2040
_PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)
 
2041
{
 
2042
        ndr_print_struct(ndr, name, "samr_UserInfo2");
 
2043
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2044
        ndr->depth++;
 
2045
        ndr_print_lsa_String(ndr, "comment", &r->comment);
 
2046
        ndr_print_lsa_String(ndr, "reserved", &r->reserved);
 
2047
        ndr_print_uint16(ndr, "country_code", r->country_code);
 
2048
        ndr_print_uint16(ndr, "code_page", r->code_page);
 
2049
        ndr->depth--;
 
2050
}
 
2051
 
 
2052
_PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)
 
2053
{
 
2054
        {
 
2055
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2056
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2057
                if (ndr_flags & NDR_SCALARS) {
 
2058
                        NDR_CHECK(ndr_push_align(ndr, 5));
 
2059
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));
 
2060
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));
 
2061
                        NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2062
                }
 
2063
                if (ndr_flags & NDR_BUFFERS) {
 
2064
                        if (r->bits) {
 
2065
                                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1260));
 
2066
                                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
2067
                                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->units_per_week / 8));
 
2068
                                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));
 
2069
                        }
 
2070
                }
 
2071
                ndr->flags = _flags_save_STRUCT;
 
2072
        }
 
2073
        return NDR_ERR_SUCCESS;
 
2074
}
 
2075
 
 
2076
_PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)
 
2077
{
 
2078
        uint32_t _ptr_bits;
 
2079
        TALLOC_CTX *_mem_save_bits_0;
 
2080
        {
 
2081
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2082
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2083
                if (ndr_flags & NDR_SCALARS) {
 
2084
                        NDR_CHECK(ndr_pull_align(ndr, 5));
 
2085
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));
 
2086
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));
 
2087
                        if (_ptr_bits) {
 
2088
                                NDR_PULL_ALLOC(ndr, r->bits);
 
2089
                        } else {
 
2090
                                r->bits = NULL;
 
2091
                        }
 
2092
                        NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2093
                }
 
2094
                if (ndr_flags & NDR_BUFFERS) {
 
2095
                        if (r->bits) {
 
2096
                                _mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2097
                                NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);
 
2098
                                NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));
 
2099
                                NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));
 
2100
                                if (ndr_get_array_length(ndr, &r->bits) > ndr_get_array_size(ndr, &r->bits)) {
 
2101
                                        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));
 
2102
                                }
 
2103
                                NDR_PULL_ALLOC_N(ndr, r->bits, ndr_get_array_size(ndr, &r->bits));
 
2104
                                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, ndr_get_array_length(ndr, &r->bits)));
 
2105
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);
 
2106
                        }
 
2107
                        if (r->bits) {
 
2108
                                NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));
 
2109
                        }
 
2110
                        if (r->bits) {
 
2111
                                NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));
 
2112
                        }
 
2113
                }
 
2114
                ndr->flags = _flags_save_STRUCT;
 
2115
        }
 
2116
        return NDR_ERR_SUCCESS;
 
2117
}
 
2118
 
 
2119
_PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)
 
2120
{
 
2121
        ndr_print_struct(ndr, name, "samr_LogonHours");
 
2122
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2123
        {
 
2124
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2125
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2126
                ndr->depth++;
 
2127
                ndr_print_uint16(ndr, "units_per_week", r->units_per_week);
 
2128
                ndr_print_ptr(ndr, "bits", r->bits);
 
2129
                ndr->depth++;
 
2130
                if (r->bits) {
 
2131
                        ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);
 
2132
                }
 
2133
                ndr->depth--;
 
2134
                ndr->depth--;
 
2135
                ndr->flags = _flags_save_STRUCT;
 
2136
        }
 
2137
}
 
2138
 
 
2139
static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)
 
2140
{
 
2141
        if (ndr_flags & NDR_SCALARS) {
 
2142
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2143
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2144
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2145
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
2146
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
2147
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2148
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2149
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2150
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2151
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2152
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
 
2153
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
 
2154
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
 
2155
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
 
2156
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
 
2157
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2158
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
 
2159
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
 
2160
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
2161
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2162
        }
 
2163
        if (ndr_flags & NDR_BUFFERS) {
 
2164
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2165
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2166
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2167
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2168
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2169
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2170
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2171
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2172
        }
 
2173
        return NDR_ERR_SUCCESS;
 
2174
}
 
2175
 
 
2176
static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)
 
2177
{
 
2178
        if (ndr_flags & NDR_SCALARS) {
 
2179
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2180
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2181
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2182
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
2183
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
2184
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2185
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2186
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2187
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2188
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2189
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
 
2190
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
 
2191
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
 
2192
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
 
2193
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
 
2194
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2195
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
 
2196
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
 
2197
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
2198
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2199
        }
 
2200
        if (ndr_flags & NDR_BUFFERS) {
 
2201
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2202
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2203
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2204
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2205
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2206
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2207
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2208
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2209
        }
 
2210
        return NDR_ERR_SUCCESS;
 
2211
}
 
2212
 
 
2213
_PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)
 
2214
{
 
2215
        ndr_print_struct(ndr, name, "samr_UserInfo3");
 
2216
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2217
        ndr->depth++;
 
2218
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2219
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2220
        ndr_print_uint32(ndr, "rid", r->rid);
 
2221
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
2222
        ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
 
2223
        ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
 
2224
        ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
 
2225
        ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
 
2226
        ndr_print_lsa_String(ndr, "workstations", &r->workstations);
 
2227
        ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
 
2228
        ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
 
2229
        ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
 
2230
        ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
 
2231
        ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
 
2232
        ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
 
2233
        ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
 
2234
        ndr_print_uint16(ndr, "logon_count", r->logon_count);
 
2235
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
2236
        ndr->depth--;
 
2237
}
 
2238
 
 
2239
static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)
 
2240
{
 
2241
        if (ndr_flags & NDR_SCALARS) {
 
2242
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2243
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2244
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2245
        }
 
2246
        if (ndr_flags & NDR_BUFFERS) {
 
2247
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2248
        }
 
2249
        return NDR_ERR_SUCCESS;
 
2250
}
 
2251
 
 
2252
static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)
 
2253
{
 
2254
        if (ndr_flags & NDR_SCALARS) {
 
2255
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2256
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2257
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2258
        }
 
2259
        if (ndr_flags & NDR_BUFFERS) {
 
2260
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2261
        }
 
2262
        return NDR_ERR_SUCCESS;
 
2263
}
 
2264
 
 
2265
_PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)
 
2266
{
 
2267
        ndr_print_struct(ndr, name, "samr_UserInfo4");
 
2268
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2269
        ndr->depth++;
 
2270
        ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
 
2271
        ndr->depth--;
 
2272
}
 
2273
 
 
2274
static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)
 
2275
{
 
2276
        if (ndr_flags & NDR_SCALARS) {
 
2277
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2278
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2279
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2280
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
2281
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
2282
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2283
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2284
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2285
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2286
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2287
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2288
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
 
2289
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
 
2290
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2291
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
 
2292
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
 
2293
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
 
2294
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
 
2295
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
2296
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2297
        }
 
2298
        if (ndr_flags & NDR_BUFFERS) {
 
2299
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2300
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2301
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2302
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2303
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2304
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2305
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2306
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2307
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2308
        }
 
2309
        return NDR_ERR_SUCCESS;
 
2310
}
 
2311
 
 
2312
static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)
 
2313
{
 
2314
        if (ndr_flags & NDR_SCALARS) {
 
2315
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2316
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2317
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2318
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
2319
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
2320
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2321
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2322
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2323
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2324
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2325
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2326
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
 
2327
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
 
2328
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2329
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
 
2330
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
 
2331
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
 
2332
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
 
2333
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
2334
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2335
        }
 
2336
        if (ndr_flags & NDR_BUFFERS) {
 
2337
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2338
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2339
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2340
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2341
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2342
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2343
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2344
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2345
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
2346
        }
 
2347
        return NDR_ERR_SUCCESS;
 
2348
}
 
2349
 
 
2350
_PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)
 
2351
{
 
2352
        ndr_print_struct(ndr, name, "samr_UserInfo5");
 
2353
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2354
        ndr->depth++;
 
2355
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2356
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2357
        ndr_print_uint32(ndr, "rid", r->rid);
 
2358
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
2359
        ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
 
2360
        ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
 
2361
        ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
 
2362
        ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
 
2363
        ndr_print_lsa_String(ndr, "description", &r->description);
 
2364
        ndr_print_lsa_String(ndr, "workstations", &r->workstations);
 
2365
        ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
 
2366
        ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
 
2367
        ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
 
2368
        ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
 
2369
        ndr_print_uint16(ndr, "logon_count", r->logon_count);
 
2370
        ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
 
2371
        ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
 
2372
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
2373
        ndr->depth--;
 
2374
}
 
2375
 
 
2376
static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)
 
2377
{
 
2378
        if (ndr_flags & NDR_SCALARS) {
 
2379
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2380
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2381
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2382
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2383
        }
 
2384
        if (ndr_flags & NDR_BUFFERS) {
 
2385
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2386
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2387
        }
 
2388
        return NDR_ERR_SUCCESS;
 
2389
}
 
2390
 
 
2391
static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)
 
2392
{
 
2393
        if (ndr_flags & NDR_SCALARS) {
 
2394
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2395
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2396
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2397
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2398
        }
 
2399
        if (ndr_flags & NDR_BUFFERS) {
 
2400
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2401
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2402
        }
 
2403
        return NDR_ERR_SUCCESS;
 
2404
}
 
2405
 
 
2406
_PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)
 
2407
{
 
2408
        ndr_print_struct(ndr, name, "samr_UserInfo6");
 
2409
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2410
        ndr->depth++;
 
2411
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2412
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2413
        ndr->depth--;
 
2414
}
 
2415
 
 
2416
static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)
 
2417
{
 
2418
        if (ndr_flags & NDR_SCALARS) {
 
2419
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2420
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2421
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2422
        }
 
2423
        if (ndr_flags & NDR_BUFFERS) {
 
2424
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2425
        }
 
2426
        return NDR_ERR_SUCCESS;
 
2427
}
 
2428
 
 
2429
static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)
 
2430
{
 
2431
        if (ndr_flags & NDR_SCALARS) {
 
2432
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2433
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2434
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2435
        }
 
2436
        if (ndr_flags & NDR_BUFFERS) {
 
2437
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2438
        }
 
2439
        return NDR_ERR_SUCCESS;
 
2440
}
 
2441
 
 
2442
_PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)
 
2443
{
 
2444
        ndr_print_struct(ndr, name, "samr_UserInfo7");
 
2445
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2446
        ndr->depth++;
 
2447
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
2448
        ndr->depth--;
 
2449
}
 
2450
 
 
2451
static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)
 
2452
{
 
2453
        if (ndr_flags & NDR_SCALARS) {
 
2454
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2455
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2456
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2457
        }
 
2458
        if (ndr_flags & NDR_BUFFERS) {
 
2459
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2460
        }
 
2461
        return NDR_ERR_SUCCESS;
 
2462
}
 
2463
 
 
2464
static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)
 
2465
{
 
2466
        if (ndr_flags & NDR_SCALARS) {
 
2467
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2468
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2469
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2470
        }
 
2471
        if (ndr_flags & NDR_BUFFERS) {
 
2472
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2473
        }
 
2474
        return NDR_ERR_SUCCESS;
 
2475
}
 
2476
 
 
2477
_PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)
 
2478
{
 
2479
        ndr_print_struct(ndr, name, "samr_UserInfo8");
 
2480
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2481
        ndr->depth++;
 
2482
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
2483
        ndr->depth--;
 
2484
}
 
2485
 
 
2486
static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)
 
2487
{
 
2488
        if (ndr_flags & NDR_SCALARS) {
 
2489
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2490
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
2491
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
2492
        }
 
2493
        if (ndr_flags & NDR_BUFFERS) {
 
2494
        }
 
2495
        return NDR_ERR_SUCCESS;
 
2496
}
 
2497
 
 
2498
static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)
 
2499
{
 
2500
        if (ndr_flags & NDR_SCALARS) {
 
2501
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2502
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
2503
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
2504
        }
 
2505
        if (ndr_flags & NDR_BUFFERS) {
 
2506
        }
 
2507
        return NDR_ERR_SUCCESS;
 
2508
}
 
2509
 
 
2510
_PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)
 
2511
{
 
2512
        ndr_print_struct(ndr, name, "samr_UserInfo9");
 
2513
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2514
        ndr->depth++;
 
2515
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
2516
        ndr->depth--;
 
2517
}
 
2518
 
 
2519
static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)
 
2520
{
 
2521
        if (ndr_flags & NDR_SCALARS) {
 
2522
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2523
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2524
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2525
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2526
        }
 
2527
        if (ndr_flags & NDR_BUFFERS) {
 
2528
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2529
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2530
        }
 
2531
        return NDR_ERR_SUCCESS;
 
2532
}
 
2533
 
 
2534
static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)
 
2535
{
 
2536
        if (ndr_flags & NDR_SCALARS) {
 
2537
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2538
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2539
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2540
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2541
        }
 
2542
        if (ndr_flags & NDR_BUFFERS) {
 
2543
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2544
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2545
        }
 
2546
        return NDR_ERR_SUCCESS;
 
2547
}
 
2548
 
 
2549
_PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)
 
2550
{
 
2551
        ndr_print_struct(ndr, name, "samr_UserInfo10");
 
2552
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2553
        ndr->depth++;
 
2554
        ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
 
2555
        ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
 
2556
        ndr->depth--;
 
2557
}
 
2558
 
 
2559
static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)
 
2560
{
 
2561
        if (ndr_flags & NDR_SCALARS) {
 
2562
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2563
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2564
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2565
        }
 
2566
        if (ndr_flags & NDR_BUFFERS) {
 
2567
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2568
        }
 
2569
        return NDR_ERR_SUCCESS;
 
2570
}
 
2571
 
 
2572
static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)
 
2573
{
 
2574
        if (ndr_flags & NDR_SCALARS) {
 
2575
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2576
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2577
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2578
        }
 
2579
        if (ndr_flags & NDR_BUFFERS) {
 
2580
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2581
        }
 
2582
        return NDR_ERR_SUCCESS;
 
2583
}
 
2584
 
 
2585
_PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)
 
2586
{
 
2587
        ndr_print_struct(ndr, name, "samr_UserInfo11");
 
2588
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2589
        ndr->depth++;
 
2590
        ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
 
2591
        ndr->depth--;
 
2592
}
 
2593
 
 
2594
static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)
 
2595
{
 
2596
        if (ndr_flags & NDR_SCALARS) {
 
2597
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2598
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2599
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2600
        }
 
2601
        if (ndr_flags & NDR_BUFFERS) {
 
2602
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2603
        }
 
2604
        return NDR_ERR_SUCCESS;
 
2605
}
 
2606
 
 
2607
static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)
 
2608
{
 
2609
        if (ndr_flags & NDR_SCALARS) {
 
2610
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2611
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2612
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2613
        }
 
2614
        if (ndr_flags & NDR_BUFFERS) {
 
2615
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2616
        }
 
2617
        return NDR_ERR_SUCCESS;
 
2618
}
 
2619
 
 
2620
_PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)
 
2621
{
 
2622
        ndr_print_struct(ndr, name, "samr_UserInfo12");
 
2623
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2624
        ndr->depth++;
 
2625
        ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
 
2626
        ndr->depth--;
 
2627
}
 
2628
 
 
2629
static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)
 
2630
{
 
2631
        if (ndr_flags & NDR_SCALARS) {
 
2632
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2633
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2634
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2635
        }
 
2636
        if (ndr_flags & NDR_BUFFERS) {
 
2637
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2638
        }
 
2639
        return NDR_ERR_SUCCESS;
 
2640
}
 
2641
 
 
2642
static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)
 
2643
{
 
2644
        if (ndr_flags & NDR_SCALARS) {
 
2645
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2646
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2647
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2648
        }
 
2649
        if (ndr_flags & NDR_BUFFERS) {
 
2650
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2651
        }
 
2652
        return NDR_ERR_SUCCESS;
 
2653
}
 
2654
 
 
2655
_PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)
 
2656
{
 
2657
        ndr_print_struct(ndr, name, "samr_UserInfo13");
 
2658
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2659
        ndr->depth++;
 
2660
        ndr_print_lsa_String(ndr, "description", &r->description);
 
2661
        ndr->depth--;
 
2662
}
 
2663
 
 
2664
static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)
 
2665
{
 
2666
        if (ndr_flags & NDR_SCALARS) {
 
2667
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2668
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2669
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2670
        }
 
2671
        if (ndr_flags & NDR_BUFFERS) {
 
2672
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2673
        }
 
2674
        return NDR_ERR_SUCCESS;
 
2675
}
 
2676
 
 
2677
static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)
 
2678
{
 
2679
        if (ndr_flags & NDR_SCALARS) {
 
2680
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2681
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2682
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2683
        }
 
2684
        if (ndr_flags & NDR_BUFFERS) {
 
2685
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2686
        }
 
2687
        return NDR_ERR_SUCCESS;
 
2688
}
 
2689
 
 
2690
_PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)
 
2691
{
 
2692
        ndr_print_struct(ndr, name, "samr_UserInfo14");
 
2693
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2694
        ndr->depth++;
 
2695
        ndr_print_lsa_String(ndr, "workstations", &r->workstations);
 
2696
        ndr->depth--;
 
2697
}
 
2698
 
 
2699
static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)
 
2700
{
 
2701
        if (ndr_flags & NDR_SCALARS) {
 
2702
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2703
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
2704
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
2705
        }
 
2706
        if (ndr_flags & NDR_BUFFERS) {
 
2707
        }
 
2708
        return NDR_ERR_SUCCESS;
 
2709
}
 
2710
 
 
2711
static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)
 
2712
{
 
2713
        if (ndr_flags & NDR_SCALARS) {
 
2714
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2715
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
2716
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
2717
        }
 
2718
        if (ndr_flags & NDR_BUFFERS) {
 
2719
        }
 
2720
        return NDR_ERR_SUCCESS;
 
2721
}
 
2722
 
 
2723
_PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)
 
2724
{
 
2725
        ndr_print_struct(ndr, name, "samr_UserInfo16");
 
2726
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2727
        ndr->depth++;
 
2728
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
2729
        ndr->depth--;
 
2730
}
 
2731
 
 
2732
static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)
 
2733
{
 
2734
        if (ndr_flags & NDR_SCALARS) {
 
2735
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2736
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
 
2737
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
2738
        }
 
2739
        if (ndr_flags & NDR_BUFFERS) {
 
2740
        }
 
2741
        return NDR_ERR_SUCCESS;
 
2742
}
 
2743
 
 
2744
static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)
 
2745
{
 
2746
        if (ndr_flags & NDR_SCALARS) {
 
2747
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2748
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
 
2749
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
2750
        }
 
2751
        if (ndr_flags & NDR_BUFFERS) {
 
2752
        }
 
2753
        return NDR_ERR_SUCCESS;
 
2754
}
 
2755
 
 
2756
_PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)
 
2757
{
 
2758
        ndr_print_struct(ndr, name, "samr_UserInfo17");
 
2759
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2760
        ndr->depth++;
 
2761
        ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
 
2762
        ndr->depth--;
 
2763
}
 
2764
 
 
2765
_PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)
 
2766
{
 
2767
        {
 
2768
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2769
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2770
                if (ndr_flags & NDR_SCALARS) {
 
2771
                        NDR_CHECK(ndr_push_align(ndr, 1));
 
2772
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 
2773
                        NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
2774
                }
 
2775
                if (ndr_flags & NDR_BUFFERS) {
 
2776
                }
 
2777
                ndr->flags = _flags_save_STRUCT;
 
2778
        }
 
2779
        return NDR_ERR_SUCCESS;
 
2780
}
 
2781
 
 
2782
_PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)
 
2783
{
 
2784
        {
 
2785
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2786
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2787
                if (ndr_flags & NDR_SCALARS) {
 
2788
                        NDR_CHECK(ndr_pull_align(ndr, 1));
 
2789
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 
2790
                        NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
2791
                }
 
2792
                if (ndr_flags & NDR_BUFFERS) {
 
2793
                }
 
2794
                ndr->flags = _flags_save_STRUCT;
 
2795
        }
 
2796
        return NDR_ERR_SUCCESS;
 
2797
}
 
2798
 
 
2799
_PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)
 
2800
{
 
2801
        ndr_print_struct(ndr, name, "samr_Password");
 
2802
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2803
        {
 
2804
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2805
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
2806
                ndr->depth++;
 
2807
                ndr_print_array_uint8(ndr, "hash", r->hash, 16);
 
2808
                ndr->depth--;
 
2809
                ndr->flags = _flags_save_STRUCT;
 
2810
        }
 
2811
}
 
2812
 
 
2813
static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)
 
2814
{
 
2815
        if (ndr_flags & NDR_SCALARS) {
 
2816
                NDR_CHECK(ndr_push_align(ndr, 1));
 
2817
                NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
 
2818
                NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
 
2819
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));
 
2820
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));
 
2821
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
 
2822
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
2823
        }
 
2824
        if (ndr_flags & NDR_BUFFERS) {
 
2825
        }
 
2826
        return NDR_ERR_SUCCESS;
 
2827
}
 
2828
 
 
2829
static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)
 
2830
{
 
2831
        if (ndr_flags & NDR_SCALARS) {
 
2832
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
2833
                NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));
 
2834
                NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));
 
2835
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));
 
2836
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));
 
2837
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
 
2838
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
2839
        }
 
2840
        if (ndr_flags & NDR_BUFFERS) {
 
2841
        }
 
2842
        return NDR_ERR_SUCCESS;
 
2843
}
 
2844
 
 
2845
_PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)
 
2846
{
 
2847
        ndr_print_struct(ndr, name, "samr_UserInfo18");
 
2848
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2849
        ndr->depth++;
 
2850
        ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);
 
2851
        ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);
 
2852
        ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);
 
2853
        ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);
 
2854
        ndr_print_uint8(ndr, "password_expired", r->password_expired);
 
2855
        ndr->depth--;
 
2856
}
 
2857
 
 
2858
static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)
 
2859
{
 
2860
        if (ndr_flags & NDR_SCALARS) {
 
2861
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2862
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
 
2863
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2864
        }
 
2865
        if (ndr_flags & NDR_BUFFERS) {
 
2866
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
 
2867
        }
 
2868
        return NDR_ERR_SUCCESS;
 
2869
}
 
2870
 
 
2871
static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)
 
2872
{
 
2873
        if (ndr_flags & NDR_SCALARS) {
 
2874
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
2875
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
 
2876
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
2877
        }
 
2878
        if (ndr_flags & NDR_BUFFERS) {
 
2879
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
 
2880
        }
 
2881
        return NDR_ERR_SUCCESS;
 
2882
}
 
2883
 
 
2884
_PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)
 
2885
{
 
2886
        ndr_print_struct(ndr, name, "samr_UserInfo20");
 
2887
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2888
        ndr->depth++;
 
2889
        ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
 
2890
        ndr->depth--;
 
2891
}
 
2892
 
 
2893
static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
2894
{
 
2895
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
2896
        return NDR_ERR_SUCCESS;
 
2897
}
 
2898
 
 
2899
static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
2900
{
 
2901
        uint32_t v;
 
2902
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
2903
        *r = v;
 
2904
        return NDR_ERR_SUCCESS;
 
2905
}
 
2906
 
 
2907
_PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
 
2908
{
 
2909
        ndr_print_uint32(ndr, name, r);
 
2910
        ndr->depth++;
 
2911
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);
 
2912
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);
 
2913
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);
 
2914
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);
 
2915
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);
 
2916
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);
 
2917
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);
 
2918
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);
 
2919
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);
 
2920
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);
 
2921
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);
 
2922
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);
 
2923
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);
 
2924
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);
 
2925
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);
 
2926
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);
 
2927
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);
 
2928
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);
 
2929
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);
 
2930
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);
 
2931
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);
 
2932
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);
 
2933
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);
 
2934
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);
 
2935
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NT_PASSWORD_PRESENT", SAMR_FIELD_NT_PASSWORD_PRESENT, r);
 
2936
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LM_PASSWORD_PRESENT", SAMR_FIELD_LM_PASSWORD_PRESENT, r);
 
2937
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);
 
2938
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);
 
2939
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);
 
2940
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);
 
2941
        ndr->depth--;
 
2942
}
 
2943
 
 
2944
static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)
 
2945
{
 
2946
        if (ndr_flags & NDR_SCALARS) {
 
2947
                NDR_CHECK(ndr_push_align(ndr, 5));
 
2948
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));
 
2949
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));
 
2950
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));
 
2951
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));
 
2952
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));
 
2953
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));
 
2954
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
2955
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
2956
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
2957
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
2958
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
2959
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
2960
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
2961
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
2962
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
2963
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
 
2964
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
 
2965
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
 
2966
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->private_data));
 
2967
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));
 
2968
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
 
2969
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
2970
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
 
2971
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
2972
                NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));
 
2973
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
2974
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));
 
2975
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));
 
2976
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));
 
2977
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));
 
2978
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));
 
2979
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));
 
2980
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
 
2981
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->private_data_sensitive));
 
2982
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
2983
        }
 
2984
        if (ndr_flags & NDR_BUFFERS) {
 
2985
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
2986
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
2987
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
2988
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
2989
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
2990
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
2991
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
2992
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
2993
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
2994
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
 
2995
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
 
2996
                NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
 
2997
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->private_data));
 
2998
                if (r->buffer) {
 
2999
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->buf_count));
 
3000
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));
 
3001
                }
 
3002
                NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
3003
        }
 
3004
        return NDR_ERR_SUCCESS;
 
3005
}
 
3006
 
 
3007
static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)
 
3008
{
 
3009
        uint32_t _ptr_buffer;
 
3010
        TALLOC_CTX *_mem_save_buffer_0;
 
3011
        if (ndr_flags & NDR_SCALARS) {
 
3012
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
3013
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));
 
3014
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));
 
3015
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));
 
3016
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));
 
3017
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));
 
3018
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));
 
3019
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
3020
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
3021
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));
 
3022
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));
 
3023
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));
 
3024
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));
 
3025
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
3026
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));
 
3027
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));
 
3028
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));
 
3029
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));
 
3030
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));
 
3031
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->private_data));
 
3032
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));
 
3033
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
 
3034
                if (_ptr_buffer) {
 
3035
                        NDR_PULL_ALLOC(ndr, r->buffer);
 
3036
                } else {
 
3037
                        r->buffer = NULL;
 
3038
                }
 
3039
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
3040
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
 
3041
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
3042
                NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
 
3043
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));
 
3044
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));
 
3045
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));
 
3046
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));
 
3047
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));
 
3048
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));
 
3049
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));
 
3050
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
 
3051
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->private_data_sensitive));
 
3052
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
3053
        }
 
3054
        if (ndr_flags & NDR_BUFFERS) {
 
3055
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
3056
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
3057
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));
 
3058
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));
 
3059
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));
 
3060
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));
 
3061
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
3062
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));
 
3063
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));
 
3064
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));
 
3065
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));
 
3066
                NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));
 
3067
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->private_data));
 
3068
                if (r->buffer) {
 
3069
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
3070
                        NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
 
3071
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
 
3072
                        NDR_PULL_ALLOC_N(ndr, r->buffer, ndr_get_array_size(ndr, &r->buffer));
 
3073
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, ndr_get_array_size(ndr, &r->buffer)));
 
3074
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
 
3075
                }
 
3076
                NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));
 
3077
                if (r->buffer) {
 
3078
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));
 
3079
                }
 
3080
        }
 
3081
        return NDR_ERR_SUCCESS;
 
3082
}
 
3083
 
 
3084
_PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)
 
3085
{
 
3086
        ndr_print_struct(ndr, name, "samr_UserInfo21");
 
3087
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3088
        ndr->depth++;
 
3089
        ndr_print_NTTIME(ndr, "last_logon", r->last_logon);
 
3090
        ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);
 
3091
        ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);
 
3092
        ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);
 
3093
        ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);
 
3094
        ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);
 
3095
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
3096
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
3097
        ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);
 
3098
        ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);
 
3099
        ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);
 
3100
        ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);
 
3101
        ndr_print_lsa_String(ndr, "description", &r->description);
 
3102
        ndr_print_lsa_String(ndr, "workstations", &r->workstations);
 
3103
        ndr_print_lsa_String(ndr, "comment", &r->comment);
 
3104
        ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);
 
3105
        ndr_print_lsa_BinaryString(ndr, "lm_owf_password", &r->lm_owf_password);
 
3106
        ndr_print_lsa_BinaryString(ndr, "nt_owf_password", &r->nt_owf_password);
 
3107
        ndr_print_lsa_String(ndr, "private_data", &r->private_data);
 
3108
        ndr_print_uint32(ndr, "buf_count", r->buf_count);
 
3109
        ndr_print_ptr(ndr, "buffer", r->buffer);
 
3110
        ndr->depth++;
 
3111
        if (r->buffer) {
 
3112
                ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);
 
3113
        }
 
3114
        ndr->depth--;
 
3115
        ndr_print_uint32(ndr, "rid", r->rid);
 
3116
        ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
 
3117
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
3118
        ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);
 
3119
        ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);
 
3120
        ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);
 
3121
        ndr_print_uint16(ndr, "logon_count", r->logon_count);
 
3122
        ndr_print_uint16(ndr, "country_code", r->country_code);
 
3123
        ndr_print_uint16(ndr, "code_page", r->code_page);
 
3124
        ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);
 
3125
        ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);
 
3126
        ndr_print_uint8(ndr, "password_expired", r->password_expired);
 
3127
        ndr_print_uint8(ndr, "private_data_sensitive", r->private_data_sensitive);
 
3128
        ndr->depth--;
 
3129
}
 
3130
 
 
3131
_PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPassword *r)
 
3132
{
 
3133
        {
 
3134
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3135
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3136
                if (ndr_flags & NDR_SCALARS) {
 
3137
                        NDR_CHECK(ndr_push_align(ndr, 1));
 
3138
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));
 
3139
                        NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
3140
                }
 
3141
                if (ndr_flags & NDR_BUFFERS) {
 
3142
                }
 
3143
                ndr->flags = _flags_save_STRUCT;
 
3144
        }
 
3145
        return NDR_ERR_SUCCESS;
 
3146
}
 
3147
 
 
3148
_PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)
 
3149
{
 
3150
        {
 
3151
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3152
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3153
                if (ndr_flags & NDR_SCALARS) {
 
3154
                        NDR_CHECK(ndr_pull_align(ndr, 1));
 
3155
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 516));
 
3156
                        NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
3157
                }
 
3158
                if (ndr_flags & NDR_BUFFERS) {
 
3159
                }
 
3160
                ndr->flags = _flags_save_STRUCT;
 
3161
        }
 
3162
        return NDR_ERR_SUCCESS;
 
3163
}
 
3164
 
 
3165
_PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)
 
3166
{
 
3167
        ndr_print_struct(ndr, name, "samr_CryptPassword");
 
3168
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3169
        {
 
3170
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3171
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3172
                ndr->depth++;
 
3173
                ndr_print_array_uint8(ndr, "data", r->data, 516);
 
3174
                ndr->depth--;
 
3175
                ndr->flags = _flags_save_STRUCT;
 
3176
        }
 
3177
}
 
3178
 
 
3179
static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)
 
3180
{
 
3181
        if (ndr_flags & NDR_SCALARS) {
 
3182
                NDR_CHECK(ndr_push_align(ndr, 5));
 
3183
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
 
3184
                NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
 
3185
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
3186
        }
 
3187
        if (ndr_flags & NDR_BUFFERS) {
 
3188
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
 
3189
        }
 
3190
        return NDR_ERR_SUCCESS;
 
3191
}
 
3192
 
 
3193
static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)
 
3194
{
 
3195
        if (ndr_flags & NDR_SCALARS) {
 
3196
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
3197
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
 
3198
                NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
 
3199
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
3200
        }
 
3201
        if (ndr_flags & NDR_BUFFERS) {
 
3202
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
 
3203
        }
 
3204
        return NDR_ERR_SUCCESS;
 
3205
}
 
3206
 
 
3207
_PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)
 
3208
{
 
3209
        ndr_print_struct(ndr, name, "samr_UserInfo23");
 
3210
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3211
        ndr->depth++;
 
3212
        ndr_print_samr_UserInfo21(ndr, "info", &r->info);
 
3213
        ndr_print_samr_CryptPassword(ndr, "password", &r->password);
 
3214
        ndr->depth--;
 
3215
}
 
3216
 
 
3217
static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)
 
3218
{
 
3219
        if (ndr_flags & NDR_SCALARS) {
 
3220
                NDR_CHECK(ndr_push_align(ndr, 1));
 
3221
                NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
 
3222
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
 
3223
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
3224
        }
 
3225
        if (ndr_flags & NDR_BUFFERS) {
 
3226
        }
 
3227
        return NDR_ERR_SUCCESS;
 
3228
}
 
3229
 
 
3230
static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)
 
3231
{
 
3232
        if (ndr_flags & NDR_SCALARS) {
 
3233
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
3234
                NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));
 
3235
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
 
3236
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
3237
        }
 
3238
        if (ndr_flags & NDR_BUFFERS) {
 
3239
        }
 
3240
        return NDR_ERR_SUCCESS;
 
3241
}
 
3242
 
 
3243
_PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)
 
3244
{
 
3245
        ndr_print_struct(ndr, name, "samr_UserInfo24");
 
3246
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3247
        ndr->depth++;
 
3248
        ndr_print_samr_CryptPassword(ndr, "password", &r->password);
 
3249
        ndr_print_uint8(ndr, "password_expired", r->password_expired);
 
3250
        ndr->depth--;
 
3251
}
 
3252
 
 
3253
static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)
 
3254
{
 
3255
        {
 
3256
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3257
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3258
                if (ndr_flags & NDR_SCALARS) {
 
3259
                        NDR_CHECK(ndr_push_align(ndr, 1));
 
3260
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));
 
3261
                        NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
3262
                }
 
3263
                if (ndr_flags & NDR_BUFFERS) {
 
3264
                }
 
3265
                ndr->flags = _flags_save_STRUCT;
 
3266
        }
 
3267
        return NDR_ERR_SUCCESS;
 
3268
}
 
3269
 
 
3270
static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)
 
3271
{
 
3272
        {
 
3273
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3274
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3275
                if (ndr_flags & NDR_SCALARS) {
 
3276
                        NDR_CHECK(ndr_pull_align(ndr, 1));
 
3277
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 532));
 
3278
                        NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
3279
                }
 
3280
                if (ndr_flags & NDR_BUFFERS) {
 
3281
                }
 
3282
                ndr->flags = _flags_save_STRUCT;
 
3283
        }
 
3284
        return NDR_ERR_SUCCESS;
 
3285
}
 
3286
 
 
3287
_PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)
 
3288
{
 
3289
        ndr_print_struct(ndr, name, "samr_CryptPasswordEx");
 
3290
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3291
        {
 
3292
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3293
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
3294
                ndr->depth++;
 
3295
                ndr_print_array_uint8(ndr, "data", r->data, 532);
 
3296
                ndr->depth--;
 
3297
                ndr->flags = _flags_save_STRUCT;
 
3298
        }
 
3299
}
 
3300
 
 
3301
static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)
 
3302
{
 
3303
        if (ndr_flags & NDR_SCALARS) {
 
3304
                NDR_CHECK(ndr_push_align(ndr, 5));
 
3305
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
 
3306
                NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
 
3307
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
3308
        }
 
3309
        if (ndr_flags & NDR_BUFFERS) {
 
3310
                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
 
3311
        }
 
3312
        return NDR_ERR_SUCCESS;
 
3313
}
 
3314
 
 
3315
static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)
 
3316
{
 
3317
        if (ndr_flags & NDR_SCALARS) {
 
3318
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
3319
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));
 
3320
                NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
 
3321
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
3322
        }
 
3323
        if (ndr_flags & NDR_BUFFERS) {
 
3324
                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));
 
3325
        }
 
3326
        return NDR_ERR_SUCCESS;
 
3327
}
 
3328
 
 
3329
_PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)
 
3330
{
 
3331
        ndr_print_struct(ndr, name, "samr_UserInfo25");
 
3332
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3333
        ndr->depth++;
 
3334
        ndr_print_samr_UserInfo21(ndr, "info", &r->info);
 
3335
        ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
 
3336
        ndr->depth--;
 
3337
}
 
3338
 
 
3339
static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)
 
3340
{
 
3341
        if (ndr_flags & NDR_SCALARS) {
 
3342
                NDR_CHECK(ndr_push_align(ndr, 1));
 
3343
                NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
 
3344
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));
 
3345
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
3346
        }
 
3347
        if (ndr_flags & NDR_BUFFERS) {
 
3348
        }
 
3349
        return NDR_ERR_SUCCESS;
 
3350
}
 
3351
 
 
3352
static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)
 
3353
{
 
3354
        if (ndr_flags & NDR_SCALARS) {
 
3355
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
3356
                NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));
 
3357
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));
 
3358
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
3359
        }
 
3360
        if (ndr_flags & NDR_BUFFERS) {
 
3361
        }
 
3362
        return NDR_ERR_SUCCESS;
 
3363
}
 
3364
 
 
3365
_PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)
 
3366
{
 
3367
        ndr_print_struct(ndr, name, "samr_UserInfo26");
 
3368
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3369
        ndr->depth++;
 
3370
        ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);
 
3371
        ndr_print_uint8(ndr, "password_expired", r->password_expired);
 
3372
        ndr->depth--;
 
3373
}
 
3374
 
 
3375
static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)
 
3376
{
 
3377
        if (ndr_flags & NDR_SCALARS) {
 
3378
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
3379
                NDR_CHECK(ndr_push_union_align(ndr, 5));
 
3380
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
3381
                NDR_CHECK(ndr_push_union_align(ndr, 5));
 
3382
                switch (level) {
 
3383
                        case 1: {
 
3384
                                NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
 
3385
                        break; }
 
3386
 
 
3387
                        case 2: {
 
3388
                                NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
 
3389
                        break; }
 
3390
 
 
3391
                        case 3: {
 
3392
                                NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
 
3393
                        break; }
 
3394
 
 
3395
                        case 4: {
 
3396
                                NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
 
3397
                        break; }
 
3398
 
 
3399
                        case 5: {
 
3400
                                NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
 
3401
                        break; }
 
3402
 
 
3403
                        case 6: {
 
3404
                                NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
 
3405
                        break; }
 
3406
 
 
3407
                        case 7: {
 
3408
                                NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
 
3409
                        break; }
 
3410
 
 
3411
                        case 8: {
 
3412
                                NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
 
3413
                        break; }
 
3414
 
 
3415
                        case 9: {
 
3416
                                NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
 
3417
                        break; }
 
3418
 
 
3419
                        case 10: {
 
3420
                                NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
 
3421
                        break; }
 
3422
 
 
3423
                        case 11: {
 
3424
                                NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
 
3425
                        break; }
 
3426
 
 
3427
                        case 12: {
 
3428
                                NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
 
3429
                        break; }
 
3430
 
 
3431
                        case 13: {
 
3432
                                NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
 
3433
                        break; }
 
3434
 
 
3435
                        case 14: {
 
3436
                                NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
 
3437
                        break; }
 
3438
 
 
3439
                        case 16: {
 
3440
                                NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
 
3441
                        break; }
 
3442
 
 
3443
                        case 17: {
 
3444
                                NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
 
3445
                        break; }
 
3446
 
 
3447
                        case 18: {
 
3448
                                NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
 
3449
                        break; }
 
3450
 
 
3451
                        case 20: {
 
3452
                                NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
 
3453
                        break; }
 
3454
 
 
3455
                        case 21: {
 
3456
                                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
 
3457
                        break; }
 
3458
 
 
3459
                        case 23: {
 
3460
                                NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
 
3461
                        break; }
 
3462
 
 
3463
                        case 24: {
 
3464
                                NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
 
3465
                        break; }
 
3466
 
 
3467
                        case 25: {
 
3468
                                NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
 
3469
                        break; }
 
3470
 
 
3471
                        case 26: {
 
3472
                                NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
 
3473
                        break; }
 
3474
 
 
3475
                        default:
 
3476
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
3477
                }
 
3478
        }
 
3479
        if (ndr_flags & NDR_BUFFERS) {
 
3480
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
3481
                switch (level) {
 
3482
                        case 1:
 
3483
                                NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
 
3484
                        break;
 
3485
 
 
3486
                        case 2:
 
3487
                                NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
 
3488
                        break;
 
3489
 
 
3490
                        case 3:
 
3491
                                NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
 
3492
                        break;
 
3493
 
 
3494
                        case 4:
 
3495
                                NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
 
3496
                        break;
 
3497
 
 
3498
                        case 5:
 
3499
                                NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
 
3500
                        break;
 
3501
 
 
3502
                        case 6:
 
3503
                                NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
 
3504
                        break;
 
3505
 
 
3506
                        case 7:
 
3507
                                NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
 
3508
                        break;
 
3509
 
 
3510
                        case 8:
 
3511
                                NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
 
3512
                        break;
 
3513
 
 
3514
                        case 9:
 
3515
                        break;
 
3516
 
 
3517
                        case 10:
 
3518
                                NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
 
3519
                        break;
 
3520
 
 
3521
                        case 11:
 
3522
                                NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
 
3523
                        break;
 
3524
 
 
3525
                        case 12:
 
3526
                                NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
 
3527
                        break;
 
3528
 
 
3529
                        case 13:
 
3530
                                NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
 
3531
                        break;
 
3532
 
 
3533
                        case 14:
 
3534
                                NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
 
3535
                        break;
 
3536
 
 
3537
                        case 16:
 
3538
                        break;
 
3539
 
 
3540
                        case 17:
 
3541
                        break;
 
3542
 
 
3543
                        case 18:
 
3544
                        break;
 
3545
 
 
3546
                        case 20:
 
3547
                                NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
 
3548
                        break;
 
3549
 
 
3550
                        case 21:
 
3551
                                NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
 
3552
                        break;
 
3553
 
 
3554
                        case 23:
 
3555
                                NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
 
3556
                        break;
 
3557
 
 
3558
                        case 24:
 
3559
                        break;
 
3560
 
 
3561
                        case 25:
 
3562
                                NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
 
3563
                        break;
 
3564
 
 
3565
                        case 26:
 
3566
                        break;
 
3567
 
 
3568
                        default:
 
3569
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
3570
                }
 
3571
        }
 
3572
        return NDR_ERR_SUCCESS;
 
3573
}
 
3574
 
 
3575
static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)
 
3576
{
 
3577
        uint32_t level;
 
3578
        uint16_t _level;
 
3579
        level = ndr_pull_get_switch_value(ndr, r);
 
3580
        if (ndr_flags & NDR_SCALARS) {
 
3581
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
 
3582
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
3583
                if (_level != level) {
 
3584
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
3585
                }
 
3586
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
 
3587
                switch (level) {
 
3588
                        case 1: {
 
3589
                                NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));
 
3590
                        break; }
 
3591
 
 
3592
                        case 2: {
 
3593
                                NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));
 
3594
                        break; }
 
3595
 
 
3596
                        case 3: {
 
3597
                                NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));
 
3598
                        break; }
 
3599
 
 
3600
                        case 4: {
 
3601
                                NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));
 
3602
                        break; }
 
3603
 
 
3604
                        case 5: {
 
3605
                                NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));
 
3606
                        break; }
 
3607
 
 
3608
                        case 6: {
 
3609
                                NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));
 
3610
                        break; }
 
3611
 
 
3612
                        case 7: {
 
3613
                                NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));
 
3614
                        break; }
 
3615
 
 
3616
                        case 8: {
 
3617
                                NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));
 
3618
                        break; }
 
3619
 
 
3620
                        case 9: {
 
3621
                                NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));
 
3622
                        break; }
 
3623
 
 
3624
                        case 10: {
 
3625
                                NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));
 
3626
                        break; }
 
3627
 
 
3628
                        case 11: {
 
3629
                                NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));
 
3630
                        break; }
 
3631
 
 
3632
                        case 12: {
 
3633
                                NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));
 
3634
                        break; }
 
3635
 
 
3636
                        case 13: {
 
3637
                                NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));
 
3638
                        break; }
 
3639
 
 
3640
                        case 14: {
 
3641
                                NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));
 
3642
                        break; }
 
3643
 
 
3644
                        case 16: {
 
3645
                                NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));
 
3646
                        break; }
 
3647
 
 
3648
                        case 17: {
 
3649
                                NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));
 
3650
                        break; }
 
3651
 
 
3652
                        case 18: {
 
3653
                                NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));
 
3654
                        break; }
 
3655
 
 
3656
                        case 20: {
 
3657
                                NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));
 
3658
                        break; }
 
3659
 
 
3660
                        case 21: {
 
3661
                                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));
 
3662
                        break; }
 
3663
 
 
3664
                        case 23: {
 
3665
                                NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));
 
3666
                        break; }
 
3667
 
 
3668
                        case 24: {
 
3669
                                NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));
 
3670
                        break; }
 
3671
 
 
3672
                        case 25: {
 
3673
                                NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));
 
3674
                        break; }
 
3675
 
 
3676
                        case 26: {
 
3677
                                NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));
 
3678
                        break; }
 
3679
 
 
3680
                        default:
 
3681
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
3682
                }
 
3683
        }
 
3684
        if (ndr_flags & NDR_BUFFERS) {
 
3685
                switch (level) {
 
3686
                        case 1:
 
3687
                                NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));
 
3688
                        break;
 
3689
 
 
3690
                        case 2:
 
3691
                                NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));
 
3692
                        break;
 
3693
 
 
3694
                        case 3:
 
3695
                                NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));
 
3696
                        break;
 
3697
 
 
3698
                        case 4:
 
3699
                                NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));
 
3700
                        break;
 
3701
 
 
3702
                        case 5:
 
3703
                                NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));
 
3704
                        break;
 
3705
 
 
3706
                        case 6:
 
3707
                                NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));
 
3708
                        break;
 
3709
 
 
3710
                        case 7:
 
3711
                                NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));
 
3712
                        break;
 
3713
 
 
3714
                        case 8:
 
3715
                                NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));
 
3716
                        break;
 
3717
 
 
3718
                        case 9:
 
3719
                        break;
 
3720
 
 
3721
                        case 10:
 
3722
                                NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));
 
3723
                        break;
 
3724
 
 
3725
                        case 11:
 
3726
                                NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));
 
3727
                        break;
 
3728
 
 
3729
                        case 12:
 
3730
                                NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));
 
3731
                        break;
 
3732
 
 
3733
                        case 13:
 
3734
                                NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));
 
3735
                        break;
 
3736
 
 
3737
                        case 14:
 
3738
                                NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));
 
3739
                        break;
 
3740
 
 
3741
                        case 16:
 
3742
                        break;
 
3743
 
 
3744
                        case 17:
 
3745
                        break;
 
3746
 
 
3747
                        case 18:
 
3748
                        break;
 
3749
 
 
3750
                        case 20:
 
3751
                                NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));
 
3752
                        break;
 
3753
 
 
3754
                        case 21:
 
3755
                                NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));
 
3756
                        break;
 
3757
 
 
3758
                        case 23:
 
3759
                                NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));
 
3760
                        break;
 
3761
 
 
3762
                        case 24:
 
3763
                        break;
 
3764
 
 
3765
                        case 25:
 
3766
                                NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));
 
3767
                        break;
 
3768
 
 
3769
                        case 26:
 
3770
                        break;
 
3771
 
 
3772
                        default:
 
3773
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
3774
                }
 
3775
        }
 
3776
        return NDR_ERR_SUCCESS;
 
3777
}
 
3778
 
 
3779
_PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)
 
3780
{
 
3781
        uint32_t level;
 
3782
        level = ndr_print_get_switch_value(ndr, r);
 
3783
        ndr_print_union(ndr, name, level, "samr_UserInfo");
 
3784
        switch (level) {
 
3785
                case 1:
 
3786
                        ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);
 
3787
                break;
 
3788
 
 
3789
                case 2:
 
3790
                        ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);
 
3791
                break;
 
3792
 
 
3793
                case 3:
 
3794
                        ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);
 
3795
                break;
 
3796
 
 
3797
                case 4:
 
3798
                        ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);
 
3799
                break;
 
3800
 
 
3801
                case 5:
 
3802
                        ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);
 
3803
                break;
 
3804
 
 
3805
                case 6:
 
3806
                        ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);
 
3807
                break;
 
3808
 
 
3809
                case 7:
 
3810
                        ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);
 
3811
                break;
 
3812
 
 
3813
                case 8:
 
3814
                        ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);
 
3815
                break;
 
3816
 
 
3817
                case 9:
 
3818
                        ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);
 
3819
                break;
 
3820
 
 
3821
                case 10:
 
3822
                        ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);
 
3823
                break;
 
3824
 
 
3825
                case 11:
 
3826
                        ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);
 
3827
                break;
 
3828
 
 
3829
                case 12:
 
3830
                        ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);
 
3831
                break;
 
3832
 
 
3833
                case 13:
 
3834
                        ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);
 
3835
                break;
 
3836
 
 
3837
                case 14:
 
3838
                        ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);
 
3839
                break;
 
3840
 
 
3841
                case 16:
 
3842
                        ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);
 
3843
                break;
 
3844
 
 
3845
                case 17:
 
3846
                        ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);
 
3847
                break;
 
3848
 
 
3849
                case 18:
 
3850
                        ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);
 
3851
                break;
 
3852
 
 
3853
                case 20:
 
3854
                        ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);
 
3855
                break;
 
3856
 
 
3857
                case 21:
 
3858
                        ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);
 
3859
                break;
 
3860
 
 
3861
                case 23:
 
3862
                        ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);
 
3863
                break;
 
3864
 
 
3865
                case 24:
 
3866
                        ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);
 
3867
                break;
 
3868
 
 
3869
                case 25:
 
3870
                        ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);
 
3871
                break;
 
3872
 
 
3873
                case 26:
 
3874
                        ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);
 
3875
                break;
 
3876
 
 
3877
                default:
 
3878
                        ndr_print_bad_level(ndr, name, level);
 
3879
        }
 
3880
}
 
3881
 
 
3882
_PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)
 
3883
{
 
3884
        if (ndr_flags & NDR_SCALARS) {
 
3885
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3886
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
3887
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));
 
3888
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
3889
        }
 
3890
        if (ndr_flags & NDR_BUFFERS) {
 
3891
        }
 
3892
        return NDR_ERR_SUCCESS;
 
3893
}
 
3894
 
 
3895
_PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)
 
3896
{
 
3897
        if (ndr_flags & NDR_SCALARS) {
 
3898
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3899
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
3900
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));
 
3901
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
3902
        }
 
3903
        if (ndr_flags & NDR_BUFFERS) {
 
3904
        }
 
3905
        return NDR_ERR_SUCCESS;
 
3906
}
 
3907
 
 
3908
_PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)
 
3909
{
 
3910
        ndr_print_struct(ndr, name, "samr_RidWithAttribute");
 
3911
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3912
        ndr->depth++;
 
3913
        ndr_print_uint32(ndr, "rid", r->rid);
 
3914
        ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);
 
3915
        ndr->depth--;
 
3916
}
 
3917
 
 
3918
_PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)
 
3919
{
 
3920
        uint32_t cntr_rids_1;
 
3921
        if (ndr_flags & NDR_SCALARS) {
 
3922
                NDR_CHECK(ndr_push_align(ndr, 5));
 
3923
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
3924
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));
 
3925
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
3926
        }
 
3927
        if (ndr_flags & NDR_BUFFERS) {
 
3928
                if (r->rids) {
 
3929
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
3930
                        for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
 
3931
                                NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
 
3932
                        }
 
3933
                }
 
3934
        }
 
3935
        return NDR_ERR_SUCCESS;
 
3936
}
 
3937
 
 
3938
_PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)
 
3939
{
 
3940
        uint32_t _ptr_rids;
 
3941
        uint32_t cntr_rids_1;
 
3942
        TALLOC_CTX *_mem_save_rids_0;
 
3943
        TALLOC_CTX *_mem_save_rids_1;
 
3944
        if (ndr_flags & NDR_SCALARS) {
 
3945
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
3946
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
3947
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
 
3948
                if (_ptr_rids) {
 
3949
                        NDR_PULL_ALLOC(ndr, r->rids);
 
3950
                } else {
 
3951
                        r->rids = NULL;
 
3952
                }
 
3953
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
3954
        }
 
3955
        if (ndr_flags & NDR_BUFFERS) {
 
3956
                if (r->rids) {
 
3957
                        _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
3958
                        NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 
3959
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
 
3960
                        NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
 
3961
                        _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
3962
                        NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
 
3963
                        for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {
 
3964
                                NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));
 
3965
                        }
 
3966
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
 
3967
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 
3968
                }
 
3969
                if (r->rids) {
 
3970
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));
 
3971
                }
 
3972
        }
 
3973
        return NDR_ERR_SUCCESS;
 
3974
}
 
3975
 
 
3976
_PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)
 
3977
{
 
3978
        uint32_t cntr_rids_1;
 
3979
        ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");
 
3980
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3981
        ndr->depth++;
 
3982
        ndr_print_uint32(ndr, "count", r->count);
 
3983
        ndr_print_ptr(ndr, "rids", r->rids);
 
3984
        ndr->depth++;
 
3985
        if (r->rids) {
 
3986
                ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);
 
3987
                ndr->depth++;
 
3988
                for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {
 
3989
                        ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);
 
3990
                }
 
3991
                ndr->depth--;
 
3992
        }
 
3993
        ndr->depth--;
 
3994
        ndr->depth--;
 
3995
}
 
3996
 
 
3997
static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)
 
3998
{
 
3999
        if (ndr_flags & NDR_SCALARS) {
 
4000
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4001
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
4002
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
4003
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
4004
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
4005
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
4006
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
4007
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4008
        }
 
4009
        if (ndr_flags & NDR_BUFFERS) {
 
4010
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
4011
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
4012
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
4013
        }
 
4014
        return NDR_ERR_SUCCESS;
 
4015
}
 
4016
 
 
4017
static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)
 
4018
{
 
4019
        if (ndr_flags & NDR_SCALARS) {
 
4020
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4021
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
4022
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
4023
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
4024
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
4025
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
4026
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));
 
4027
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4028
        }
 
4029
        if (ndr_flags & NDR_BUFFERS) {
 
4030
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
4031
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
4032
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));
 
4033
        }
 
4034
        return NDR_ERR_SUCCESS;
 
4035
}
 
4036
 
 
4037
_PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)
 
4038
{
 
4039
        ndr_print_struct(ndr, name, "samr_DispEntryGeneral");
 
4040
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4041
        ndr->depth++;
 
4042
        ndr_print_uint32(ndr, "idx", r->idx);
 
4043
        ndr_print_uint32(ndr, "rid", r->rid);
 
4044
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
4045
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
4046
        ndr_print_lsa_String(ndr, "description", &r->description);
 
4047
        ndr_print_lsa_String(ndr, "full_name", &r->full_name);
 
4048
        ndr->depth--;
 
4049
}
 
4050
 
 
4051
static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)
 
4052
{
 
4053
        uint32_t cntr_entries_1;
 
4054
        if (ndr_flags & NDR_SCALARS) {
 
4055
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4056
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
4057
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
4058
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4059
        }
 
4060
        if (ndr_flags & NDR_BUFFERS) {
 
4061
                if (r->entries) {
 
4062
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
4063
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4064
                                NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4065
                        }
 
4066
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4067
                                NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4068
                        }
 
4069
                }
 
4070
        }
 
4071
        return NDR_ERR_SUCCESS;
 
4072
}
 
4073
 
 
4074
static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)
 
4075
{
 
4076
        uint32_t _ptr_entries;
 
4077
        uint32_t cntr_entries_1;
 
4078
        TALLOC_CTX *_mem_save_entries_0;
 
4079
        TALLOC_CTX *_mem_save_entries_1;
 
4080
        if (ndr_flags & NDR_SCALARS) {
 
4081
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4082
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
4083
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
4084
                if (_ptr_entries) {
 
4085
                        NDR_PULL_ALLOC(ndr, r->entries);
 
4086
                } else {
 
4087
                        r->entries = NULL;
 
4088
                }
 
4089
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4090
        }
 
4091
        if (ndr_flags & NDR_BUFFERS) {
 
4092
                if (r->entries) {
 
4093
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4094
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4095
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
4096
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
4097
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
4098
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4099
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4100
                                NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4101
                        }
 
4102
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4103
                                NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4104
                        }
 
4105
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
4106
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
4107
                }
 
4108
                if (r->entries) {
 
4109
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
4110
                }
 
4111
        }
 
4112
        return NDR_ERR_SUCCESS;
 
4113
}
 
4114
 
 
4115
_PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)
 
4116
{
 
4117
        uint32_t cntr_entries_1;
 
4118
        ndr_print_struct(ndr, name, "samr_DispInfoGeneral");
 
4119
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4120
        ndr->depth++;
 
4121
        ndr_print_uint32(ndr, "count", r->count);
 
4122
        ndr_print_ptr(ndr, "entries", r->entries);
 
4123
        ndr->depth++;
 
4124
        if (r->entries) {
 
4125
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
4126
                ndr->depth++;
 
4127
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
4128
                        ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);
 
4129
                }
 
4130
                ndr->depth--;
 
4131
        }
 
4132
        ndr->depth--;
 
4133
        ndr->depth--;
 
4134
}
 
4135
 
 
4136
static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)
 
4137
{
 
4138
        if (ndr_flags & NDR_SCALARS) {
 
4139
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4140
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
4141
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
4142
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));
 
4143
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
4144
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
4145
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4146
        }
 
4147
        if (ndr_flags & NDR_BUFFERS) {
 
4148
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
4149
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
4150
        }
 
4151
        return NDR_ERR_SUCCESS;
 
4152
}
 
4153
 
 
4154
static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)
 
4155
{
 
4156
        if (ndr_flags & NDR_SCALARS) {
 
4157
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4158
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
4159
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
4160
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));
 
4161
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
4162
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
4163
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4164
        }
 
4165
        if (ndr_flags & NDR_BUFFERS) {
 
4166
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
4167
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
4168
        }
 
4169
        return NDR_ERR_SUCCESS;
 
4170
}
 
4171
 
 
4172
_PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)
 
4173
{
 
4174
        ndr_print_struct(ndr, name, "samr_DispEntryFull");
 
4175
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4176
        ndr->depth++;
 
4177
        ndr_print_uint32(ndr, "idx", r->idx);
 
4178
        ndr_print_uint32(ndr, "rid", r->rid);
 
4179
        ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);
 
4180
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
4181
        ndr_print_lsa_String(ndr, "description", &r->description);
 
4182
        ndr->depth--;
 
4183
}
 
4184
 
 
4185
static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)
 
4186
{
 
4187
        uint32_t cntr_entries_1;
 
4188
        if (ndr_flags & NDR_SCALARS) {
 
4189
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4190
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
4191
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
4192
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4193
        }
 
4194
        if (ndr_flags & NDR_BUFFERS) {
 
4195
                if (r->entries) {
 
4196
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
4197
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4198
                                NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4199
                        }
 
4200
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4201
                                NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4202
                        }
 
4203
                }
 
4204
        }
 
4205
        return NDR_ERR_SUCCESS;
 
4206
}
 
4207
 
 
4208
static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)
 
4209
{
 
4210
        uint32_t _ptr_entries;
 
4211
        uint32_t cntr_entries_1;
 
4212
        TALLOC_CTX *_mem_save_entries_0;
 
4213
        TALLOC_CTX *_mem_save_entries_1;
 
4214
        if (ndr_flags & NDR_SCALARS) {
 
4215
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4216
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
4217
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
4218
                if (_ptr_entries) {
 
4219
                        NDR_PULL_ALLOC(ndr, r->entries);
 
4220
                } else {
 
4221
                        r->entries = NULL;
 
4222
                }
 
4223
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4224
        }
 
4225
        if (ndr_flags & NDR_BUFFERS) {
 
4226
                if (r->entries) {
 
4227
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4228
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4229
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
4230
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
4231
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
4232
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4233
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4234
                                NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4235
                        }
 
4236
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4237
                                NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4238
                        }
 
4239
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
4240
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
4241
                }
 
4242
                if (r->entries) {
 
4243
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
4244
                }
 
4245
        }
 
4246
        return NDR_ERR_SUCCESS;
 
4247
}
 
4248
 
 
4249
_PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)
 
4250
{
 
4251
        uint32_t cntr_entries_1;
 
4252
        ndr_print_struct(ndr, name, "samr_DispInfoFull");
 
4253
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4254
        ndr->depth++;
 
4255
        ndr_print_uint32(ndr, "count", r->count);
 
4256
        ndr_print_ptr(ndr, "entries", r->entries);
 
4257
        ndr->depth++;
 
4258
        if (r->entries) {
 
4259
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
4260
                ndr->depth++;
 
4261
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
4262
                        ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);
 
4263
                }
 
4264
                ndr->depth--;
 
4265
        }
 
4266
        ndr->depth--;
 
4267
        ndr->depth--;
 
4268
}
 
4269
 
 
4270
static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)
 
4271
{
 
4272
        if (ndr_flags & NDR_SCALARS) {
 
4273
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4274
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
4275
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
 
4276
                NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));
 
4277
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
4278
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));
 
4279
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4280
        }
 
4281
        if (ndr_flags & NDR_BUFFERS) {
 
4282
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
4283
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
4284
        }
 
4285
        return NDR_ERR_SUCCESS;
 
4286
}
 
4287
 
 
4288
static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)
 
4289
{
 
4290
        if (ndr_flags & NDR_SCALARS) {
 
4291
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4292
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
4293
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
 
4294
                NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));
 
4295
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));
 
4296
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));
 
4297
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4298
        }
 
4299
        if (ndr_flags & NDR_BUFFERS) {
 
4300
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));
 
4301
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));
 
4302
        }
 
4303
        return NDR_ERR_SUCCESS;
 
4304
}
 
4305
 
 
4306
_PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)
 
4307
{
 
4308
        ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");
 
4309
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4310
        ndr->depth++;
 
4311
        ndr_print_uint32(ndr, "idx", r->idx);
 
4312
        ndr_print_uint32(ndr, "rid", r->rid);
 
4313
        ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);
 
4314
        ndr_print_lsa_String(ndr, "account_name", &r->account_name);
 
4315
        ndr_print_lsa_String(ndr, "description", &r->description);
 
4316
        ndr->depth--;
 
4317
}
 
4318
 
 
4319
static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)
 
4320
{
 
4321
        uint32_t cntr_entries_1;
 
4322
        if (ndr_flags & NDR_SCALARS) {
 
4323
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4324
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
4325
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
4326
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4327
        }
 
4328
        if (ndr_flags & NDR_BUFFERS) {
 
4329
                if (r->entries) {
 
4330
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
4331
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4332
                                NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4333
                        }
 
4334
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4335
                                NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4336
                        }
 
4337
                }
 
4338
        }
 
4339
        return NDR_ERR_SUCCESS;
 
4340
}
 
4341
 
 
4342
static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)
 
4343
{
 
4344
        uint32_t _ptr_entries;
 
4345
        uint32_t cntr_entries_1;
 
4346
        TALLOC_CTX *_mem_save_entries_0;
 
4347
        TALLOC_CTX *_mem_save_entries_1;
 
4348
        if (ndr_flags & NDR_SCALARS) {
 
4349
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4350
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
4351
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
4352
                if (_ptr_entries) {
 
4353
                        NDR_PULL_ALLOC(ndr, r->entries);
 
4354
                } else {
 
4355
                        r->entries = NULL;
 
4356
                }
 
4357
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4358
        }
 
4359
        if (ndr_flags & NDR_BUFFERS) {
 
4360
                if (r->entries) {
 
4361
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4362
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4363
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
4364
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
4365
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
4366
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4367
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4368
                                NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4369
                        }
 
4370
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4371
                                NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4372
                        }
 
4373
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
4374
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
4375
                }
 
4376
                if (r->entries) {
 
4377
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
4378
                }
 
4379
        }
 
4380
        return NDR_ERR_SUCCESS;
 
4381
}
 
4382
 
 
4383
_PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)
 
4384
{
 
4385
        uint32_t cntr_entries_1;
 
4386
        ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");
 
4387
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4388
        ndr->depth++;
 
4389
        ndr_print_uint32(ndr, "count", r->count);
 
4390
        ndr_print_ptr(ndr, "entries", r->entries);
 
4391
        ndr->depth++;
 
4392
        if (r->entries) {
 
4393
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
4394
                ndr->depth++;
 
4395
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
4396
                        ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);
 
4397
                }
 
4398
                ndr->depth--;
 
4399
        }
 
4400
        ndr->depth--;
 
4401
        ndr->depth--;
 
4402
}
 
4403
 
 
4404
static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)
 
4405
{
 
4406
        if (ndr_flags & NDR_SCALARS) {
 
4407
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4408
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));
 
4409
                NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
 
4410
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4411
        }
 
4412
        if (ndr_flags & NDR_BUFFERS) {
 
4413
                NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
 
4414
        }
 
4415
        return NDR_ERR_SUCCESS;
 
4416
}
 
4417
 
 
4418
static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)
 
4419
{
 
4420
        if (ndr_flags & NDR_SCALARS) {
 
4421
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4422
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));
 
4423
                NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));
 
4424
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4425
        }
 
4426
        if (ndr_flags & NDR_BUFFERS) {
 
4427
                NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));
 
4428
        }
 
4429
        return NDR_ERR_SUCCESS;
 
4430
}
 
4431
 
 
4432
_PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)
 
4433
{
 
4434
        ndr_print_struct(ndr, name, "samr_DispEntryAscii");
 
4435
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4436
        ndr->depth++;
 
4437
        ndr_print_uint32(ndr, "idx", r->idx);
 
4438
        ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);
 
4439
        ndr->depth--;
 
4440
}
 
4441
 
 
4442
static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)
 
4443
{
 
4444
        uint32_t cntr_entries_1;
 
4445
        if (ndr_flags & NDR_SCALARS) {
 
4446
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4447
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 
4448
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
 
4449
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4450
        }
 
4451
        if (ndr_flags & NDR_BUFFERS) {
 
4452
                if (r->entries) {
 
4453
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
4454
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4455
                                NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4456
                        }
 
4457
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4458
                                NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4459
                        }
 
4460
                }
 
4461
        }
 
4462
        return NDR_ERR_SUCCESS;
 
4463
}
 
4464
 
 
4465
static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)
 
4466
{
 
4467
        uint32_t _ptr_entries;
 
4468
        uint32_t cntr_entries_1;
 
4469
        TALLOC_CTX *_mem_save_entries_0;
 
4470
        TALLOC_CTX *_mem_save_entries_1;
 
4471
        if (ndr_flags & NDR_SCALARS) {
 
4472
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4473
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 
4474
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
 
4475
                if (_ptr_entries) {
 
4476
                        NDR_PULL_ALLOC(ndr, r->entries);
 
4477
                } else {
 
4478
                        r->entries = NULL;
 
4479
                }
 
4480
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4481
        }
 
4482
        if (ndr_flags & NDR_BUFFERS) {
 
4483
                if (r->entries) {
 
4484
                        _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4485
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4486
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
 
4487
                        NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
 
4488
                        _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
4489
                        NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
 
4490
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4491
                                NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));
 
4492
                        }
 
4493
                        for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
 
4494
                                NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));
 
4495
                        }
 
4496
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
 
4497
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
 
4498
                }
 
4499
                if (r->entries) {
 
4500
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
 
4501
                }
 
4502
        }
 
4503
        return NDR_ERR_SUCCESS;
 
4504
}
 
4505
 
 
4506
_PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)
 
4507
{
 
4508
        uint32_t cntr_entries_1;
 
4509
        ndr_print_struct(ndr, name, "samr_DispInfoAscii");
 
4510
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4511
        ndr->depth++;
 
4512
        ndr_print_uint32(ndr, "count", r->count);
 
4513
        ndr_print_ptr(ndr, "entries", r->entries);
 
4514
        ndr->depth++;
 
4515
        if (r->entries) {
 
4516
                ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
 
4517
                ndr->depth++;
 
4518
                for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
 
4519
                        ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);
 
4520
                }
 
4521
                ndr->depth--;
 
4522
        }
 
4523
        ndr->depth--;
 
4524
        ndr->depth--;
 
4525
}
 
4526
 
 
4527
static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)
 
4528
{
 
4529
        if (ndr_flags & NDR_SCALARS) {
 
4530
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
4531
                NDR_CHECK(ndr_push_union_align(ndr, 5));
 
4532
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
4533
                NDR_CHECK(ndr_push_union_align(ndr, 5));
 
4534
                switch (level) {
 
4535
                        case 1: {
 
4536
                                NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
 
4537
                        break; }
 
4538
 
 
4539
                        case 2: {
 
4540
                                NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
 
4541
                        break; }
 
4542
 
 
4543
                        case 3: {
 
4544
                                NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
 
4545
                        break; }
 
4546
 
 
4547
                        case 4: {
 
4548
                                NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
 
4549
                        break; }
 
4550
 
 
4551
                        case 5: {
 
4552
                                NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
 
4553
                        break; }
 
4554
 
 
4555
                        default:
 
4556
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
4557
                }
 
4558
        }
 
4559
        if (ndr_flags & NDR_BUFFERS) {
 
4560
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
4561
                switch (level) {
 
4562
                        case 1:
 
4563
                                NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
 
4564
                        break;
 
4565
 
 
4566
                        case 2:
 
4567
                                NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
 
4568
                        break;
 
4569
 
 
4570
                        case 3:
 
4571
                                NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
 
4572
                        break;
 
4573
 
 
4574
                        case 4:
 
4575
                                NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
 
4576
                        break;
 
4577
 
 
4578
                        case 5:
 
4579
                                NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
 
4580
                        break;
 
4581
 
 
4582
                        default:
 
4583
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
4584
                }
 
4585
        }
 
4586
        return NDR_ERR_SUCCESS;
 
4587
}
 
4588
 
 
4589
static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)
 
4590
{
 
4591
        uint32_t level;
 
4592
        uint16_t _level;
 
4593
        level = ndr_pull_get_switch_value(ndr, r);
 
4594
        if (ndr_flags & NDR_SCALARS) {
 
4595
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
 
4596
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
4597
                if (_level != level) {
 
4598
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
4599
                }
 
4600
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
 
4601
                switch (level) {
 
4602
                        case 1: {
 
4603
                                NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));
 
4604
                        break; }
 
4605
 
 
4606
                        case 2: {
 
4607
                                NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));
 
4608
                        break; }
 
4609
 
 
4610
                        case 3: {
 
4611
                                NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));
 
4612
                        break; }
 
4613
 
 
4614
                        case 4: {
 
4615
                                NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));
 
4616
                        break; }
 
4617
 
 
4618
                        case 5: {
 
4619
                                NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));
 
4620
                        break; }
 
4621
 
 
4622
                        default:
 
4623
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
4624
                }
 
4625
        }
 
4626
        if (ndr_flags & NDR_BUFFERS) {
 
4627
                switch (level) {
 
4628
                        case 1:
 
4629
                                NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));
 
4630
                        break;
 
4631
 
 
4632
                        case 2:
 
4633
                                NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));
 
4634
                        break;
 
4635
 
 
4636
                        case 3:
 
4637
                                NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));
 
4638
                        break;
 
4639
 
 
4640
                        case 4:
 
4641
                                NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));
 
4642
                        break;
 
4643
 
 
4644
                        case 5:
 
4645
                                NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));
 
4646
                        break;
 
4647
 
 
4648
                        default:
 
4649
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
4650
                }
 
4651
        }
 
4652
        return NDR_ERR_SUCCESS;
 
4653
}
 
4654
 
 
4655
_PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)
 
4656
{
 
4657
        uint32_t level;
 
4658
        level = ndr_print_get_switch_value(ndr, r);
 
4659
        ndr_print_union(ndr, name, level, "samr_DispInfo");
 
4660
        switch (level) {
 
4661
                case 1:
 
4662
                        ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);
 
4663
                break;
 
4664
 
 
4665
                case 2:
 
4666
                        ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);
 
4667
                break;
 
4668
 
 
4669
                case 3:
 
4670
                        ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);
 
4671
                break;
 
4672
 
 
4673
                case 4:
 
4674
                        ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);
 
4675
                break;
 
4676
 
 
4677
                case 5:
 
4678
                        ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);
 
4679
                break;
 
4680
 
 
4681
                default:
 
4682
                        ndr_print_bad_level(ndr, name, level);
 
4683
        }
 
4684
}
 
4685
 
 
4686
static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)
 
4687
{
 
4688
        if (ndr_flags & NDR_SCALARS) {
 
4689
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4690
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));
 
4691
                NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));
 
4692
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
4693
        }
 
4694
        if (ndr_flags & NDR_BUFFERS) {
 
4695
        }
 
4696
        return NDR_ERR_SUCCESS;
 
4697
}
 
4698
 
 
4699
static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)
 
4700
{
 
4701
        if (ndr_flags & NDR_SCALARS) {
 
4702
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4703
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));
 
4704
                NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));
 
4705
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
4706
        }
 
4707
        if (ndr_flags & NDR_BUFFERS) {
 
4708
        }
 
4709
        return NDR_ERR_SUCCESS;
 
4710
}
 
4711
 
 
4712
_PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)
 
4713
{
 
4714
        ndr_print_struct(ndr, name, "samr_PwInfo");
 
4715
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4716
        ndr->depth++;
 
4717
        ndr_print_uint16(ndr, "min_password_length", r->min_password_length);
 
4718
        ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);
 
4719
        ndr->depth--;
 
4720
}
 
4721
 
 
4722
static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)
 
4723
{
 
4724
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
4725
        return NDR_ERR_SUCCESS;
 
4726
}
 
4727
 
 
4728
static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)
 
4729
{
 
4730
        uint32_t v;
 
4731
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
4732
        *r = v;
 
4733
        return NDR_ERR_SUCCESS;
 
4734
}
 
4735
 
 
4736
_PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)
 
4737
{
 
4738
        const char *val = NULL;
 
4739
 
 
4740
        switch (r) {
 
4741
                case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;
 
4742
                case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;
 
4743
                case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;
 
4744
        }
 
4745
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
4746
}
 
4747
 
 
4748
_PUBLIC_ enum ndr_err_code ndr_push_samPwdChangeReason(struct ndr_push *ndr, int ndr_flags, enum samPwdChangeReason r)
 
4749
{
 
4750
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
4751
        return NDR_ERR_SUCCESS;
 
4752
}
 
4753
 
 
4754
_PUBLIC_ enum ndr_err_code ndr_pull_samPwdChangeReason(struct ndr_pull *ndr, int ndr_flags, enum samPwdChangeReason *r)
 
4755
{
 
4756
        uint32_t v;
 
4757
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
4758
        *r = v;
 
4759
        return NDR_ERR_SUCCESS;
 
4760
}
 
4761
 
 
4762
_PUBLIC_ void ndr_print_samPwdChangeReason(struct ndr_print *ndr, const char *name, enum samPwdChangeReason r)
 
4763
{
 
4764
        const char *val = NULL;
 
4765
 
 
4766
        switch (r) {
 
4767
                case SAM_PWD_CHANGE_NO_ERROR: val = "SAM_PWD_CHANGE_NO_ERROR"; break;
 
4768
                case SAM_PWD_CHANGE_PASSWORD_TOO_SHORT: val = "SAM_PWD_CHANGE_PASSWORD_TOO_SHORT"; break;
 
4769
                case SAM_PWD_CHANGE_PWD_IN_HISTORY: val = "SAM_PWD_CHANGE_PWD_IN_HISTORY"; break;
 
4770
                case SAM_PWD_CHANGE_USERNAME_IN_PASSWORD: val = "SAM_PWD_CHANGE_USERNAME_IN_PASSWORD"; break;
 
4771
                case SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD: val = "SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD"; break;
 
4772
                case SAM_PWD_CHANGE_NOT_COMPLEX: val = "SAM_PWD_CHANGE_NOT_COMPLEX"; break;
 
4773
                case SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT: val = "SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT"; break;
 
4774
                case SAM_PWD_CHANGE_FAILED_BY_FILTER: val = "SAM_PWD_CHANGE_FAILED_BY_FILTER"; break;
 
4775
                case SAM_PWD_CHANGE_PASSWORD_TOO_LONG: val = "SAM_PWD_CHANGE_PASSWORD_TOO_LONG"; break;
 
4776
        }
 
4777
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
4778
}
 
4779
 
 
4780
static enum ndr_err_code ndr_push_userPwdChangeFailureInformation(struct ndr_push *ndr, int ndr_flags, const struct userPwdChangeFailureInformation *r)
 
4781
{
 
4782
        if (ndr_flags & NDR_SCALARS) {
 
4783
                NDR_CHECK(ndr_push_align(ndr, 5));
 
4784
                NDR_CHECK(ndr_push_samPwdChangeReason(ndr, NDR_SCALARS, r->extendedFailureReason));
 
4785
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->filterModuleName));
 
4786
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
4787
        }
 
4788
        if (ndr_flags & NDR_BUFFERS) {
 
4789
                if (r->filterModuleName) {
 
4790
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->filterModuleName, CH_UTF16)));
 
4791
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
4792
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->filterModuleName, CH_UTF16)));
 
4793
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->filterModuleName, ndr_charset_length(r->filterModuleName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
4794
                }
 
4795
        }
 
4796
        return NDR_ERR_SUCCESS;
 
4797
}
 
4798
 
 
4799
static enum ndr_err_code ndr_pull_userPwdChangeFailureInformation(struct ndr_pull *ndr, int ndr_flags, struct userPwdChangeFailureInformation *r)
 
4800
{
 
4801
        uint32_t _ptr_filterModuleName;
 
4802
        TALLOC_CTX *_mem_save_filterModuleName_0;
 
4803
        if (ndr_flags & NDR_SCALARS) {
 
4804
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
4805
                NDR_CHECK(ndr_pull_samPwdChangeReason(ndr, NDR_SCALARS, &r->extendedFailureReason));
 
4806
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_filterModuleName));
 
4807
                if (_ptr_filterModuleName) {
 
4808
                        NDR_PULL_ALLOC(ndr, r->filterModuleName);
 
4809
                } else {
 
4810
                        r->filterModuleName = NULL;
 
4811
                }
 
4812
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
4813
        }
 
4814
        if (ndr_flags & NDR_BUFFERS) {
 
4815
                if (r->filterModuleName) {
 
4816
                        _mem_save_filterModuleName_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
4817
                        NDR_PULL_SET_MEM_CTX(ndr, r->filterModuleName, 0);
 
4818
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->filterModuleName));
 
4819
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->filterModuleName));
 
4820
                        if (ndr_get_array_length(ndr, &r->filterModuleName) > ndr_get_array_size(ndr, &r->filterModuleName)) {
 
4821
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->filterModuleName), ndr_get_array_length(ndr, &r->filterModuleName));
 
4822
                        }
 
4823
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->filterModuleName), sizeof(uint16_t)));
 
4824
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->filterModuleName, ndr_get_array_length(ndr, &r->filterModuleName), sizeof(uint16_t), CH_UTF16));
 
4825
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filterModuleName_0, 0);
 
4826
                }
 
4827
        }
 
4828
        return NDR_ERR_SUCCESS;
 
4829
}
 
4830
 
 
4831
_PUBLIC_ void ndr_print_userPwdChangeFailureInformation(struct ndr_print *ndr, const char *name, const struct userPwdChangeFailureInformation *r)
 
4832
{
 
4833
        ndr_print_struct(ndr, name, "userPwdChangeFailureInformation");
 
4834
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4835
        ndr->depth++;
 
4836
        ndr_print_samPwdChangeReason(ndr, "extendedFailureReason", r->extendedFailureReason);
 
4837
        ndr_print_ptr(ndr, "filterModuleName", r->filterModuleName);
 
4838
        ndr->depth++;
 
4839
        if (r->filterModuleName) {
 
4840
                ndr_print_string(ndr, "filterModuleName", r->filterModuleName);
 
4841
        }
 
4842
        ndr->depth--;
 
4843
        ndr->depth--;
 
4844
}
 
4845
 
 
4846
static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)
 
4847
{
 
4848
        if (ndr_flags & NDR_SCALARS) {
 
4849
                NDR_CHECK(ndr_push_align(ndr, 4));
 
4850
                NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));
 
4851
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
 
4852
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
4853
        }
 
4854
        if (ndr_flags & NDR_BUFFERS) {
 
4855
        }
 
4856
        return NDR_ERR_SUCCESS;
 
4857
}
 
4858
 
 
4859
static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)
 
4860
{
 
4861
        if (ndr_flags & NDR_SCALARS) {
 
4862
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
4863
                NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));
 
4864
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
 
4865
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
4866
        }
 
4867
        if (ndr_flags & NDR_BUFFERS) {
 
4868
        }
 
4869
        return NDR_ERR_SUCCESS;
 
4870
}
 
4871
 
 
4872
_PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)
 
4873
{
 
4874
        ndr_print_struct(ndr, name, "samr_ConnectInfo1");
 
4875
        if (r == NULL) { ndr_print_null(ndr); return; }
 
4876
        ndr->depth++;
 
4877
        ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);
 
4878
        ndr_print_uint32(ndr, "unknown2", r->unknown2);
 
4879
        ndr->depth--;
 
4880
}
 
4881
 
 
4882
static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)
 
4883
{
 
4884
        if (ndr_flags & NDR_SCALARS) {
 
4885
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
4886
                NDR_CHECK(ndr_push_union_align(ndr, 4));
 
4887
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 
4888
                NDR_CHECK(ndr_push_union_align(ndr, 4));
 
4889
                switch (level) {
 
4890
                        case 1: {
 
4891
                                NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
 
4892
                        break; }
 
4893
 
 
4894
                        default:
 
4895
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
4896
                }
 
4897
        }
 
4898
        if (ndr_flags & NDR_BUFFERS) {
 
4899
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
4900
                switch (level) {
 
4901
                        case 1:
 
4902
                        break;
 
4903
 
 
4904
                        default:
 
4905
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
4906
                }
 
4907
        }
 
4908
        return NDR_ERR_SUCCESS;
 
4909
}
 
4910
 
 
4911
static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)
 
4912
{
 
4913
        uint32_t level;
 
4914
        uint32_t _level;
 
4915
        level = ndr_pull_get_switch_value(ndr, r);
 
4916
        if (ndr_flags & NDR_SCALARS) {
 
4917
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
 
4918
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 
4919
                if (_level != level) {
 
4920
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
4921
                }
 
4922
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
 
4923
                switch (level) {
 
4924
                        case 1: {
 
4925
                                NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));
 
4926
                        break; }
 
4927
 
 
4928
                        default:
 
4929
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
4930
                }
 
4931
        }
 
4932
        if (ndr_flags & NDR_BUFFERS) {
 
4933
                switch (level) {
 
4934
                        case 1:
 
4935
                        break;
 
4936
 
 
4937
                        default:
 
4938
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
4939
                }
 
4940
        }
 
4941
        return NDR_ERR_SUCCESS;
 
4942
}
 
4943
 
 
4944
_PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)
 
4945
{
 
4946
        uint32_t level;
 
4947
        level = ndr_print_get_switch_value(ndr, r);
 
4948
        ndr_print_union(ndr, name, level, "samr_ConnectInfo");
 
4949
        switch (level) {
 
4950
                case 1:
 
4951
                        ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);
 
4952
                break;
 
4953
 
 
4954
                default:
 
4955
                        ndr_print_bad_level(ndr, name, level);
 
4956
        }
 
4957
}
 
4958
 
 
4959
static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
4960
{
 
4961
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
4962
        return NDR_ERR_SUCCESS;
 
4963
}
 
4964
 
 
4965
static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
4966
{
 
4967
        uint32_t v;
 
4968
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
4969
        *r = v;
 
4970
        return NDR_ERR_SUCCESS;
 
4971
}
 
4972
 
 
4973
_PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)
 
4974
{
 
4975
        ndr_print_uint32(ndr, name, r);
 
4976
        ndr->depth++;
 
4977
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);
 
4978
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);
 
4979
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);
 
4980
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);
 
4981
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);
 
4982
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);
 
4983
        ndr->depth--;
 
4984
}
 
4985
 
 
4986
static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)
 
4987
{
 
4988
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
4989
        return NDR_ERR_SUCCESS;
 
4990
}
 
4991
 
 
4992
static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)
 
4993
{
 
4994
        uint16_t v;
 
4995
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
4996
        *r = v;
 
4997
        return NDR_ERR_SUCCESS;
 
4998
}
 
4999
 
 
5000
_PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)
 
5001
{
 
5002
        const char *val = NULL;
 
5003
 
 
5004
        switch (r) {
 
5005
                case NetValidateAuthentication: val = "NetValidateAuthentication"; break;
 
5006
                case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;
 
5007
                case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;
 
5008
        }
 
5009
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
5010
}
 
5011
 
 
5012
static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)
 
5013
{
 
5014
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
5015
        return NDR_ERR_SUCCESS;
 
5016
}
 
5017
 
 
5018
static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)
 
5019
{
 
5020
        uint16_t v;
 
5021
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
5022
        *r = v;
 
5023
        return NDR_ERR_SUCCESS;
 
5024
}
 
5025
 
 
5026
_PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)
 
5027
{
 
5028
        const char *val = NULL;
 
5029
 
 
5030
        switch (r) {
 
5031
                case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;
 
5032
                case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;
 
5033
                case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;
 
5034
                case SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED: val = "SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED"; break;
 
5035
                case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;
 
5036
                case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;
 
5037
                case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;
 
5038
                case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;
 
5039
                case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;
 
5040
                case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;
 
5041
                case SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR: val = "SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR"; break;
 
5042
        }
 
5043
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
5044
}
 
5045
 
 
5046
static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)
 
5047
{
 
5048
        if (ndr_flags & NDR_SCALARS) {
 
5049
                NDR_CHECK(ndr_push_align(ndr, 5));
 
5050
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 
5051
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
 
5052
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
5053
        }
 
5054
        if (ndr_flags & NDR_BUFFERS) {
 
5055
                if (r->data) {
 
5056
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
 
5057
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
 
5058
                }
 
5059
        }
 
5060
        return NDR_ERR_SUCCESS;
 
5061
}
 
5062
 
 
5063
static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)
 
5064
{
 
5065
        uint32_t _ptr_data;
 
5066
        TALLOC_CTX *_mem_save_data_0;
 
5067
        if (ndr_flags & NDR_SCALARS) {
 
5068
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
5069
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 
5070
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
 
5071
                if (_ptr_data) {
 
5072
                        NDR_PULL_ALLOC(ndr, r->data);
 
5073
                } else {
 
5074
                        r->data = NULL;
 
5075
                }
 
5076
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
5077
        }
 
5078
        if (ndr_flags & NDR_BUFFERS) {
 
5079
                if (r->data) {
 
5080
                        _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5081
                        NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
 
5082
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
 
5083
                        NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
 
5084
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
 
5085
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
 
5086
                }
 
5087
                if (r->data) {
 
5088
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
 
5089
                }
 
5090
        }
 
5091
        return NDR_ERR_SUCCESS;
 
5092
}
 
5093
 
 
5094
_PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)
 
5095
{
 
5096
        ndr_print_struct(ndr, name, "samr_ValidationBlob");
 
5097
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5098
        ndr->depth++;
 
5099
        ndr_print_uint32(ndr, "length", r->length);
 
5100
        ndr_print_ptr(ndr, "data", r->data);
 
5101
        ndr->depth++;
 
5102
        if (r->data) {
 
5103
                ndr_print_array_uint8(ndr, "data", r->data, r->length);
 
5104
        }
 
5105
        ndr->depth--;
 
5106
        ndr->depth--;
 
5107
}
 
5108
 
 
5109
static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)
 
5110
{
 
5111
        uint32_t cntr_pwd_history_1;
 
5112
        if (ndr_flags & NDR_SCALARS) {
 
5113
                NDR_CHECK(ndr_push_align(ndr, 8));
 
5114
                NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));
 
5115
                NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));
 
5116
                NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));
 
5117
                NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));
 
5118
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));
 
5119
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));
 
5120
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));
 
5121
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
5122
        }
 
5123
        if (ndr_flags & NDR_BUFFERS) {
 
5124
                if (r->pwd_history) {
 
5125
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->pwd_history_len));
 
5126
                        for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
 
5127
                                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
 
5128
                        }
 
5129
                        for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
 
5130
                                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
 
5131
                        }
 
5132
                }
 
5133
        }
 
5134
        return NDR_ERR_SUCCESS;
 
5135
}
 
5136
 
 
5137
static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)
 
5138
{
 
5139
        uint32_t _ptr_pwd_history;
 
5140
        uint32_t cntr_pwd_history_1;
 
5141
        TALLOC_CTX *_mem_save_pwd_history_0;
 
5142
        TALLOC_CTX *_mem_save_pwd_history_1;
 
5143
        if (ndr_flags & NDR_SCALARS) {
 
5144
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
5145
                NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));
 
5146
                NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));
 
5147
                NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));
 
5148
                NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));
 
5149
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));
 
5150
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));
 
5151
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));
 
5152
                if (_ptr_pwd_history) {
 
5153
                        NDR_PULL_ALLOC(ndr, r->pwd_history);
 
5154
                } else {
 
5155
                        r->pwd_history = NULL;
 
5156
                }
 
5157
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
5158
        }
 
5159
        if (ndr_flags & NDR_BUFFERS) {
 
5160
                if (r->pwd_history) {
 
5161
                        _mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5162
                        NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
 
5163
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));
 
5164
                        NDR_PULL_ALLOC_N(ndr, r->pwd_history, ndr_get_array_size(ndr, &r->pwd_history));
 
5165
                        _mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
5166
                        NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);
 
5167
                        for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
 
5168
                                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));
 
5169
                        }
 
5170
                        for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {
 
5171
                                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));
 
5172
                        }
 
5173
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);
 
5174
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);
 
5175
                }
 
5176
                if (r->pwd_history) {
 
5177
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));
 
5178
                }
 
5179
        }
 
5180
        return NDR_ERR_SUCCESS;
 
5181
}
 
5182
 
 
5183
_PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)
 
5184
{
 
5185
        uint32_t cntr_pwd_history_1;
 
5186
        ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");
 
5187
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5188
        ndr->depth++;
 
5189
        ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);
 
5190
        ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);
 
5191
        ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);
 
5192
        ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);
 
5193
        ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);
 
5194
        ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);
 
5195
        ndr_print_ptr(ndr, "pwd_history", r->pwd_history);
 
5196
        ndr->depth++;
 
5197
        if (r->pwd_history) {
 
5198
                ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);
 
5199
                ndr->depth++;
 
5200
                for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {
 
5201
                        ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);
 
5202
                }
 
5203
                ndr->depth--;
 
5204
        }
 
5205
        ndr->depth--;
 
5206
        ndr->depth--;
 
5207
}
 
5208
 
 
5209
static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)
 
5210
{
 
5211
        if (ndr_flags & NDR_SCALARS) {
 
5212
                NDR_CHECK(ndr_push_align(ndr, 8));
 
5213
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5214
                NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));
 
5215
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
5216
        }
 
5217
        if (ndr_flags & NDR_BUFFERS) {
 
5218
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5219
        }
 
5220
        return NDR_ERR_SUCCESS;
 
5221
}
 
5222
 
 
5223
static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)
 
5224
{
 
5225
        if (ndr_flags & NDR_SCALARS) {
 
5226
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
5227
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5228
                NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));
 
5229
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
5230
        }
 
5231
        if (ndr_flags & NDR_BUFFERS) {
 
5232
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5233
        }
 
5234
        return NDR_ERR_SUCCESS;
 
5235
}
 
5236
 
 
5237
_PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)
 
5238
{
 
5239
        ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");
 
5240
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5241
        ndr->depth++;
 
5242
        ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
 
5243
        ndr_print_samr_ValidationStatus(ndr, "status", r->status);
 
5244
        ndr->depth--;
 
5245
}
 
5246
 
 
5247
static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)
 
5248
{
 
5249
        if (ndr_flags & NDR_SCALARS) {
 
5250
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
5251
                NDR_CHECK(ndr_push_union_align(ndr, 8));
 
5252
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
5253
                NDR_CHECK(ndr_push_union_align(ndr, 8));
 
5254
                switch (level) {
 
5255
                        case 1: {
 
5256
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
 
5257
                        break; }
 
5258
 
 
5259
                        case 2: {
 
5260
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
 
5261
                        break; }
 
5262
 
 
5263
                        case 3: {
 
5264
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
 
5265
                        break; }
 
5266
 
 
5267
                        default:
 
5268
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
5269
                }
 
5270
        }
 
5271
        if (ndr_flags & NDR_BUFFERS) {
 
5272
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
5273
                switch (level) {
 
5274
                        case 1:
 
5275
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
 
5276
                        break;
 
5277
 
 
5278
                        case 2:
 
5279
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
 
5280
                        break;
 
5281
 
 
5282
                        case 3:
 
5283
                                NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
 
5284
                        break;
 
5285
 
 
5286
                        default:
 
5287
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
5288
                }
 
5289
        }
 
5290
        return NDR_ERR_SUCCESS;
 
5291
}
 
5292
 
 
5293
static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)
 
5294
{
 
5295
        uint32_t level;
 
5296
        uint16_t _level;
 
5297
        level = ndr_pull_get_switch_value(ndr, r);
 
5298
        if (ndr_flags & NDR_SCALARS) {
 
5299
                NDR_CHECK(ndr_pull_union_align(ndr, 8));
 
5300
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
5301
                if (_level != level) {
 
5302
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
5303
                }
 
5304
                NDR_CHECK(ndr_pull_union_align(ndr, 8));
 
5305
                switch (level) {
 
5306
                        case 1: {
 
5307
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));
 
5308
                        break; }
 
5309
 
 
5310
                        case 2: {
 
5311
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));
 
5312
                        break; }
 
5313
 
 
5314
                        case 3: {
 
5315
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));
 
5316
                        break; }
 
5317
 
 
5318
                        default:
 
5319
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
5320
                }
 
5321
        }
 
5322
        if (ndr_flags & NDR_BUFFERS) {
 
5323
                switch (level) {
 
5324
                        case 1:
 
5325
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));
 
5326
                        break;
 
5327
 
 
5328
                        case 2:
 
5329
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));
 
5330
                        break;
 
5331
 
 
5332
                        case 3:
 
5333
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));
 
5334
                        break;
 
5335
 
 
5336
                        default:
 
5337
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
5338
                }
 
5339
        }
 
5340
        return NDR_ERR_SUCCESS;
 
5341
}
 
5342
 
 
5343
_PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)
 
5344
{
 
5345
        uint32_t level;
 
5346
        level = ndr_print_get_switch_value(ndr, r);
 
5347
        ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");
 
5348
        switch (level) {
 
5349
                case 1:
 
5350
                        ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);
 
5351
                break;
 
5352
 
 
5353
                case 2:
 
5354
                        ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);
 
5355
                break;
 
5356
 
 
5357
                case 3:
 
5358
                        ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);
 
5359
                break;
 
5360
 
 
5361
                default:
 
5362
                        ndr_print_bad_level(ndr, name, level);
 
5363
        }
 
5364
}
 
5365
 
 
5366
static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)
 
5367
{
 
5368
        if (ndr_flags & NDR_SCALARS) {
 
5369
                NDR_CHECK(ndr_push_align(ndr, 8));
 
5370
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5371
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
 
5372
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
 
5373
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
 
5374
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));
 
5375
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));
 
5376
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
5377
        }
 
5378
        if (ndr_flags & NDR_BUFFERS) {
 
5379
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5380
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
 
5381
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
 
5382
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
 
5383
        }
 
5384
        return NDR_ERR_SUCCESS;
 
5385
}
 
5386
 
 
5387
static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)
 
5388
{
 
5389
        if (ndr_flags & NDR_SCALARS) {
 
5390
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
5391
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5392
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
 
5393
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
 
5394
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
 
5395
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));
 
5396
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));
 
5397
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
5398
        }
 
5399
        if (ndr_flags & NDR_BUFFERS) {
 
5400
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5401
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
 
5402
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
 
5403
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
 
5404
        }
 
5405
        return NDR_ERR_SUCCESS;
 
5406
}
 
5407
 
 
5408
_PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)
 
5409
{
 
5410
        ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");
 
5411
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5412
        ndr->depth++;
 
5413
        ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
 
5414
        ndr_print_lsa_StringLarge(ndr, "password", &r->password);
 
5415
        ndr_print_lsa_StringLarge(ndr, "account", &r->account);
 
5416
        ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
 
5417
        ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);
 
5418
        ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);
 
5419
        ndr->depth--;
 
5420
}
 
5421
 
 
5422
static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)
 
5423
{
 
5424
        if (ndr_flags & NDR_SCALARS) {
 
5425
                NDR_CHECK(ndr_push_align(ndr, 8));
 
5426
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5427
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
 
5428
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
 
5429
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
 
5430
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
 
5431
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
5432
        }
 
5433
        if (ndr_flags & NDR_BUFFERS) {
 
5434
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5435
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
 
5436
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
 
5437
                NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
 
5438
        }
 
5439
        return NDR_ERR_SUCCESS;
 
5440
}
 
5441
 
 
5442
static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)
 
5443
{
 
5444
        if (ndr_flags & NDR_SCALARS) {
 
5445
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
5446
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5447
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));
 
5448
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));
 
5449
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));
 
5450
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
 
5451
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
5452
        }
 
5453
        if (ndr_flags & NDR_BUFFERS) {
 
5454
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5455
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));
 
5456
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));
 
5457
                NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));
 
5458
        }
 
5459
        return NDR_ERR_SUCCESS;
 
5460
}
 
5461
 
 
5462
_PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)
 
5463
{
 
5464
        ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");
 
5465
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5466
        ndr->depth++;
 
5467
        ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
 
5468
        ndr_print_lsa_StringLarge(ndr, "password", &r->password);
 
5469
        ndr_print_lsa_StringLarge(ndr, "account", &r->account);
 
5470
        ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);
 
5471
        ndr_print_uint8(ndr, "password_matched", r->password_matched);
 
5472
        ndr->depth--;
 
5473
}
 
5474
 
 
5475
static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)
 
5476
{
 
5477
        if (ndr_flags & NDR_SCALARS) {
 
5478
                NDR_CHECK(ndr_push_align(ndr, 8));
 
5479
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5480
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));
 
5481
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
5482
        }
 
5483
        if (ndr_flags & NDR_BUFFERS) {
 
5484
                NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5485
        }
 
5486
        return NDR_ERR_SUCCESS;
 
5487
}
 
5488
 
 
5489
static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *r)
 
5490
{
 
5491
        if (ndr_flags & NDR_SCALARS) {
 
5492
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
5493
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));
 
5494
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));
 
5495
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
5496
        }
 
5497
        if (ndr_flags & NDR_BUFFERS) {
 
5498
                NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));
 
5499
        }
 
5500
        return NDR_ERR_SUCCESS;
 
5501
}
 
5502
 
 
5503
_PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)
 
5504
{
 
5505
        ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");
 
5506
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5507
        ndr->depth++;
 
5508
        ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);
 
5509
        ndr_print_uint8(ndr, "password_matched", r->password_matched);
 
5510
        ndr->depth--;
 
5511
}
 
5512
 
 
5513
static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)
 
5514
{
 
5515
        if (ndr_flags & NDR_SCALARS) {
 
5516
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
5517
                NDR_CHECK(ndr_push_union_align(ndr, 8));
 
5518
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
5519
                NDR_CHECK(ndr_push_union_align(ndr, 8));
 
5520
                switch (level) {
 
5521
                        case 1: {
 
5522
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
 
5523
                        break; }
 
5524
 
 
5525
                        case 2: {
 
5526
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
 
5527
                        break; }
 
5528
 
 
5529
                        case 3: {
 
5530
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
 
5531
                        break; }
 
5532
 
 
5533
                        default:
 
5534
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
5535
                }
 
5536
        }
 
5537
        if (ndr_flags & NDR_BUFFERS) {
 
5538
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
5539
                switch (level) {
 
5540
                        case 1:
 
5541
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
 
5542
                        break;
 
5543
 
 
5544
                        case 2:
 
5545
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
 
5546
                        break;
 
5547
 
 
5548
                        case 3:
 
5549
                                NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
 
5550
                        break;
 
5551
 
 
5552
                        default:
 
5553
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
5554
                }
 
5555
        }
 
5556
        return NDR_ERR_SUCCESS;
 
5557
}
 
5558
 
 
5559
static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)
 
5560
{
 
5561
        uint32_t level;
 
5562
        uint16_t _level;
 
5563
        level = ndr_pull_get_switch_value(ndr, r);
 
5564
        if (ndr_flags & NDR_SCALARS) {
 
5565
                NDR_CHECK(ndr_pull_union_align(ndr, 8));
 
5566
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
5567
                if (_level != level) {
 
5568
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
5569
                }
 
5570
                NDR_CHECK(ndr_pull_union_align(ndr, 8));
 
5571
                switch (level) {
 
5572
                        case 1: {
 
5573
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));
 
5574
                        break; }
 
5575
 
 
5576
                        case 2: {
 
5577
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));
 
5578
                        break; }
 
5579
 
 
5580
                        case 3: {
 
5581
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));
 
5582
                        break; }
 
5583
 
 
5584
                        default:
 
5585
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
5586
                }
 
5587
        }
 
5588
        if (ndr_flags & NDR_BUFFERS) {
 
5589
                switch (level) {
 
5590
                        case 1:
 
5591
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));
 
5592
                        break;
 
5593
 
 
5594
                        case 2:
 
5595
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));
 
5596
                        break;
 
5597
 
 
5598
                        case 3:
 
5599
                                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));
 
5600
                        break;
 
5601
 
 
5602
                        default:
 
5603
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
5604
                }
 
5605
        }
 
5606
        return NDR_ERR_SUCCESS;
 
5607
}
 
5608
 
 
5609
_PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)
 
5610
{
 
5611
        uint32_t level;
 
5612
        level = ndr_print_get_switch_value(ndr, r);
 
5613
        ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");
 
5614
        switch (level) {
 
5615
                case 1:
 
5616
                        ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);
 
5617
                break;
 
5618
 
 
5619
                case 2:
 
5620
                        ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);
 
5621
                break;
 
5622
 
 
5623
                case 3:
 
5624
                        ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);
 
5625
                break;
 
5626
 
 
5627
                default:
 
5628
                        ndr_print_bad_level(ndr, name, level);
 
5629
        }
 
5630
}
 
5631
 
 
5632
static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)
 
5633
{
 
5634
        if (flags & NDR_IN) {
 
5635
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
5636
                if (r->in.system_name) {
 
5637
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
 
5638
                }
 
5639
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
5640
        }
 
5641
        if (flags & NDR_OUT) {
 
5642
                if (r->out.connect_handle == NULL) {
 
5643
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5644
                }
 
5645
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
5646
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5647
        }
 
5648
        return NDR_ERR_SUCCESS;
 
5649
}
 
5650
 
 
5651
static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)
 
5652
{
 
5653
        uint32_t _ptr_system_name;
 
5654
        TALLOC_CTX *_mem_save_system_name_0;
 
5655
        TALLOC_CTX *_mem_save_connect_handle_0;
 
5656
        if (flags & NDR_IN) {
 
5657
                ZERO_STRUCT(r->out);
 
5658
 
 
5659
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
5660
                if (_ptr_system_name) {
 
5661
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
5662
                } else {
 
5663
                        r->in.system_name = NULL;
 
5664
                }
 
5665
                if (r->in.system_name) {
 
5666
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5667
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
5668
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
 
5669
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
5670
                }
 
5671
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
5672
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
5673
                ZERO_STRUCTP(r->out.connect_handle);
 
5674
        }
 
5675
        if (flags & NDR_OUT) {
 
5676
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5677
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
5678
                }
 
5679
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5680
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
5681
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
5682
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5683
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5684
        }
 
5685
        return NDR_ERR_SUCCESS;
 
5686
}
 
5687
 
 
5688
_PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)
 
5689
{
 
5690
        ndr_print_struct(ndr, name, "samr_Connect");
 
5691
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5692
        ndr->depth++;
 
5693
        if (flags & NDR_SET_VALUES) {
 
5694
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5695
        }
 
5696
        if (flags & NDR_IN) {
 
5697
                ndr_print_struct(ndr, "in", "samr_Connect");
 
5698
                ndr->depth++;
 
5699
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
5700
                ndr->depth++;
 
5701
                if (r->in.system_name) {
 
5702
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
 
5703
                }
 
5704
                ndr->depth--;
 
5705
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
5706
                ndr->depth--;
 
5707
        }
 
5708
        if (flags & NDR_OUT) {
 
5709
                ndr_print_struct(ndr, "out", "samr_Connect");
 
5710
                ndr->depth++;
 
5711
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
5712
                ndr->depth++;
 
5713
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
5714
                ndr->depth--;
 
5715
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5716
                ndr->depth--;
 
5717
        }
 
5718
        ndr->depth--;
 
5719
}
 
5720
 
 
5721
_PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)
 
5722
{
 
5723
        if (flags & NDR_IN) {
 
5724
                if (r->in.handle == NULL) {
 
5725
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5726
                }
 
5727
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5728
        }
 
5729
        if (flags & NDR_OUT) {
 
5730
                if (r->out.handle == NULL) {
 
5731
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5732
                }
 
5733
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
 
5734
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5735
        }
 
5736
        return NDR_ERR_SUCCESS;
 
5737
}
 
5738
 
 
5739
_PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)
 
5740
{
 
5741
        TALLOC_CTX *_mem_save_handle_0;
 
5742
        if (flags & NDR_IN) {
 
5743
                ZERO_STRUCT(r->out);
 
5744
 
 
5745
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5746
                        NDR_PULL_ALLOC(ndr, r->in.handle);
 
5747
                }
 
5748
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5749
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 
5750
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5751
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5752
                NDR_PULL_ALLOC(ndr, r->out.handle);
 
5753
                *r->out.handle = *r->in.handle;
 
5754
        }
 
5755
        if (flags & NDR_OUT) {
 
5756
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5757
                        NDR_PULL_ALLOC(ndr, r->out.handle);
 
5758
                }
 
5759
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5760
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 
5761
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
 
5762
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5763
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5764
        }
 
5765
        return NDR_ERR_SUCCESS;
 
5766
}
 
5767
 
 
5768
_PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)
 
5769
{
 
5770
        ndr_print_struct(ndr, name, "samr_Close");
 
5771
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5772
        ndr->depth++;
 
5773
        if (flags & NDR_SET_VALUES) {
 
5774
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5775
        }
 
5776
        if (flags & NDR_IN) {
 
5777
                ndr_print_struct(ndr, "in", "samr_Close");
 
5778
                ndr->depth++;
 
5779
                ndr_print_ptr(ndr, "handle", r->in.handle);
 
5780
                ndr->depth++;
 
5781
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
 
5782
                ndr->depth--;
 
5783
                ndr->depth--;
 
5784
        }
 
5785
        if (flags & NDR_OUT) {
 
5786
                ndr_print_struct(ndr, "out", "samr_Close");
 
5787
                ndr->depth++;
 
5788
                ndr_print_ptr(ndr, "handle", r->out.handle);
 
5789
                ndr->depth++;
 
5790
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
 
5791
                ndr->depth--;
 
5792
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5793
                ndr->depth--;
 
5794
        }
 
5795
        ndr->depth--;
 
5796
}
 
5797
 
 
5798
static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)
 
5799
{
 
5800
        if (flags & NDR_IN) {
 
5801
                if (r->in.handle == NULL) {
 
5802
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5803
                }
 
5804
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5805
                NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
 
5806
                if (r->in.sdbuf == NULL) {
 
5807
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5808
                }
 
5809
                NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
 
5810
        }
 
5811
        if (flags & NDR_OUT) {
 
5812
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5813
        }
 
5814
        return NDR_ERR_SUCCESS;
 
5815
}
 
5816
 
 
5817
static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)
 
5818
{
 
5819
        TALLOC_CTX *_mem_save_handle_0;
 
5820
        TALLOC_CTX *_mem_save_sdbuf_0;
 
5821
        if (flags & NDR_IN) {
 
5822
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5823
                        NDR_PULL_ALLOC(ndr, r->in.handle);
 
5824
                }
 
5825
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5826
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 
5827
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5828
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5829
                NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
 
5830
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5831
                        NDR_PULL_ALLOC(ndr, r->in.sdbuf);
 
5832
                }
 
5833
                _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5834
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
 
5835
                NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
 
5836
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
 
5837
        }
 
5838
        if (flags & NDR_OUT) {
 
5839
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5840
        }
 
5841
        return NDR_ERR_SUCCESS;
 
5842
}
 
5843
 
 
5844
_PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)
 
5845
{
 
5846
        ndr_print_struct(ndr, name, "samr_SetSecurity");
 
5847
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5848
        ndr->depth++;
 
5849
        if (flags & NDR_SET_VALUES) {
 
5850
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5851
        }
 
5852
        if (flags & NDR_IN) {
 
5853
                ndr_print_struct(ndr, "in", "samr_SetSecurity");
 
5854
                ndr->depth++;
 
5855
                ndr_print_ptr(ndr, "handle", r->in.handle);
 
5856
                ndr->depth++;
 
5857
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
 
5858
                ndr->depth--;
 
5859
                ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
 
5860
                ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
 
5861
                ndr->depth++;
 
5862
                ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
 
5863
                ndr->depth--;
 
5864
                ndr->depth--;
 
5865
        }
 
5866
        if (flags & NDR_OUT) {
 
5867
                ndr_print_struct(ndr, "out", "samr_SetSecurity");
 
5868
                ndr->depth++;
 
5869
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5870
                ndr->depth--;
 
5871
        }
 
5872
        ndr->depth--;
 
5873
}
 
5874
 
 
5875
static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)
 
5876
{
 
5877
        if (flags & NDR_IN) {
 
5878
                if (r->in.handle == NULL) {
 
5879
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5880
                }
 
5881
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5882
                NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
 
5883
        }
 
5884
        if (flags & NDR_OUT) {
 
5885
                if (r->out.sdbuf == NULL) {
 
5886
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5887
                }
 
5888
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
 
5889
                if (*r->out.sdbuf) {
 
5890
                        NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
 
5891
                }
 
5892
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5893
        }
 
5894
        return NDR_ERR_SUCCESS;
 
5895
}
 
5896
 
 
5897
static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)
 
5898
{
 
5899
        uint32_t _ptr_sdbuf;
 
5900
        TALLOC_CTX *_mem_save_handle_0;
 
5901
        TALLOC_CTX *_mem_save_sdbuf_0;
 
5902
        TALLOC_CTX *_mem_save_sdbuf_1;
 
5903
        if (flags & NDR_IN) {
 
5904
                ZERO_STRUCT(r->out);
 
5905
 
 
5906
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5907
                        NDR_PULL_ALLOC(ndr, r->in.handle);
 
5908
                }
 
5909
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5910
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 
5911
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
 
5912
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
5913
                NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
 
5914
                NDR_PULL_ALLOC(ndr, r->out.sdbuf);
 
5915
                ZERO_STRUCTP(r->out.sdbuf);
 
5916
        }
 
5917
        if (flags & NDR_OUT) {
 
5918
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5919
                        NDR_PULL_ALLOC(ndr, r->out.sdbuf);
 
5920
                }
 
5921
                _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5922
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
 
5923
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
 
5924
                if (_ptr_sdbuf) {
 
5925
                        NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
 
5926
                } else {
 
5927
                        *r->out.sdbuf = NULL;
 
5928
                }
 
5929
                if (*r->out.sdbuf) {
 
5930
                        _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
5931
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
 
5932
                        NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
 
5933
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
 
5934
                }
 
5935
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
 
5936
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
5937
        }
 
5938
        return NDR_ERR_SUCCESS;
 
5939
}
 
5940
 
 
5941
_PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)
 
5942
{
 
5943
        ndr_print_struct(ndr, name, "samr_QuerySecurity");
 
5944
        if (r == NULL) { ndr_print_null(ndr); return; }
 
5945
        ndr->depth++;
 
5946
        if (flags & NDR_SET_VALUES) {
 
5947
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
5948
        }
 
5949
        if (flags & NDR_IN) {
 
5950
                ndr_print_struct(ndr, "in", "samr_QuerySecurity");
 
5951
                ndr->depth++;
 
5952
                ndr_print_ptr(ndr, "handle", r->in.handle);
 
5953
                ndr->depth++;
 
5954
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
 
5955
                ndr->depth--;
 
5956
                ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
 
5957
                ndr->depth--;
 
5958
        }
 
5959
        if (flags & NDR_OUT) {
 
5960
                ndr_print_struct(ndr, "out", "samr_QuerySecurity");
 
5961
                ndr->depth++;
 
5962
                ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
 
5963
                ndr->depth++;
 
5964
                ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
 
5965
                ndr->depth++;
 
5966
                if (*r->out.sdbuf) {
 
5967
                        ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
 
5968
                }
 
5969
                ndr->depth--;
 
5970
                ndr->depth--;
 
5971
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
5972
                ndr->depth--;
 
5973
        }
 
5974
        ndr->depth--;
 
5975
}
 
5976
 
 
5977
static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)
 
5978
{
 
5979
        if (flags & NDR_IN) {
 
5980
                if (r->in.connect_handle == NULL) {
 
5981
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
5982
                }
 
5983
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
5984
        }
 
5985
        if (flags & NDR_OUT) {
 
5986
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
5987
        }
 
5988
        return NDR_ERR_SUCCESS;
 
5989
}
 
5990
 
 
5991
static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)
 
5992
{
 
5993
        TALLOC_CTX *_mem_save_connect_handle_0;
 
5994
        if (flags & NDR_IN) {
 
5995
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
5996
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
5997
                }
 
5998
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
5999
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
6000
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
6001
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6002
        }
 
6003
        if (flags & NDR_OUT) {
 
6004
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6005
        }
 
6006
        return NDR_ERR_SUCCESS;
 
6007
}
 
6008
 
 
6009
_PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)
 
6010
{
 
6011
        ndr_print_struct(ndr, name, "samr_Shutdown");
 
6012
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6013
        ndr->depth++;
 
6014
        if (flags & NDR_SET_VALUES) {
 
6015
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6016
        }
 
6017
        if (flags & NDR_IN) {
 
6018
                ndr_print_struct(ndr, "in", "samr_Shutdown");
 
6019
                ndr->depth++;
 
6020
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
6021
                ndr->depth++;
 
6022
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
6023
                ndr->depth--;
 
6024
                ndr->depth--;
 
6025
        }
 
6026
        if (flags & NDR_OUT) {
 
6027
                ndr_print_struct(ndr, "out", "samr_Shutdown");
 
6028
                ndr->depth++;
 
6029
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6030
                ndr->depth--;
 
6031
        }
 
6032
        ndr->depth--;
 
6033
}
 
6034
 
 
6035
static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)
 
6036
{
 
6037
        if (flags & NDR_IN) {
 
6038
                if (r->in.connect_handle == NULL) {
 
6039
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6040
                }
 
6041
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
6042
                if (r->in.domain_name == NULL) {
 
6043
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6044
                }
 
6045
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
 
6046
        }
 
6047
        if (flags & NDR_OUT) {
 
6048
                if (r->out.sid == NULL) {
 
6049
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6050
                }
 
6051
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
 
6052
                if (*r->out.sid) {
 
6053
                        NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
 
6054
                }
 
6055
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6056
        }
 
6057
        return NDR_ERR_SUCCESS;
 
6058
}
 
6059
 
 
6060
static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)
 
6061
{
 
6062
        uint32_t _ptr_sid;
 
6063
        TALLOC_CTX *_mem_save_connect_handle_0;
 
6064
        TALLOC_CTX *_mem_save_domain_name_0;
 
6065
        TALLOC_CTX *_mem_save_sid_0;
 
6066
        TALLOC_CTX *_mem_save_sid_1;
 
6067
        if (flags & NDR_IN) {
 
6068
                ZERO_STRUCT(r->out);
 
6069
 
 
6070
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6071
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
6072
                }
 
6073
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6074
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
6075
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
6076
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6077
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6078
                        NDR_PULL_ALLOC(ndr, r->in.domain_name);
 
6079
                }
 
6080
                _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6081
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);
 
6082
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
 
6083
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
 
6084
                NDR_PULL_ALLOC(ndr, r->out.sid);
 
6085
                ZERO_STRUCTP(r->out.sid);
 
6086
        }
 
6087
        if (flags & NDR_OUT) {
 
6088
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6089
                        NDR_PULL_ALLOC(ndr, r->out.sid);
 
6090
                }
 
6091
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6092
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
 
6093
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 
6094
                if (_ptr_sid) {
 
6095
                        NDR_PULL_ALLOC(ndr, *r->out.sid);
 
6096
                } else {
 
6097
                        *r->out.sid = NULL;
 
6098
                }
 
6099
                if (*r->out.sid) {
 
6100
                        _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
6101
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
 
6102
                        NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
 
6103
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
 
6104
                }
 
6105
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
6106
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6107
        }
 
6108
        return NDR_ERR_SUCCESS;
 
6109
}
 
6110
 
 
6111
_PUBLIC_ void ndr_print_samr_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)
 
6112
{
 
6113
        ndr_print_struct(ndr, name, "samr_LookupDomain");
 
6114
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6115
        ndr->depth++;
 
6116
        if (flags & NDR_SET_VALUES) {
 
6117
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6118
        }
 
6119
        if (flags & NDR_IN) {
 
6120
                ndr_print_struct(ndr, "in", "samr_LookupDomain");
 
6121
                ndr->depth++;
 
6122
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
6123
                ndr->depth++;
 
6124
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
6125
                ndr->depth--;
 
6126
                ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
 
6127
                ndr->depth++;
 
6128
                ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
 
6129
                ndr->depth--;
 
6130
                ndr->depth--;
 
6131
        }
 
6132
        if (flags & NDR_OUT) {
 
6133
                ndr_print_struct(ndr, "out", "samr_LookupDomain");
 
6134
                ndr->depth++;
 
6135
                ndr_print_ptr(ndr, "sid", r->out.sid);
 
6136
                ndr->depth++;
 
6137
                ndr_print_ptr(ndr, "sid", *r->out.sid);
 
6138
                ndr->depth++;
 
6139
                if (*r->out.sid) {
 
6140
                        ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
 
6141
                }
 
6142
                ndr->depth--;
 
6143
                ndr->depth--;
 
6144
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6145
                ndr->depth--;
 
6146
        }
 
6147
        ndr->depth--;
 
6148
}
 
6149
 
 
6150
static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)
 
6151
{
 
6152
        if (flags & NDR_IN) {
 
6153
                if (r->in.connect_handle == NULL) {
 
6154
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6155
                }
 
6156
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
6157
                if (r->in.resume_handle == NULL) {
 
6158
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6159
                }
 
6160
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
 
6161
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
 
6162
        }
 
6163
        if (flags & NDR_OUT) {
 
6164
                if (r->out.resume_handle == NULL) {
 
6165
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6166
                }
 
6167
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
 
6168
                if (r->out.sam == NULL) {
 
6169
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6170
                }
 
6171
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
 
6172
                if (*r->out.sam) {
 
6173
                        NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6174
                }
 
6175
                if (r->out.num_entries == NULL) {
 
6176
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6177
                }
 
6178
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
 
6179
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6180
        }
 
6181
        return NDR_ERR_SUCCESS;
 
6182
}
 
6183
 
 
6184
static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)
 
6185
{
 
6186
        uint32_t _ptr_sam;
 
6187
        TALLOC_CTX *_mem_save_connect_handle_0;
 
6188
        TALLOC_CTX *_mem_save_resume_handle_0;
 
6189
        TALLOC_CTX *_mem_save_sam_0;
 
6190
        TALLOC_CTX *_mem_save_sam_1;
 
6191
        TALLOC_CTX *_mem_save_num_entries_0;
 
6192
        if (flags & NDR_IN) {
 
6193
                ZERO_STRUCT(r->out);
 
6194
 
 
6195
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6196
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
6197
                }
 
6198
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6199
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
6200
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
6201
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6202
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6203
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
 
6204
                }
 
6205
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6206
                NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6207
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
 
6208
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6209
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
 
6210
                NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6211
                *r->out.resume_handle = *r->in.resume_handle;
 
6212
                NDR_PULL_ALLOC(ndr, r->out.sam);
 
6213
                ZERO_STRUCTP(r->out.sam);
 
6214
                NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6215
                ZERO_STRUCTP(r->out.num_entries);
 
6216
        }
 
6217
        if (flags & NDR_OUT) {
 
6218
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6219
                        NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6220
                }
 
6221
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6222
                NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6223
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
 
6224
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6225
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6226
                        NDR_PULL_ALLOC(ndr, r->out.sam);
 
6227
                }
 
6228
                _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6229
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
 
6230
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
 
6231
                if (_ptr_sam) {
 
6232
                        NDR_PULL_ALLOC(ndr, *r->out.sam);
 
6233
                } else {
 
6234
                        *r->out.sam = NULL;
 
6235
                }
 
6236
                if (*r->out.sam) {
 
6237
                        _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
6238
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
 
6239
                        NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6240
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
 
6241
                }
 
6242
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
 
6243
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6244
                        NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6245
                }
 
6246
                _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6247
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
 
6248
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
 
6249
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
 
6250
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6251
        }
 
6252
        return NDR_ERR_SUCCESS;
 
6253
}
 
6254
 
 
6255
_PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)
 
6256
{
 
6257
        ndr_print_struct(ndr, name, "samr_EnumDomains");
 
6258
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6259
        ndr->depth++;
 
6260
        if (flags & NDR_SET_VALUES) {
 
6261
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6262
        }
 
6263
        if (flags & NDR_IN) {
 
6264
                ndr_print_struct(ndr, "in", "samr_EnumDomains");
 
6265
                ndr->depth++;
 
6266
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
6267
                ndr->depth++;
 
6268
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
6269
                ndr->depth--;
 
6270
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
 
6271
                ndr->depth++;
 
6272
                ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
 
6273
                ndr->depth--;
 
6274
                ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
 
6275
                ndr->depth--;
 
6276
        }
 
6277
        if (flags & NDR_OUT) {
 
6278
                ndr_print_struct(ndr, "out", "samr_EnumDomains");
 
6279
                ndr->depth++;
 
6280
                ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
 
6281
                ndr->depth++;
 
6282
                ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
 
6283
                ndr->depth--;
 
6284
                ndr_print_ptr(ndr, "sam", r->out.sam);
 
6285
                ndr->depth++;
 
6286
                ndr_print_ptr(ndr, "sam", *r->out.sam);
 
6287
                ndr->depth++;
 
6288
                if (*r->out.sam) {
 
6289
                        ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
 
6290
                }
 
6291
                ndr->depth--;
 
6292
                ndr->depth--;
 
6293
                ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
 
6294
                ndr->depth++;
 
6295
                ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
 
6296
                ndr->depth--;
 
6297
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6298
                ndr->depth--;
 
6299
        }
 
6300
        ndr->depth--;
 
6301
}
 
6302
 
 
6303
_PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)
 
6304
{
 
6305
        if (flags & NDR_IN) {
 
6306
                if (r->in.connect_handle == NULL) {
 
6307
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6308
                }
 
6309
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
6310
                NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
6311
                if (r->in.sid == NULL) {
 
6312
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6313
                }
 
6314
                NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
6315
        }
 
6316
        if (flags & NDR_OUT) {
 
6317
                if (r->out.domain_handle == NULL) {
 
6318
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6319
                }
 
6320
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
 
6321
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6322
        }
 
6323
        return NDR_ERR_SUCCESS;
 
6324
}
 
6325
 
 
6326
_PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)
 
6327
{
 
6328
        TALLOC_CTX *_mem_save_connect_handle_0;
 
6329
        TALLOC_CTX *_mem_save_sid_0;
 
6330
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6331
        if (flags & NDR_IN) {
 
6332
                ZERO_STRUCT(r->out);
 
6333
 
 
6334
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6335
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
6336
                }
 
6337
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6338
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
6339
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
6340
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6341
                NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
6342
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6343
                        NDR_PULL_ALLOC(ndr, r->in.sid);
 
6344
                }
 
6345
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6346
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 
6347
                NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
6348
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
6349
                NDR_PULL_ALLOC(ndr, r->out.domain_handle);
 
6350
                ZERO_STRUCTP(r->out.domain_handle);
 
6351
        }
 
6352
        if (flags & NDR_OUT) {
 
6353
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6354
                        NDR_PULL_ALLOC(ndr, r->out.domain_handle);
 
6355
                }
 
6356
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6357
                NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6358
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));
 
6359
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6360
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6361
        }
 
6362
        return NDR_ERR_SUCCESS;
 
6363
}
 
6364
 
 
6365
_PUBLIC_ void ndr_print_samr_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)
 
6366
{
 
6367
        ndr_print_struct(ndr, name, "samr_OpenDomain");
 
6368
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6369
        ndr->depth++;
 
6370
        if (flags & NDR_SET_VALUES) {
 
6371
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6372
        }
 
6373
        if (flags & NDR_IN) {
 
6374
                ndr_print_struct(ndr, "in", "samr_OpenDomain");
 
6375
                ndr->depth++;
 
6376
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
6377
                ndr->depth++;
 
6378
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
6379
                ndr->depth--;
 
6380
                ndr_print_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);
 
6381
                ndr_print_ptr(ndr, "sid", r->in.sid);
 
6382
                ndr->depth++;
 
6383
                ndr_print_dom_sid2(ndr, "sid", r->in.sid);
 
6384
                ndr->depth--;
 
6385
                ndr->depth--;
 
6386
        }
 
6387
        if (flags & NDR_OUT) {
 
6388
                ndr_print_struct(ndr, "out", "samr_OpenDomain");
 
6389
                ndr->depth++;
 
6390
                ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);
 
6391
                ndr->depth++;
 
6392
                ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);
 
6393
                ndr->depth--;
 
6394
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6395
                ndr->depth--;
 
6396
        }
 
6397
        ndr->depth--;
 
6398
}
 
6399
 
 
6400
static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)
 
6401
{
 
6402
        if (flags & NDR_IN) {
 
6403
                if (r->in.domain_handle == NULL) {
 
6404
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6405
                }
 
6406
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6407
                NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
 
6408
        }
 
6409
        if (flags & NDR_OUT) {
 
6410
                if (r->out.info == NULL) {
 
6411
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6412
                }
 
6413
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
6414
                if (*r->out.info) {
 
6415
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
6416
                        NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
6417
                }
 
6418
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6419
        }
 
6420
        return NDR_ERR_SUCCESS;
 
6421
}
 
6422
 
 
6423
static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)
 
6424
{
 
6425
        uint32_t _ptr_info;
 
6426
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6427
        TALLOC_CTX *_mem_save_info_0;
 
6428
        TALLOC_CTX *_mem_save_info_1;
 
6429
        if (flags & NDR_IN) {
 
6430
                ZERO_STRUCT(r->out);
 
6431
 
 
6432
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6433
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6434
                }
 
6435
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6436
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6437
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6438
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6439
                NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
 
6440
                NDR_PULL_ALLOC(ndr, r->out.info);
 
6441
                ZERO_STRUCTP(r->out.info);
 
6442
        }
 
6443
        if (flags & NDR_OUT) {
 
6444
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6445
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
6446
                }
 
6447
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6448
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
6449
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
6450
                if (_ptr_info) {
 
6451
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
6452
                } else {
 
6453
                        *r->out.info = NULL;
 
6454
                }
 
6455
                if (*r->out.info) {
 
6456
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
6457
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
6458
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
6459
                        NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
6460
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
6461
                }
 
6462
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
6463
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6464
        }
 
6465
        return NDR_ERR_SUCCESS;
 
6466
}
 
6467
 
 
6468
_PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)
 
6469
{
 
6470
        ndr_print_struct(ndr, name, "samr_QueryDomainInfo");
 
6471
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6472
        ndr->depth++;
 
6473
        if (flags & NDR_SET_VALUES) {
 
6474
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6475
        }
 
6476
        if (flags & NDR_IN) {
 
6477
                ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");
 
6478
                ndr->depth++;
 
6479
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6480
                ndr->depth++;
 
6481
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6482
                ndr->depth--;
 
6483
                ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
 
6484
                ndr->depth--;
 
6485
        }
 
6486
        if (flags & NDR_OUT) {
 
6487
                ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");
 
6488
                ndr->depth++;
 
6489
                ndr_print_ptr(ndr, "info", r->out.info);
 
6490
                ndr->depth++;
 
6491
                ndr_print_ptr(ndr, "info", *r->out.info);
 
6492
                ndr->depth++;
 
6493
                if (*r->out.info) {
 
6494
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
6495
                        ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
 
6496
                }
 
6497
                ndr->depth--;
 
6498
                ndr->depth--;
 
6499
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6500
                ndr->depth--;
 
6501
        }
 
6502
        ndr->depth--;
 
6503
}
 
6504
 
 
6505
static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)
 
6506
{
 
6507
        if (flags & NDR_IN) {
 
6508
                if (r->in.domain_handle == NULL) {
 
6509
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6510
                }
 
6511
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6512
                NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
 
6513
                if (r->in.info == NULL) {
 
6514
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6515
                }
 
6516
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
6517
                NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
6518
        }
 
6519
        if (flags & NDR_OUT) {
 
6520
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6521
        }
 
6522
        return NDR_ERR_SUCCESS;
 
6523
}
 
6524
 
 
6525
static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)
 
6526
{
 
6527
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6528
        TALLOC_CTX *_mem_save_info_0;
 
6529
        if (flags & NDR_IN) {
 
6530
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6531
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6532
                }
 
6533
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6534
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6535
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6536
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6537
                NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
 
6538
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6539
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
6540
                }
 
6541
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6542
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
6543
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
6544
                NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
6545
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
6546
        }
 
6547
        if (flags & NDR_OUT) {
 
6548
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6549
        }
 
6550
        return NDR_ERR_SUCCESS;
 
6551
}
 
6552
 
 
6553
_PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)
 
6554
{
 
6555
        ndr_print_struct(ndr, name, "samr_SetDomainInfo");
 
6556
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6557
        ndr->depth++;
 
6558
        if (flags & NDR_SET_VALUES) {
 
6559
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6560
        }
 
6561
        if (flags & NDR_IN) {
 
6562
                ndr_print_struct(ndr, "in", "samr_SetDomainInfo");
 
6563
                ndr->depth++;
 
6564
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6565
                ndr->depth++;
 
6566
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6567
                ndr->depth--;
 
6568
                ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
 
6569
                ndr_print_ptr(ndr, "info", r->in.info);
 
6570
                ndr->depth++;
 
6571
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
6572
                ndr_print_samr_DomainInfo(ndr, "info", r->in.info);
 
6573
                ndr->depth--;
 
6574
                ndr->depth--;
 
6575
        }
 
6576
        if (flags & NDR_OUT) {
 
6577
                ndr_print_struct(ndr, "out", "samr_SetDomainInfo");
 
6578
                ndr->depth++;
 
6579
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6580
                ndr->depth--;
 
6581
        }
 
6582
        ndr->depth--;
 
6583
}
 
6584
 
 
6585
static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)
 
6586
{
 
6587
        if (flags & NDR_IN) {
 
6588
                if (r->in.domain_handle == NULL) {
 
6589
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6590
                }
 
6591
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6592
                if (r->in.name == NULL) {
 
6593
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6594
                }
 
6595
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
6596
                NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
6597
        }
 
6598
        if (flags & NDR_OUT) {
 
6599
                if (r->out.group_handle == NULL) {
 
6600
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6601
                }
 
6602
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
6603
                if (r->out.rid == NULL) {
 
6604
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6605
                }
 
6606
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
 
6607
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6608
        }
 
6609
        return NDR_ERR_SUCCESS;
 
6610
}
 
6611
 
 
6612
static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)
 
6613
{
 
6614
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6615
        TALLOC_CTX *_mem_save_name_0;
 
6616
        TALLOC_CTX *_mem_save_group_handle_0;
 
6617
        TALLOC_CTX *_mem_save_rid_0;
 
6618
        if (flags & NDR_IN) {
 
6619
                ZERO_STRUCT(r->out);
 
6620
 
 
6621
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6622
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6623
                }
 
6624
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6625
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6626
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6627
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6628
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6629
                        NDR_PULL_ALLOC(ndr, r->in.name);
 
6630
                }
 
6631
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6632
                NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
 
6633
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
6634
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
 
6635
                NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
6636
                NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
6637
                ZERO_STRUCTP(r->out.group_handle);
 
6638
                NDR_PULL_ALLOC(ndr, r->out.rid);
 
6639
                ZERO_STRUCTP(r->out.rid);
 
6640
        }
 
6641
        if (flags & NDR_OUT) {
 
6642
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6643
                        NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
6644
                }
 
6645
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6646
                NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
6647
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
6648
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6649
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6650
                        NDR_PULL_ALLOC(ndr, r->out.rid);
 
6651
                }
 
6652
                _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6653
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
 
6654
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
 
6655
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
 
6656
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6657
        }
 
6658
        return NDR_ERR_SUCCESS;
 
6659
}
 
6660
 
 
6661
_PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)
 
6662
{
 
6663
        ndr_print_struct(ndr, name, "samr_CreateDomainGroup");
 
6664
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6665
        ndr->depth++;
 
6666
        if (flags & NDR_SET_VALUES) {
 
6667
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6668
        }
 
6669
        if (flags & NDR_IN) {
 
6670
                ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");
 
6671
                ndr->depth++;
 
6672
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6673
                ndr->depth++;
 
6674
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6675
                ndr->depth--;
 
6676
                ndr_print_ptr(ndr, "name", r->in.name);
 
6677
                ndr->depth++;
 
6678
                ndr_print_lsa_String(ndr, "name", r->in.name);
 
6679
                ndr->depth--;
 
6680
                ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
 
6681
                ndr->depth--;
 
6682
        }
 
6683
        if (flags & NDR_OUT) {
 
6684
                ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");
 
6685
                ndr->depth++;
 
6686
                ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
 
6687
                ndr->depth++;
 
6688
                ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
 
6689
                ndr->depth--;
 
6690
                ndr_print_ptr(ndr, "rid", r->out.rid);
 
6691
                ndr->depth++;
 
6692
                ndr_print_uint32(ndr, "rid", *r->out.rid);
 
6693
                ndr->depth--;
 
6694
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6695
                ndr->depth--;
 
6696
        }
 
6697
        ndr->depth--;
 
6698
}
 
6699
 
 
6700
static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)
 
6701
{
 
6702
        if (flags & NDR_IN) {
 
6703
                if (r->in.domain_handle == NULL) {
 
6704
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6705
                }
 
6706
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6707
                if (r->in.resume_handle == NULL) {
 
6708
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6709
                }
 
6710
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
 
6711
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
 
6712
        }
 
6713
        if (flags & NDR_OUT) {
 
6714
                if (r->out.resume_handle == NULL) {
 
6715
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6716
                }
 
6717
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
 
6718
                if (r->out.sam == NULL) {
 
6719
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6720
                }
 
6721
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
 
6722
                if (*r->out.sam) {
 
6723
                        NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6724
                }
 
6725
                if (r->out.num_entries == NULL) {
 
6726
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6727
                }
 
6728
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
 
6729
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6730
        }
 
6731
        return NDR_ERR_SUCCESS;
 
6732
}
 
6733
 
 
6734
static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)
 
6735
{
 
6736
        uint32_t _ptr_sam;
 
6737
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6738
        TALLOC_CTX *_mem_save_resume_handle_0;
 
6739
        TALLOC_CTX *_mem_save_sam_0;
 
6740
        TALLOC_CTX *_mem_save_sam_1;
 
6741
        TALLOC_CTX *_mem_save_num_entries_0;
 
6742
        if (flags & NDR_IN) {
 
6743
                ZERO_STRUCT(r->out);
 
6744
 
 
6745
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6746
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6747
                }
 
6748
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6749
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6750
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6751
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6752
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6753
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
 
6754
                }
 
6755
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6756
                NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6757
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
 
6758
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6759
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
 
6760
                NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6761
                *r->out.resume_handle = *r->in.resume_handle;
 
6762
                NDR_PULL_ALLOC(ndr, r->out.sam);
 
6763
                ZERO_STRUCTP(r->out.sam);
 
6764
                NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6765
                ZERO_STRUCTP(r->out.num_entries);
 
6766
        }
 
6767
        if (flags & NDR_OUT) {
 
6768
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6769
                        NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
6770
                }
 
6771
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6772
                NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
6773
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
 
6774
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6775
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6776
                        NDR_PULL_ALLOC(ndr, r->out.sam);
 
6777
                }
 
6778
                _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6779
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
 
6780
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
 
6781
                if (_ptr_sam) {
 
6782
                        NDR_PULL_ALLOC(ndr, *r->out.sam);
 
6783
                } else {
 
6784
                        *r->out.sam = NULL;
 
6785
                }
 
6786
                if (*r->out.sam) {
 
6787
                        _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
6788
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
 
6789
                        NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6790
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
 
6791
                }
 
6792
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
 
6793
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6794
                        NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
6795
                }
 
6796
                _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6797
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
 
6798
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
 
6799
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
 
6800
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6801
        }
 
6802
        return NDR_ERR_SUCCESS;
 
6803
}
 
6804
 
 
6805
_PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)
 
6806
{
 
6807
        ndr_print_struct(ndr, name, "samr_EnumDomainGroups");
 
6808
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6809
        ndr->depth++;
 
6810
        if (flags & NDR_SET_VALUES) {
 
6811
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6812
        }
 
6813
        if (flags & NDR_IN) {
 
6814
                ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");
 
6815
                ndr->depth++;
 
6816
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6817
                ndr->depth++;
 
6818
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6819
                ndr->depth--;
 
6820
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
 
6821
                ndr->depth++;
 
6822
                ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
 
6823
                ndr->depth--;
 
6824
                ndr_print_uint32(ndr, "max_size", r->in.max_size);
 
6825
                ndr->depth--;
 
6826
        }
 
6827
        if (flags & NDR_OUT) {
 
6828
                ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");
 
6829
                ndr->depth++;
 
6830
                ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
 
6831
                ndr->depth++;
 
6832
                ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
 
6833
                ndr->depth--;
 
6834
                ndr_print_ptr(ndr, "sam", r->out.sam);
 
6835
                ndr->depth++;
 
6836
                ndr_print_ptr(ndr, "sam", *r->out.sam);
 
6837
                ndr->depth++;
 
6838
                if (*r->out.sam) {
 
6839
                        ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
 
6840
                }
 
6841
                ndr->depth--;
 
6842
                ndr->depth--;
 
6843
                ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
 
6844
                ndr->depth++;
 
6845
                ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
 
6846
                ndr->depth--;
 
6847
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6848
                ndr->depth--;
 
6849
        }
 
6850
        ndr->depth--;
 
6851
}
 
6852
 
 
6853
static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)
 
6854
{
 
6855
        if (flags & NDR_IN) {
 
6856
                if (r->in.domain_handle == NULL) {
 
6857
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6858
                }
 
6859
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6860
                if (r->in.account_name == NULL) {
 
6861
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6862
                }
 
6863
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
 
6864
                NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
6865
        }
 
6866
        if (flags & NDR_OUT) {
 
6867
                if (r->out.user_handle == NULL) {
 
6868
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6869
                }
 
6870
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
6871
                if (r->out.rid == NULL) {
 
6872
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6873
                }
 
6874
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
 
6875
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6876
        }
 
6877
        return NDR_ERR_SUCCESS;
 
6878
}
 
6879
 
 
6880
static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)
 
6881
{
 
6882
        TALLOC_CTX *_mem_save_domain_handle_0;
 
6883
        TALLOC_CTX *_mem_save_account_name_0;
 
6884
        TALLOC_CTX *_mem_save_user_handle_0;
 
6885
        TALLOC_CTX *_mem_save_rid_0;
 
6886
        if (flags & NDR_IN) {
 
6887
                ZERO_STRUCT(r->out);
 
6888
 
 
6889
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6890
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
6891
                }
 
6892
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6893
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
6894
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6895
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6896
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6897
                        NDR_PULL_ALLOC(ndr, r->in.account_name);
 
6898
                }
 
6899
                _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6900
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
 
6901
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
 
6902
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
 
6903
                NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
6904
                NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
6905
                ZERO_STRUCTP(r->out.user_handle);
 
6906
                NDR_PULL_ALLOC(ndr, r->out.rid);
 
6907
                ZERO_STRUCTP(r->out.rid);
 
6908
        }
 
6909
        if (flags & NDR_OUT) {
 
6910
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6911
                        NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
6912
                }
 
6913
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6914
                NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
6915
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
6916
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
6917
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
6918
                        NDR_PULL_ALLOC(ndr, r->out.rid);
 
6919
                }
 
6920
                _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
6921
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
 
6922
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
 
6923
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
 
6924
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
6925
        }
 
6926
        return NDR_ERR_SUCCESS;
 
6927
}
 
6928
 
 
6929
_PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)
 
6930
{
 
6931
        ndr_print_struct(ndr, name, "samr_CreateUser");
 
6932
        if (r == NULL) { ndr_print_null(ndr); return; }
 
6933
        ndr->depth++;
 
6934
        if (flags & NDR_SET_VALUES) {
 
6935
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
6936
        }
 
6937
        if (flags & NDR_IN) {
 
6938
                ndr_print_struct(ndr, "in", "samr_CreateUser");
 
6939
                ndr->depth++;
 
6940
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
6941
                ndr->depth++;
 
6942
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
6943
                ndr->depth--;
 
6944
                ndr_print_ptr(ndr, "account_name", r->in.account_name);
 
6945
                ndr->depth++;
 
6946
                ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
 
6947
                ndr->depth--;
 
6948
                ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
 
6949
                ndr->depth--;
 
6950
        }
 
6951
        if (flags & NDR_OUT) {
 
6952
                ndr_print_struct(ndr, "out", "samr_CreateUser");
 
6953
                ndr->depth++;
 
6954
                ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
 
6955
                ndr->depth++;
 
6956
                ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
 
6957
                ndr->depth--;
 
6958
                ndr_print_ptr(ndr, "rid", r->out.rid);
 
6959
                ndr->depth++;
 
6960
                ndr_print_uint32(ndr, "rid", *r->out.rid);
 
6961
                ndr->depth--;
 
6962
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
6963
                ndr->depth--;
 
6964
        }
 
6965
        ndr->depth--;
 
6966
}
 
6967
 
 
6968
static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)
 
6969
{
 
6970
        if (flags & NDR_IN) {
 
6971
                if (r->in.domain_handle == NULL) {
 
6972
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6973
                }
 
6974
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
6975
                if (r->in.resume_handle == NULL) {
 
6976
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6977
                }
 
6978
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
 
6979
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
 
6980
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
 
6981
        }
 
6982
        if (flags & NDR_OUT) {
 
6983
                if (r->out.resume_handle == NULL) {
 
6984
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6985
                }
 
6986
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
 
6987
                if (r->out.sam == NULL) {
 
6988
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6989
                }
 
6990
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
 
6991
                if (*r->out.sam) {
 
6992
                        NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
6993
                }
 
6994
                if (r->out.num_entries == NULL) {
 
6995
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
6996
                }
 
6997
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
 
6998
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
6999
        }
 
7000
        return NDR_ERR_SUCCESS;
 
7001
}
 
7002
 
 
7003
static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)
 
7004
{
 
7005
        uint32_t _ptr_sam;
 
7006
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7007
        TALLOC_CTX *_mem_save_resume_handle_0;
 
7008
        TALLOC_CTX *_mem_save_sam_0;
 
7009
        TALLOC_CTX *_mem_save_sam_1;
 
7010
        TALLOC_CTX *_mem_save_num_entries_0;
 
7011
        if (flags & NDR_IN) {
 
7012
                ZERO_STRUCT(r->out);
 
7013
 
 
7014
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7015
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7016
                }
 
7017
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7018
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7019
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7020
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7021
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7022
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
 
7023
                }
 
7024
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7025
                NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
7026
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
 
7027
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7028
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
 
7029
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
 
7030
                NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
7031
                *r->out.resume_handle = *r->in.resume_handle;
 
7032
                NDR_PULL_ALLOC(ndr, r->out.sam);
 
7033
                ZERO_STRUCTP(r->out.sam);
 
7034
                NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
7035
                ZERO_STRUCTP(r->out.num_entries);
 
7036
        }
 
7037
        if (flags & NDR_OUT) {
 
7038
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7039
                        NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
7040
                }
 
7041
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7042
                NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
7043
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
 
7044
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7045
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7046
                        NDR_PULL_ALLOC(ndr, r->out.sam);
 
7047
                }
 
7048
                _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7049
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
 
7050
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
 
7051
                if (_ptr_sam) {
 
7052
                        NDR_PULL_ALLOC(ndr, *r->out.sam);
 
7053
                } else {
 
7054
                        *r->out.sam = NULL;
 
7055
                }
 
7056
                if (*r->out.sam) {
 
7057
                        _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
7058
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
 
7059
                        NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
7060
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
 
7061
                }
 
7062
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
 
7063
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7064
                        NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
7065
                }
 
7066
                _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7067
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
 
7068
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
 
7069
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
 
7070
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7071
        }
 
7072
        return NDR_ERR_SUCCESS;
 
7073
}
 
7074
 
 
7075
_PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)
 
7076
{
 
7077
        ndr_print_struct(ndr, name, "samr_EnumDomainUsers");
 
7078
        if (r == NULL) { ndr_print_null(ndr); return; }
 
7079
        ndr->depth++;
 
7080
        if (flags & NDR_SET_VALUES) {
 
7081
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7082
        }
 
7083
        if (flags & NDR_IN) {
 
7084
                ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");
 
7085
                ndr->depth++;
 
7086
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7087
                ndr->depth++;
 
7088
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7089
                ndr->depth--;
 
7090
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
 
7091
                ndr->depth++;
 
7092
                ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
 
7093
                ndr->depth--;
 
7094
                ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
 
7095
                ndr_print_uint32(ndr, "max_size", r->in.max_size);
 
7096
                ndr->depth--;
 
7097
        }
 
7098
        if (flags & NDR_OUT) {
 
7099
                ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");
 
7100
                ndr->depth++;
 
7101
                ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
 
7102
                ndr->depth++;
 
7103
                ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
 
7104
                ndr->depth--;
 
7105
                ndr_print_ptr(ndr, "sam", r->out.sam);
 
7106
                ndr->depth++;
 
7107
                ndr_print_ptr(ndr, "sam", *r->out.sam);
 
7108
                ndr->depth++;
 
7109
                if (*r->out.sam) {
 
7110
                        ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
 
7111
                }
 
7112
                ndr->depth--;
 
7113
                ndr->depth--;
 
7114
                ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
 
7115
                ndr->depth++;
 
7116
                ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
 
7117
                ndr->depth--;
 
7118
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7119
                ndr->depth--;
 
7120
        }
 
7121
        ndr->depth--;
 
7122
}
 
7123
 
 
7124
static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)
 
7125
{
 
7126
        if (flags & NDR_IN) {
 
7127
                if (r->in.domain_handle == NULL) {
 
7128
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7129
                }
 
7130
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7131
                if (r->in.alias_name == NULL) {
 
7132
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7133
                }
 
7134
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
 
7135
                NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
7136
        }
 
7137
        if (flags & NDR_OUT) {
 
7138
                if (r->out.alias_handle == NULL) {
 
7139
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7140
                }
 
7141
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
7142
                if (r->out.rid == NULL) {
 
7143
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7144
                }
 
7145
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
 
7146
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7147
        }
 
7148
        return NDR_ERR_SUCCESS;
 
7149
}
 
7150
 
 
7151
static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)
 
7152
{
 
7153
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7154
        TALLOC_CTX *_mem_save_alias_name_0;
 
7155
        TALLOC_CTX *_mem_save_alias_handle_0;
 
7156
        TALLOC_CTX *_mem_save_rid_0;
 
7157
        if (flags & NDR_IN) {
 
7158
                ZERO_STRUCT(r->out);
 
7159
 
 
7160
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7161
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7162
                }
 
7163
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7164
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7165
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7166
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7167
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7168
                        NDR_PULL_ALLOC(ndr, r->in.alias_name);
 
7169
                }
 
7170
                _mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7171
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);
 
7172
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));
 
7173
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);
 
7174
                NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
7175
                NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
7176
                ZERO_STRUCTP(r->out.alias_handle);
 
7177
                NDR_PULL_ALLOC(ndr, r->out.rid);
 
7178
                ZERO_STRUCTP(r->out.rid);
 
7179
        }
 
7180
        if (flags & NDR_OUT) {
 
7181
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7182
                        NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
7183
                }
 
7184
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7185
                NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
7186
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
7187
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7188
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7189
                        NDR_PULL_ALLOC(ndr, r->out.rid);
 
7190
                }
 
7191
                _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7192
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
 
7193
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
 
7194
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
 
7195
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7196
        }
 
7197
        return NDR_ERR_SUCCESS;
 
7198
}
 
7199
 
 
7200
_PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)
 
7201
{
 
7202
        ndr_print_struct(ndr, name, "samr_CreateDomAlias");
 
7203
        if (r == NULL) { ndr_print_null(ndr); return; }
 
7204
        ndr->depth++;
 
7205
        if (flags & NDR_SET_VALUES) {
 
7206
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7207
        }
 
7208
        if (flags & NDR_IN) {
 
7209
                ndr_print_struct(ndr, "in", "samr_CreateDomAlias");
 
7210
                ndr->depth++;
 
7211
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7212
                ndr->depth++;
 
7213
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7214
                ndr->depth--;
 
7215
                ndr_print_ptr(ndr, "alias_name", r->in.alias_name);
 
7216
                ndr->depth++;
 
7217
                ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);
 
7218
                ndr->depth--;
 
7219
                ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
 
7220
                ndr->depth--;
 
7221
        }
 
7222
        if (flags & NDR_OUT) {
 
7223
                ndr_print_struct(ndr, "out", "samr_CreateDomAlias");
 
7224
                ndr->depth++;
 
7225
                ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
 
7226
                ndr->depth++;
 
7227
                ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
 
7228
                ndr->depth--;
 
7229
                ndr_print_ptr(ndr, "rid", r->out.rid);
 
7230
                ndr->depth++;
 
7231
                ndr_print_uint32(ndr, "rid", *r->out.rid);
 
7232
                ndr->depth--;
 
7233
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7234
                ndr->depth--;
 
7235
        }
 
7236
        ndr->depth--;
 
7237
}
 
7238
 
 
7239
static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)
 
7240
{
 
7241
        if (flags & NDR_IN) {
 
7242
                if (r->in.domain_handle == NULL) {
 
7243
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7244
                }
 
7245
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7246
                if (r->in.resume_handle == NULL) {
 
7247
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7248
                }
 
7249
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
 
7250
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
 
7251
        }
 
7252
        if (flags & NDR_OUT) {
 
7253
                if (r->out.resume_handle == NULL) {
 
7254
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7255
                }
 
7256
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
 
7257
                if (r->out.sam == NULL) {
 
7258
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7259
                }
 
7260
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));
 
7261
                if (*r->out.sam) {
 
7262
                        NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
7263
                }
 
7264
                if (r->out.num_entries == NULL) {
 
7265
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7266
                }
 
7267
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));
 
7268
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7269
        }
 
7270
        return NDR_ERR_SUCCESS;
 
7271
}
 
7272
 
 
7273
static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)
 
7274
{
 
7275
        uint32_t _ptr_sam;
 
7276
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7277
        TALLOC_CTX *_mem_save_resume_handle_0;
 
7278
        TALLOC_CTX *_mem_save_sam_0;
 
7279
        TALLOC_CTX *_mem_save_sam_1;
 
7280
        TALLOC_CTX *_mem_save_num_entries_0;
 
7281
        if (flags & NDR_IN) {
 
7282
                ZERO_STRUCT(r->out);
 
7283
 
 
7284
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7285
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7286
                }
 
7287
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7288
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7289
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7290
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7291
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7292
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
 
7293
                }
 
7294
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7295
                NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
7296
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
 
7297
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7298
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
 
7299
                NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
7300
                *r->out.resume_handle = *r->in.resume_handle;
 
7301
                NDR_PULL_ALLOC(ndr, r->out.sam);
 
7302
                ZERO_STRUCTP(r->out.sam);
 
7303
                NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
7304
                ZERO_STRUCTP(r->out.num_entries);
 
7305
        }
 
7306
        if (flags & NDR_OUT) {
 
7307
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7308
                        NDR_PULL_ALLOC(ndr, r->out.resume_handle);
 
7309
                }
 
7310
                _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7311
                NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
 
7312
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
 
7313
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7314
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7315
                        NDR_PULL_ALLOC(ndr, r->out.sam);
 
7316
                }
 
7317
                _mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7318
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);
 
7319
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));
 
7320
                if (_ptr_sam) {
 
7321
                        NDR_PULL_ALLOC(ndr, *r->out.sam);
 
7322
                } else {
 
7323
                        *r->out.sam = NULL;
 
7324
                }
 
7325
                if (*r->out.sam) {
 
7326
                        _mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
7327
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);
 
7328
                        NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));
 
7329
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);
 
7330
                }
 
7331
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);
 
7332
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7333
                        NDR_PULL_ALLOC(ndr, r->out.num_entries);
 
7334
                }
 
7335
                _mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7336
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);
 
7337
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));
 
7338
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);
 
7339
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7340
        }
 
7341
        return NDR_ERR_SUCCESS;
 
7342
}
 
7343
 
 
7344
_PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)
 
7345
{
 
7346
        ndr_print_struct(ndr, name, "samr_EnumDomainAliases");
 
7347
        if (r == NULL) { ndr_print_null(ndr); return; }
 
7348
        ndr->depth++;
 
7349
        if (flags & NDR_SET_VALUES) {
 
7350
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7351
        }
 
7352
        if (flags & NDR_IN) {
 
7353
                ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");
 
7354
                ndr->depth++;
 
7355
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7356
                ndr->depth++;
 
7357
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7358
                ndr->depth--;
 
7359
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
 
7360
                ndr->depth++;
 
7361
                ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
 
7362
                ndr->depth--;
 
7363
                ndr_print_uint32(ndr, "max_size", r->in.max_size);
 
7364
                ndr->depth--;
 
7365
        }
 
7366
        if (flags & NDR_OUT) {
 
7367
                ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");
 
7368
                ndr->depth++;
 
7369
                ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
 
7370
                ndr->depth++;
 
7371
                ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
 
7372
                ndr->depth--;
 
7373
                ndr_print_ptr(ndr, "sam", r->out.sam);
 
7374
                ndr->depth++;
 
7375
                ndr_print_ptr(ndr, "sam", *r->out.sam);
 
7376
                ndr->depth++;
 
7377
                if (*r->out.sam) {
 
7378
                        ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);
 
7379
                }
 
7380
                ndr->depth--;
 
7381
                ndr->depth--;
 
7382
                ndr_print_ptr(ndr, "num_entries", r->out.num_entries);
 
7383
                ndr->depth++;
 
7384
                ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);
 
7385
                ndr->depth--;
 
7386
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7387
                ndr->depth--;
 
7388
        }
 
7389
        ndr->depth--;
 
7390
}
 
7391
 
 
7392
static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)
 
7393
{
 
7394
        if (flags & NDR_IN) {
 
7395
                if (r->in.domain_handle == NULL) {
 
7396
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7397
                }
 
7398
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7399
                if (r->in.sids == NULL) {
 
7400
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7401
                }
 
7402
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
7403
        }
 
7404
        if (flags & NDR_OUT) {
 
7405
                if (r->out.rids == NULL) {
 
7406
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7407
                }
 
7408
                NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
 
7409
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7410
        }
 
7411
        return NDR_ERR_SUCCESS;
 
7412
}
 
7413
 
 
7414
static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)
 
7415
{
 
7416
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7417
        TALLOC_CTX *_mem_save_sids_0;
 
7418
        TALLOC_CTX *_mem_save_rids_0;
 
7419
        if (flags & NDR_IN) {
 
7420
                ZERO_STRUCT(r->out);
 
7421
 
 
7422
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7423
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7424
                }
 
7425
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7426
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7427
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7428
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7429
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7430
                        NDR_PULL_ALLOC(ndr, r->in.sids);
 
7431
                }
 
7432
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7433
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
 
7434
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
7435
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
 
7436
                NDR_PULL_ALLOC(ndr, r->out.rids);
 
7437
                ZERO_STRUCTP(r->out.rids);
 
7438
        }
 
7439
        if (flags & NDR_OUT) {
 
7440
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7441
                        NDR_PULL_ALLOC(ndr, r->out.rids);
 
7442
                }
 
7443
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7444
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
 
7445
                NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
 
7446
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
 
7447
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7448
        }
 
7449
        return NDR_ERR_SUCCESS;
 
7450
}
 
7451
 
 
7452
_PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)
 
7453
{
 
7454
        ndr_print_struct(ndr, name, "samr_GetAliasMembership");
 
7455
        if (r == NULL) { ndr_print_null(ndr); return; }
 
7456
        ndr->depth++;
 
7457
        if (flags & NDR_SET_VALUES) {
 
7458
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7459
        }
 
7460
        if (flags & NDR_IN) {
 
7461
                ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
 
7462
                ndr->depth++;
 
7463
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7464
                ndr->depth++;
 
7465
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7466
                ndr->depth--;
 
7467
                ndr_print_ptr(ndr, "sids", r->in.sids);
 
7468
                ndr->depth++;
 
7469
                ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
 
7470
                ndr->depth--;
 
7471
                ndr->depth--;
 
7472
        }
 
7473
        if (flags & NDR_OUT) {
 
7474
                ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
 
7475
                ndr->depth++;
 
7476
                ndr_print_ptr(ndr, "rids", r->out.rids);
 
7477
                ndr->depth++;
 
7478
                ndr_print_samr_Ids(ndr, "rids", r->out.rids);
 
7479
                ndr->depth--;
 
7480
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7481
                ndr->depth--;
 
7482
        }
 
7483
        ndr->depth--;
 
7484
}
 
7485
 
 
7486
_PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)
 
7487
{
 
7488
        uint32_t cntr_names_0;
 
7489
        if (flags & NDR_IN) {
 
7490
                if (r->in.domain_handle == NULL) {
 
7491
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7492
                }
 
7493
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7494
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
 
7495
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));
 
7496
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
7497
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_names));
 
7498
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
 
7499
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
 
7500
                }
 
7501
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
 
7502
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
 
7503
                }
 
7504
        }
 
7505
        if (flags & NDR_OUT) {
 
7506
                if (r->out.rids == NULL) {
 
7507
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7508
                }
 
7509
                NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
 
7510
                if (r->out.types == NULL) {
 
7511
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7512
                }
 
7513
                NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
 
7514
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7515
        }
 
7516
        return NDR_ERR_SUCCESS;
 
7517
}
 
7518
 
 
7519
_PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)
 
7520
{
 
7521
        uint32_t cntr_names_0;
 
7522
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7523
        TALLOC_CTX *_mem_save_names_0;
 
7524
        TALLOC_CTX *_mem_save_rids_0;
 
7525
        TALLOC_CTX *_mem_save_types_0;
 
7526
        if (flags & NDR_IN) {
 
7527
                ZERO_STRUCT(r->out);
 
7528
 
 
7529
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7530
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7531
                }
 
7532
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7533
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7534
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7535
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7536
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
 
7537
                if (r->in.num_names > 1000) {
 
7538
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
7539
                }
 
7540
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
 
7541
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));
 
7542
                if (ndr_get_array_length(ndr, &r->in.names) > ndr_get_array_size(ndr, &r->in.names)) {
 
7543
                        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));
 
7544
                }
 
7545
                NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
 
7546
                _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7547
                NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
 
7548
                for (cntr_names_0 = 0; cntr_names_0 < ndr_get_array_length(ndr, &r->in.names); cntr_names_0++) {
 
7549
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
 
7550
                }
 
7551
                for (cntr_names_0 = 0; cntr_names_0 < ndr_get_array_length(ndr, &r->in.names); cntr_names_0++) {
 
7552
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
 
7553
                }
 
7554
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 
7555
                NDR_PULL_ALLOC(ndr, r->out.rids);
 
7556
                ZERO_STRUCTP(r->out.rids);
 
7557
                NDR_PULL_ALLOC(ndr, r->out.types);
 
7558
                ZERO_STRUCTP(r->out.types);
 
7559
                if (r->in.names) {
 
7560
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));
 
7561
                }
 
7562
                if (r->in.names) {
 
7563
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));
 
7564
                }
 
7565
        }
 
7566
        if (flags & NDR_OUT) {
 
7567
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7568
                        NDR_PULL_ALLOC(ndr, r->out.rids);
 
7569
                }
 
7570
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7571
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
 
7572
                NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
 
7573
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
 
7574
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7575
                        NDR_PULL_ALLOC(ndr, r->out.types);
 
7576
                }
 
7577
                _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7578
                NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
 
7579
                NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
 
7580
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
 
7581
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7582
        }
 
7583
        return NDR_ERR_SUCCESS;
 
7584
}
 
7585
 
 
7586
_PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)
 
7587
{
 
7588
        uint32_t cntr_names_0;
 
7589
        ndr_print_struct(ndr, name, "samr_LookupNames");
 
7590
        if (r == NULL) { ndr_print_null(ndr); return; }
 
7591
        ndr->depth++;
 
7592
        if (flags & NDR_SET_VALUES) {
 
7593
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7594
        }
 
7595
        if (flags & NDR_IN) {
 
7596
                ndr_print_struct(ndr, "in", "samr_LookupNames");
 
7597
                ndr->depth++;
 
7598
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7599
                ndr->depth++;
 
7600
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7601
                ndr->depth--;
 
7602
                ndr_print_uint32(ndr, "num_names", r->in.num_names);
 
7603
                ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
 
7604
                ndr->depth++;
 
7605
                for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
 
7606
                        ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
 
7607
                }
 
7608
                ndr->depth--;
 
7609
                ndr->depth--;
 
7610
        }
 
7611
        if (flags & NDR_OUT) {
 
7612
                ndr_print_struct(ndr, "out", "samr_LookupNames");
 
7613
                ndr->depth++;
 
7614
                ndr_print_ptr(ndr, "rids", r->out.rids);
 
7615
                ndr->depth++;
 
7616
                ndr_print_samr_Ids(ndr, "rids", r->out.rids);
 
7617
                ndr->depth--;
 
7618
                ndr_print_ptr(ndr, "types", r->out.types);
 
7619
                ndr->depth++;
 
7620
                ndr_print_samr_Ids(ndr, "types", r->out.types);
 
7621
                ndr->depth--;
 
7622
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7623
                ndr->depth--;
 
7624
        }
 
7625
        ndr->depth--;
 
7626
}
 
7627
 
 
7628
static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)
 
7629
{
 
7630
        uint32_t cntr_rids_0;
 
7631
        if (flags & NDR_IN) {
 
7632
                if (r->in.domain_handle == NULL) {
 
7633
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7634
                }
 
7635
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7636
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));
 
7637
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));
 
7638
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
7639
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_rids));
 
7640
                for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {
 
7641
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));
 
7642
                }
 
7643
        }
 
7644
        if (flags & NDR_OUT) {
 
7645
                if (r->out.names == NULL) {
 
7646
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7647
                }
 
7648
                NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
 
7649
                if (r->out.types == NULL) {
 
7650
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7651
                }
 
7652
                NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
 
7653
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7654
        }
 
7655
        return NDR_ERR_SUCCESS;
 
7656
}
 
7657
 
 
7658
static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)
 
7659
{
 
7660
        uint32_t cntr_rids_0;
 
7661
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7662
        TALLOC_CTX *_mem_save_rids_0;
 
7663
        TALLOC_CTX *_mem_save_names_0;
 
7664
        TALLOC_CTX *_mem_save_types_0;
 
7665
        if (flags & NDR_IN) {
 
7666
                ZERO_STRUCT(r->out);
 
7667
 
 
7668
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7669
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7670
                }
 
7671
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7672
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7673
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7674
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7675
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));
 
7676
                if (r->in.num_rids > 1000) {
 
7677
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
7678
                }
 
7679
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));
 
7680
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));
 
7681
                if (ndr_get_array_length(ndr, &r->in.rids) > ndr_get_array_size(ndr, &r->in.rids)) {
 
7682
                        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));
 
7683
                }
 
7684
                NDR_PULL_ALLOC_N(ndr, r->in.rids, ndr_get_array_size(ndr, &r->in.rids));
 
7685
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7686
                NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);
 
7687
                for (cntr_rids_0 = 0; cntr_rids_0 < ndr_get_array_length(ndr, &r->in.rids); cntr_rids_0++) {
 
7688
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));
 
7689
                }
 
7690
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
 
7691
                NDR_PULL_ALLOC(ndr, r->out.names);
 
7692
                ZERO_STRUCTP(r->out.names);
 
7693
                NDR_PULL_ALLOC(ndr, r->out.types);
 
7694
                ZERO_STRUCTP(r->out.types);
 
7695
                if (r->in.rids) {
 
7696
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));
 
7697
                }
 
7698
                if (r->in.rids) {
 
7699
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));
 
7700
                }
 
7701
        }
 
7702
        if (flags & NDR_OUT) {
 
7703
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7704
                        NDR_PULL_ALLOC(ndr, r->out.names);
 
7705
                }
 
7706
                _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7707
                NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
 
7708
                NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
 
7709
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
 
7710
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7711
                        NDR_PULL_ALLOC(ndr, r->out.types);
 
7712
                }
 
7713
                _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7714
                NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);
 
7715
                NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));
 
7716
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);
 
7717
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7718
        }
 
7719
        return NDR_ERR_SUCCESS;
 
7720
}
 
7721
 
 
7722
_PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)
 
7723
{
 
7724
        uint32_t cntr_rids_0;
 
7725
        ndr_print_struct(ndr, name, "samr_LookupRids");
 
7726
        if (r == NULL) { ndr_print_null(ndr); return; }
 
7727
        ndr->depth++;
 
7728
        if (flags & NDR_SET_VALUES) {
 
7729
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7730
        }
 
7731
        if (flags & NDR_IN) {
 
7732
                ndr_print_struct(ndr, "in", "samr_LookupRids");
 
7733
                ndr->depth++;
 
7734
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7735
                ndr->depth++;
 
7736
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7737
                ndr->depth--;
 
7738
                ndr_print_uint32(ndr, "num_rids", r->in.num_rids);
 
7739
                ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);
 
7740
                ndr->depth++;
 
7741
                for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {
 
7742
                        ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);
 
7743
                }
 
7744
                ndr->depth--;
 
7745
                ndr->depth--;
 
7746
        }
 
7747
        if (flags & NDR_OUT) {
 
7748
                ndr_print_struct(ndr, "out", "samr_LookupRids");
 
7749
                ndr->depth++;
 
7750
                ndr_print_ptr(ndr, "names", r->out.names);
 
7751
                ndr->depth++;
 
7752
                ndr_print_lsa_Strings(ndr, "names", r->out.names);
 
7753
                ndr->depth--;
 
7754
                ndr_print_ptr(ndr, "types", r->out.types);
 
7755
                ndr->depth++;
 
7756
                ndr_print_samr_Ids(ndr, "types", r->out.types);
 
7757
                ndr->depth--;
 
7758
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7759
                ndr->depth--;
 
7760
        }
 
7761
        ndr->depth--;
 
7762
}
 
7763
 
 
7764
static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)
 
7765
{
 
7766
        if (flags & NDR_IN) {
 
7767
                if (r->in.domain_handle == NULL) {
 
7768
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7769
                }
 
7770
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7771
                NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
7772
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
7773
        }
 
7774
        if (flags & NDR_OUT) {
 
7775
                if (r->out.group_handle == NULL) {
 
7776
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7777
                }
 
7778
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
7779
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7780
        }
 
7781
        return NDR_ERR_SUCCESS;
 
7782
}
 
7783
 
 
7784
static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)
 
7785
{
 
7786
        TALLOC_CTX *_mem_save_domain_handle_0;
 
7787
        TALLOC_CTX *_mem_save_group_handle_0;
 
7788
        if (flags & NDR_IN) {
 
7789
                ZERO_STRUCT(r->out);
 
7790
 
 
7791
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7792
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
7793
                }
 
7794
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7795
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
7796
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
7797
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7798
                NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
7799
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
7800
                NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
7801
                ZERO_STRUCTP(r->out.group_handle);
 
7802
        }
 
7803
        if (flags & NDR_OUT) {
 
7804
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7805
                        NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
7806
                }
 
7807
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7808
                NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7809
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
7810
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7811
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7812
        }
 
7813
        return NDR_ERR_SUCCESS;
 
7814
}
 
7815
 
 
7816
_PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)
 
7817
{
 
7818
        ndr_print_struct(ndr, name, "samr_OpenGroup");
 
7819
        if (r == NULL) { ndr_print_null(ndr); return; }
 
7820
        ndr->depth++;
 
7821
        if (flags & NDR_SET_VALUES) {
 
7822
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7823
        }
 
7824
        if (flags & NDR_IN) {
 
7825
                ndr_print_struct(ndr, "in", "samr_OpenGroup");
 
7826
                ndr->depth++;
 
7827
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
7828
                ndr->depth++;
 
7829
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
7830
                ndr->depth--;
 
7831
                ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);
 
7832
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
7833
                ndr->depth--;
 
7834
        }
 
7835
        if (flags & NDR_OUT) {
 
7836
                ndr_print_struct(ndr, "out", "samr_OpenGroup");
 
7837
                ndr->depth++;
 
7838
                ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
 
7839
                ndr->depth++;
 
7840
                ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
 
7841
                ndr->depth--;
 
7842
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7843
                ndr->depth--;
 
7844
        }
 
7845
        ndr->depth--;
 
7846
}
 
7847
 
 
7848
static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)
 
7849
{
 
7850
        if (flags & NDR_IN) {
 
7851
                if (r->in.group_handle == NULL) {
 
7852
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7853
                }
 
7854
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7855
                NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
 
7856
        }
 
7857
        if (flags & NDR_OUT) {
 
7858
                if (r->out.info == NULL) {
 
7859
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7860
                }
 
7861
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
7862
                if (*r->out.info) {
 
7863
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
7864
                        NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
7865
                }
 
7866
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7867
        }
 
7868
        return NDR_ERR_SUCCESS;
 
7869
}
 
7870
 
 
7871
static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)
 
7872
{
 
7873
        uint32_t _ptr_info;
 
7874
        TALLOC_CTX *_mem_save_group_handle_0;
 
7875
        TALLOC_CTX *_mem_save_info_0;
 
7876
        TALLOC_CTX *_mem_save_info_1;
 
7877
        if (flags & NDR_IN) {
 
7878
                ZERO_STRUCT(r->out);
 
7879
 
 
7880
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7881
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
7882
                }
 
7883
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7884
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7885
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7886
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7887
                NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
 
7888
                NDR_PULL_ALLOC(ndr, r->out.info);
 
7889
                ZERO_STRUCTP(r->out.info);
 
7890
        }
 
7891
        if (flags & NDR_OUT) {
 
7892
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7893
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
7894
                }
 
7895
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7896
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
7897
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
7898
                if (_ptr_info) {
 
7899
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
7900
                } else {
 
7901
                        *r->out.info = NULL;
 
7902
                }
 
7903
                if (*r->out.info) {
 
7904
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
7905
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
7906
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
7907
                        NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
7908
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
7909
                }
 
7910
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
7911
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7912
        }
 
7913
        return NDR_ERR_SUCCESS;
 
7914
}
 
7915
 
 
7916
_PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)
 
7917
{
 
7918
        ndr_print_struct(ndr, name, "samr_QueryGroupInfo");
 
7919
        if (r == NULL) { ndr_print_null(ndr); return; }
 
7920
        ndr->depth++;
 
7921
        if (flags & NDR_SET_VALUES) {
 
7922
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
7923
        }
 
7924
        if (flags & NDR_IN) {
 
7925
                ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");
 
7926
                ndr->depth++;
 
7927
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
7928
                ndr->depth++;
 
7929
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
7930
                ndr->depth--;
 
7931
                ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
 
7932
                ndr->depth--;
 
7933
        }
 
7934
        if (flags & NDR_OUT) {
 
7935
                ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");
 
7936
                ndr->depth++;
 
7937
                ndr_print_ptr(ndr, "info", r->out.info);
 
7938
                ndr->depth++;
 
7939
                ndr_print_ptr(ndr, "info", *r->out.info);
 
7940
                ndr->depth++;
 
7941
                if (*r->out.info) {
 
7942
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
7943
                        ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);
 
7944
                }
 
7945
                ndr->depth--;
 
7946
                ndr->depth--;
 
7947
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
7948
                ndr->depth--;
 
7949
        }
 
7950
        ndr->depth--;
 
7951
}
 
7952
 
 
7953
static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)
 
7954
{
 
7955
        if (flags & NDR_IN) {
 
7956
                if (r->in.group_handle == NULL) {
 
7957
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7958
                }
 
7959
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7960
                NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));
 
7961
                if (r->in.info == NULL) {
 
7962
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
7963
                }
 
7964
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
7965
                NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
7966
        }
 
7967
        if (flags & NDR_OUT) {
 
7968
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
7969
        }
 
7970
        return NDR_ERR_SUCCESS;
 
7971
}
 
7972
 
 
7973
static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)
 
7974
{
 
7975
        TALLOC_CTX *_mem_save_group_handle_0;
 
7976
        TALLOC_CTX *_mem_save_info_0;
 
7977
        if (flags & NDR_IN) {
 
7978
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7979
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
7980
                }
 
7981
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7982
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
7983
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
7984
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
7985
                NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));
 
7986
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
7987
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
7988
                }
 
7989
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
7990
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
7991
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
7992
                NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
7993
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
7994
        }
 
7995
        if (flags & NDR_OUT) {
 
7996
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
7997
        }
 
7998
        return NDR_ERR_SUCCESS;
 
7999
}
 
8000
 
 
8001
_PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)
 
8002
{
 
8003
        ndr_print_struct(ndr, name, "samr_SetGroupInfo");
 
8004
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8005
        ndr->depth++;
 
8006
        if (flags & NDR_SET_VALUES) {
 
8007
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8008
        }
 
8009
        if (flags & NDR_IN) {
 
8010
                ndr_print_struct(ndr, "in", "samr_SetGroupInfo");
 
8011
                ndr->depth++;
 
8012
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
8013
                ndr->depth++;
 
8014
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
8015
                ndr->depth--;
 
8016
                ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);
 
8017
                ndr_print_ptr(ndr, "info", r->in.info);
 
8018
                ndr->depth++;
 
8019
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
8020
                ndr_print_samr_GroupInfo(ndr, "info", r->in.info);
 
8021
                ndr->depth--;
 
8022
                ndr->depth--;
 
8023
        }
 
8024
        if (flags & NDR_OUT) {
 
8025
                ndr_print_struct(ndr, "out", "samr_SetGroupInfo");
 
8026
                ndr->depth++;
 
8027
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8028
                ndr->depth--;
 
8029
        }
 
8030
        ndr->depth--;
 
8031
}
 
8032
 
 
8033
static enum ndr_err_code ndr_push_samr_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *r)
 
8034
{
 
8035
        if (flags & NDR_IN) {
 
8036
                if (r->in.group_handle == NULL) {
 
8037
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8038
                }
 
8039
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8040
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
8041
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
 
8042
        }
 
8043
        if (flags & NDR_OUT) {
 
8044
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8045
        }
 
8046
        return NDR_ERR_SUCCESS;
 
8047
}
 
8048
 
 
8049
static enum ndr_err_code ndr_pull_samr_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *r)
 
8050
{
 
8051
        TALLOC_CTX *_mem_save_group_handle_0;
 
8052
        if (flags & NDR_IN) {
 
8053
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8054
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
8055
                }
 
8056
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8057
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
8058
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8059
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8060
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
8061
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
 
8062
        }
 
8063
        if (flags & NDR_OUT) {
 
8064
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8065
        }
 
8066
        return NDR_ERR_SUCCESS;
 
8067
}
 
8068
 
 
8069
_PUBLIC_ void ndr_print_samr_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)
 
8070
{
 
8071
        ndr_print_struct(ndr, name, "samr_AddGroupMember");
 
8072
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8073
        ndr->depth++;
 
8074
        if (flags & NDR_SET_VALUES) {
 
8075
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8076
        }
 
8077
        if (flags & NDR_IN) {
 
8078
                ndr_print_struct(ndr, "in", "samr_AddGroupMember");
 
8079
                ndr->depth++;
 
8080
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
8081
                ndr->depth++;
 
8082
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
8083
                ndr->depth--;
 
8084
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
8085
                ndr_print_uint32(ndr, "flags", r->in.flags);
 
8086
                ndr->depth--;
 
8087
        }
 
8088
        if (flags & NDR_OUT) {
 
8089
                ndr_print_struct(ndr, "out", "samr_AddGroupMember");
 
8090
                ndr->depth++;
 
8091
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8092
                ndr->depth--;
 
8093
        }
 
8094
        ndr->depth--;
 
8095
}
 
8096
 
 
8097
static enum ndr_err_code ndr_push_samr_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)
 
8098
{
 
8099
        if (flags & NDR_IN) {
 
8100
                if (r->in.group_handle == NULL) {
 
8101
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8102
                }
 
8103
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8104
        }
 
8105
        if (flags & NDR_OUT) {
 
8106
                if (r->out.group_handle == NULL) {
 
8107
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8108
                }
 
8109
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
8110
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8111
        }
 
8112
        return NDR_ERR_SUCCESS;
 
8113
}
 
8114
 
 
8115
static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)
 
8116
{
 
8117
        TALLOC_CTX *_mem_save_group_handle_0;
 
8118
        if (flags & NDR_IN) {
 
8119
                ZERO_STRUCT(r->out);
 
8120
 
 
8121
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8122
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
8123
                }
 
8124
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8125
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
8126
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8127
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8128
                NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
8129
                *r->out.group_handle = *r->in.group_handle;
 
8130
        }
 
8131
        if (flags & NDR_OUT) {
 
8132
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8133
                        NDR_PULL_ALLOC(ndr, r->out.group_handle);
 
8134
                }
 
8135
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8136
                NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
8137
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));
 
8138
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8139
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8140
        }
 
8141
        return NDR_ERR_SUCCESS;
 
8142
}
 
8143
 
 
8144
_PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)
 
8145
{
 
8146
        ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");
 
8147
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8148
        ndr->depth++;
 
8149
        if (flags & NDR_SET_VALUES) {
 
8150
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8151
        }
 
8152
        if (flags & NDR_IN) {
 
8153
                ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");
 
8154
                ndr->depth++;
 
8155
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
8156
                ndr->depth++;
 
8157
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
8158
                ndr->depth--;
 
8159
                ndr->depth--;
 
8160
        }
 
8161
        if (flags & NDR_OUT) {
 
8162
                ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");
 
8163
                ndr->depth++;
 
8164
                ndr_print_ptr(ndr, "group_handle", r->out.group_handle);
 
8165
                ndr->depth++;
 
8166
                ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);
 
8167
                ndr->depth--;
 
8168
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8169
                ndr->depth--;
 
8170
        }
 
8171
        ndr->depth--;
 
8172
}
 
8173
 
 
8174
static enum ndr_err_code ndr_push_samr_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)
 
8175
{
 
8176
        if (flags & NDR_IN) {
 
8177
                if (r->in.group_handle == NULL) {
 
8178
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8179
                }
 
8180
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8181
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
8182
        }
 
8183
        if (flags & NDR_OUT) {
 
8184
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8185
        }
 
8186
        return NDR_ERR_SUCCESS;
 
8187
}
 
8188
 
 
8189
static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)
 
8190
{
 
8191
        TALLOC_CTX *_mem_save_group_handle_0;
 
8192
        if (flags & NDR_IN) {
 
8193
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8194
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
8195
                }
 
8196
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8197
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
8198
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8199
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8200
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
8201
        }
 
8202
        if (flags & NDR_OUT) {
 
8203
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8204
        }
 
8205
        return NDR_ERR_SUCCESS;
 
8206
}
 
8207
 
 
8208
_PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)
 
8209
{
 
8210
        ndr_print_struct(ndr, name, "samr_DeleteGroupMember");
 
8211
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8212
        ndr->depth++;
 
8213
        if (flags & NDR_SET_VALUES) {
 
8214
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8215
        }
 
8216
        if (flags & NDR_IN) {
 
8217
                ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");
 
8218
                ndr->depth++;
 
8219
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
8220
                ndr->depth++;
 
8221
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
8222
                ndr->depth--;
 
8223
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
8224
                ndr->depth--;
 
8225
        }
 
8226
        if (flags & NDR_OUT) {
 
8227
                ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");
 
8228
                ndr->depth++;
 
8229
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8230
                ndr->depth--;
 
8231
        }
 
8232
        ndr->depth--;
 
8233
}
 
8234
 
 
8235
static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)
 
8236
{
 
8237
        if (flags & NDR_IN) {
 
8238
                if (r->in.group_handle == NULL) {
 
8239
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8240
                }
 
8241
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8242
        }
 
8243
        if (flags & NDR_OUT) {
 
8244
                if (r->out.rids == NULL) {
 
8245
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8246
                }
 
8247
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
 
8248
                if (*r->out.rids) {
 
8249
                        NDR_CHECK(ndr_push_samr_RidAttrArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
 
8250
                }
 
8251
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8252
        }
 
8253
        return NDR_ERR_SUCCESS;
 
8254
}
 
8255
 
 
8256
static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)
 
8257
{
 
8258
        uint32_t _ptr_rids;
 
8259
        TALLOC_CTX *_mem_save_group_handle_0;
 
8260
        TALLOC_CTX *_mem_save_rids_0;
 
8261
        TALLOC_CTX *_mem_save_rids_1;
 
8262
        if (flags & NDR_IN) {
 
8263
                ZERO_STRUCT(r->out);
 
8264
 
 
8265
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8266
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
8267
                }
 
8268
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8269
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
8270
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8271
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8272
                NDR_PULL_ALLOC(ndr, r->out.rids);
 
8273
                ZERO_STRUCTP(r->out.rids);
 
8274
        }
 
8275
        if (flags & NDR_OUT) {
 
8276
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8277
                        NDR_PULL_ALLOC(ndr, r->out.rids);
 
8278
                }
 
8279
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8280
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
 
8281
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
 
8282
                if (_ptr_rids) {
 
8283
                        NDR_PULL_ALLOC(ndr, *r->out.rids);
 
8284
                } else {
 
8285
                        *r->out.rids = NULL;
 
8286
                }
 
8287
                if (*r->out.rids) {
 
8288
                        _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
8289
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
 
8290
                        NDR_CHECK(ndr_pull_samr_RidAttrArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
 
8291
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
 
8292
                }
 
8293
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
 
8294
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8295
        }
 
8296
        return NDR_ERR_SUCCESS;
 
8297
}
 
8298
 
 
8299
_PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)
 
8300
{
 
8301
        ndr_print_struct(ndr, name, "samr_QueryGroupMember");
 
8302
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8303
        ndr->depth++;
 
8304
        if (flags & NDR_SET_VALUES) {
 
8305
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8306
        }
 
8307
        if (flags & NDR_IN) {
 
8308
                ndr_print_struct(ndr, "in", "samr_QueryGroupMember");
 
8309
                ndr->depth++;
 
8310
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
8311
                ndr->depth++;
 
8312
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
8313
                ndr->depth--;
 
8314
                ndr->depth--;
 
8315
        }
 
8316
        if (flags & NDR_OUT) {
 
8317
                ndr_print_struct(ndr, "out", "samr_QueryGroupMember");
 
8318
                ndr->depth++;
 
8319
                ndr_print_ptr(ndr, "rids", r->out.rids);
 
8320
                ndr->depth++;
 
8321
                ndr_print_ptr(ndr, "rids", *r->out.rids);
 
8322
                ndr->depth++;
 
8323
                if (*r->out.rids) {
 
8324
                        ndr_print_samr_RidAttrArray(ndr, "rids", *r->out.rids);
 
8325
                }
 
8326
                ndr->depth--;
 
8327
                ndr->depth--;
 
8328
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8329
                ndr->depth--;
 
8330
        }
 
8331
        ndr->depth--;
 
8332
}
 
8333
 
 
8334
static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)
 
8335
{
 
8336
        if (flags & NDR_IN) {
 
8337
                if (r->in.group_handle == NULL) {
 
8338
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8339
                }
 
8340
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8341
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
 
8342
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
 
8343
        }
 
8344
        if (flags & NDR_OUT) {
 
8345
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8346
        }
 
8347
        return NDR_ERR_SUCCESS;
 
8348
}
 
8349
 
 
8350
static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)
 
8351
{
 
8352
        TALLOC_CTX *_mem_save_group_handle_0;
 
8353
        if (flags & NDR_IN) {
 
8354
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8355
                        NDR_PULL_ALLOC(ndr, r->in.group_handle);
 
8356
                }
 
8357
                _mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8358
                NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);
 
8359
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));
 
8360
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8361
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
 
8362
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
 
8363
        }
 
8364
        if (flags & NDR_OUT) {
 
8365
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8366
        }
 
8367
        return NDR_ERR_SUCCESS;
 
8368
}
 
8369
 
 
8370
_PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)
 
8371
{
 
8372
        ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");
 
8373
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8374
        ndr->depth++;
 
8375
        if (flags & NDR_SET_VALUES) {
 
8376
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8377
        }
 
8378
        if (flags & NDR_IN) {
 
8379
                ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");
 
8380
                ndr->depth++;
 
8381
                ndr_print_ptr(ndr, "group_handle", r->in.group_handle);
 
8382
                ndr->depth++;
 
8383
                ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);
 
8384
                ndr->depth--;
 
8385
                ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
 
8386
                ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
 
8387
                ndr->depth--;
 
8388
        }
 
8389
        if (flags & NDR_OUT) {
 
8390
                ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");
 
8391
                ndr->depth++;
 
8392
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8393
                ndr->depth--;
 
8394
        }
 
8395
        ndr->depth--;
 
8396
}
 
8397
 
 
8398
static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)
 
8399
{
 
8400
        if (flags & NDR_IN) {
 
8401
                if (r->in.domain_handle == NULL) {
 
8402
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8403
                }
 
8404
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
8405
                NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
8406
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
8407
        }
 
8408
        if (flags & NDR_OUT) {
 
8409
                if (r->out.alias_handle == NULL) {
 
8410
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8411
                }
 
8412
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
8413
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8414
        }
 
8415
        return NDR_ERR_SUCCESS;
 
8416
}
 
8417
 
 
8418
static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)
 
8419
{
 
8420
        TALLOC_CTX *_mem_save_domain_handle_0;
 
8421
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8422
        if (flags & NDR_IN) {
 
8423
                ZERO_STRUCT(r->out);
 
8424
 
 
8425
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8426
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
8427
                }
 
8428
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8429
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
8430
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
8431
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8432
                NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
8433
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
8434
                NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
8435
                ZERO_STRUCTP(r->out.alias_handle);
 
8436
        }
 
8437
        if (flags & NDR_OUT) {
 
8438
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8439
                        NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
8440
                }
 
8441
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8442
                NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8443
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
8444
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8445
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8446
        }
 
8447
        return NDR_ERR_SUCCESS;
 
8448
}
 
8449
 
 
8450
_PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)
 
8451
{
 
8452
        ndr_print_struct(ndr, name, "samr_OpenAlias");
 
8453
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8454
        ndr->depth++;
 
8455
        if (flags & NDR_SET_VALUES) {
 
8456
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8457
        }
 
8458
        if (flags & NDR_IN) {
 
8459
                ndr_print_struct(ndr, "in", "samr_OpenAlias");
 
8460
                ndr->depth++;
 
8461
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
8462
                ndr->depth++;
 
8463
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
8464
                ndr->depth--;
 
8465
                ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);
 
8466
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
8467
                ndr->depth--;
 
8468
        }
 
8469
        if (flags & NDR_OUT) {
 
8470
                ndr_print_struct(ndr, "out", "samr_OpenAlias");
 
8471
                ndr->depth++;
 
8472
                ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
 
8473
                ndr->depth++;
 
8474
                ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
 
8475
                ndr->depth--;
 
8476
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8477
                ndr->depth--;
 
8478
        }
 
8479
        ndr->depth--;
 
8480
}
 
8481
 
 
8482
static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)
 
8483
{
 
8484
        if (flags & NDR_IN) {
 
8485
                if (r->in.alias_handle == NULL) {
 
8486
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8487
                }
 
8488
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8489
                NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
 
8490
        }
 
8491
        if (flags & NDR_OUT) {
 
8492
                if (r->out.info == NULL) {
 
8493
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8494
                }
 
8495
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
8496
                if (*r->out.info) {
 
8497
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
8498
                        NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
8499
                }
 
8500
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8501
        }
 
8502
        return NDR_ERR_SUCCESS;
 
8503
}
 
8504
 
 
8505
static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)
 
8506
{
 
8507
        uint32_t _ptr_info;
 
8508
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8509
        TALLOC_CTX *_mem_save_info_0;
 
8510
        TALLOC_CTX *_mem_save_info_1;
 
8511
        if (flags & NDR_IN) {
 
8512
                ZERO_STRUCT(r->out);
 
8513
 
 
8514
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8515
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8516
                }
 
8517
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8518
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8519
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8520
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8521
                NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
 
8522
                NDR_PULL_ALLOC(ndr, r->out.info);
 
8523
                ZERO_STRUCTP(r->out.info);
 
8524
        }
 
8525
        if (flags & NDR_OUT) {
 
8526
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8527
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
8528
                }
 
8529
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8530
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
8531
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
8532
                if (_ptr_info) {
 
8533
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
8534
                } else {
 
8535
                        *r->out.info = NULL;
 
8536
                }
 
8537
                if (*r->out.info) {
 
8538
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
8539
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
8540
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
8541
                        NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
8542
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
8543
                }
 
8544
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
8545
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8546
        }
 
8547
        return NDR_ERR_SUCCESS;
 
8548
}
 
8549
 
 
8550
_PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)
 
8551
{
 
8552
        ndr_print_struct(ndr, name, "samr_QueryAliasInfo");
 
8553
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8554
        ndr->depth++;
 
8555
        if (flags & NDR_SET_VALUES) {
 
8556
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8557
        }
 
8558
        if (flags & NDR_IN) {
 
8559
                ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");
 
8560
                ndr->depth++;
 
8561
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8562
                ndr->depth++;
 
8563
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8564
                ndr->depth--;
 
8565
                ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
 
8566
                ndr->depth--;
 
8567
        }
 
8568
        if (flags & NDR_OUT) {
 
8569
                ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");
 
8570
                ndr->depth++;
 
8571
                ndr_print_ptr(ndr, "info", r->out.info);
 
8572
                ndr->depth++;
 
8573
                ndr_print_ptr(ndr, "info", *r->out.info);
 
8574
                ndr->depth++;
 
8575
                if (*r->out.info) {
 
8576
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
8577
                        ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);
 
8578
                }
 
8579
                ndr->depth--;
 
8580
                ndr->depth--;
 
8581
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8582
                ndr->depth--;
 
8583
        }
 
8584
        ndr->depth--;
 
8585
}
 
8586
 
 
8587
static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)
 
8588
{
 
8589
        if (flags & NDR_IN) {
 
8590
                if (r->in.alias_handle == NULL) {
 
8591
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8592
                }
 
8593
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8594
                NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));
 
8595
                if (r->in.info == NULL) {
 
8596
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8597
                }
 
8598
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
8599
                NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
8600
        }
 
8601
        if (flags & NDR_OUT) {
 
8602
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8603
        }
 
8604
        return NDR_ERR_SUCCESS;
 
8605
}
 
8606
 
 
8607
static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)
 
8608
{
 
8609
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8610
        TALLOC_CTX *_mem_save_info_0;
 
8611
        if (flags & NDR_IN) {
 
8612
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8613
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8614
                }
 
8615
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8616
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8617
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8618
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8619
                NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));
 
8620
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8621
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
8622
                }
 
8623
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8624
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
8625
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
8626
                NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
8627
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
8628
        }
 
8629
        if (flags & NDR_OUT) {
 
8630
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8631
        }
 
8632
        return NDR_ERR_SUCCESS;
 
8633
}
 
8634
 
 
8635
_PUBLIC_ void ndr_print_samr_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)
 
8636
{
 
8637
        ndr_print_struct(ndr, name, "samr_SetAliasInfo");
 
8638
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8639
        ndr->depth++;
 
8640
        if (flags & NDR_SET_VALUES) {
 
8641
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8642
        }
 
8643
        if (flags & NDR_IN) {
 
8644
                ndr_print_struct(ndr, "in", "samr_SetAliasInfo");
 
8645
                ndr->depth++;
 
8646
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8647
                ndr->depth++;
 
8648
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8649
                ndr->depth--;
 
8650
                ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);
 
8651
                ndr_print_ptr(ndr, "info", r->in.info);
 
8652
                ndr->depth++;
 
8653
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
8654
                ndr_print_samr_AliasInfo(ndr, "info", r->in.info);
 
8655
                ndr->depth--;
 
8656
                ndr->depth--;
 
8657
        }
 
8658
        if (flags & NDR_OUT) {
 
8659
                ndr_print_struct(ndr, "out", "samr_SetAliasInfo");
 
8660
                ndr->depth++;
 
8661
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8662
                ndr->depth--;
 
8663
        }
 
8664
        ndr->depth--;
 
8665
}
 
8666
 
 
8667
static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)
 
8668
{
 
8669
        if (flags & NDR_IN) {
 
8670
                if (r->in.alias_handle == NULL) {
 
8671
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8672
                }
 
8673
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8674
        }
 
8675
        if (flags & NDR_OUT) {
 
8676
                if (r->out.alias_handle == NULL) {
 
8677
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8678
                }
 
8679
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
8680
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8681
        }
 
8682
        return NDR_ERR_SUCCESS;
 
8683
}
 
8684
 
 
8685
static enum ndr_err_code ndr_pull_samr_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)
 
8686
{
 
8687
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8688
        if (flags & NDR_IN) {
 
8689
                ZERO_STRUCT(r->out);
 
8690
 
 
8691
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8692
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8693
                }
 
8694
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8695
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8696
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8697
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8698
                NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
8699
                *r->out.alias_handle = *r->in.alias_handle;
 
8700
        }
 
8701
        if (flags & NDR_OUT) {
 
8702
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8703
                        NDR_PULL_ALLOC(ndr, r->out.alias_handle);
 
8704
                }
 
8705
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8706
                NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8707
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));
 
8708
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8709
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8710
        }
 
8711
        return NDR_ERR_SUCCESS;
 
8712
}
 
8713
 
 
8714
_PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)
 
8715
{
 
8716
        ndr_print_struct(ndr, name, "samr_DeleteDomAlias");
 
8717
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8718
        ndr->depth++;
 
8719
        if (flags & NDR_SET_VALUES) {
 
8720
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8721
        }
 
8722
        if (flags & NDR_IN) {
 
8723
                ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");
 
8724
                ndr->depth++;
 
8725
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8726
                ndr->depth++;
 
8727
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8728
                ndr->depth--;
 
8729
                ndr->depth--;
 
8730
        }
 
8731
        if (flags & NDR_OUT) {
 
8732
                ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");
 
8733
                ndr->depth++;
 
8734
                ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);
 
8735
                ndr->depth++;
 
8736
                ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);
 
8737
                ndr->depth--;
 
8738
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8739
                ndr->depth--;
 
8740
        }
 
8741
        ndr->depth--;
 
8742
}
 
8743
 
 
8744
static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)
 
8745
{
 
8746
        if (flags & NDR_IN) {
 
8747
                if (r->in.alias_handle == NULL) {
 
8748
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8749
                }
 
8750
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8751
                if (r->in.sid == NULL) {
 
8752
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8753
                }
 
8754
                NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
8755
        }
 
8756
        if (flags & NDR_OUT) {
 
8757
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8758
        }
 
8759
        return NDR_ERR_SUCCESS;
 
8760
}
 
8761
 
 
8762
static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)
 
8763
{
 
8764
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8765
        TALLOC_CTX *_mem_save_sid_0;
 
8766
        if (flags & NDR_IN) {
 
8767
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8768
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8769
                }
 
8770
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8771
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8772
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8773
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8774
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8775
                        NDR_PULL_ALLOC(ndr, r->in.sid);
 
8776
                }
 
8777
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8778
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 
8779
                NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
8780
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
8781
        }
 
8782
        if (flags & NDR_OUT) {
 
8783
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8784
        }
 
8785
        return NDR_ERR_SUCCESS;
 
8786
}
 
8787
 
 
8788
_PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)
 
8789
{
 
8790
        ndr_print_struct(ndr, name, "samr_AddAliasMember");
 
8791
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8792
        ndr->depth++;
 
8793
        if (flags & NDR_SET_VALUES) {
 
8794
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8795
        }
 
8796
        if (flags & NDR_IN) {
 
8797
                ndr_print_struct(ndr, "in", "samr_AddAliasMember");
 
8798
                ndr->depth++;
 
8799
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8800
                ndr->depth++;
 
8801
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8802
                ndr->depth--;
 
8803
                ndr_print_ptr(ndr, "sid", r->in.sid);
 
8804
                ndr->depth++;
 
8805
                ndr_print_dom_sid2(ndr, "sid", r->in.sid);
 
8806
                ndr->depth--;
 
8807
                ndr->depth--;
 
8808
        }
 
8809
        if (flags & NDR_OUT) {
 
8810
                ndr_print_struct(ndr, "out", "samr_AddAliasMember");
 
8811
                ndr->depth++;
 
8812
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8813
                ndr->depth--;
 
8814
        }
 
8815
        ndr->depth--;
 
8816
}
 
8817
 
 
8818
static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)
 
8819
{
 
8820
        if (flags & NDR_IN) {
 
8821
                if (r->in.alias_handle == NULL) {
 
8822
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8823
                }
 
8824
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8825
                if (r->in.sid == NULL) {
 
8826
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8827
                }
 
8828
                NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
8829
        }
 
8830
        if (flags & NDR_OUT) {
 
8831
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8832
        }
 
8833
        return NDR_ERR_SUCCESS;
 
8834
}
 
8835
 
 
8836
static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)
 
8837
{
 
8838
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8839
        TALLOC_CTX *_mem_save_sid_0;
 
8840
        if (flags & NDR_IN) {
 
8841
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8842
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8843
                }
 
8844
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8845
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8846
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8847
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8848
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8849
                        NDR_PULL_ALLOC(ndr, r->in.sid);
 
8850
                }
 
8851
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8852
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 
8853
                NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
8854
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
8855
        }
 
8856
        if (flags & NDR_OUT) {
 
8857
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8858
        }
 
8859
        return NDR_ERR_SUCCESS;
 
8860
}
 
8861
 
 
8862
_PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)
 
8863
{
 
8864
        ndr_print_struct(ndr, name, "samr_DeleteAliasMember");
 
8865
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8866
        ndr->depth++;
 
8867
        if (flags & NDR_SET_VALUES) {
 
8868
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8869
        }
 
8870
        if (flags & NDR_IN) {
 
8871
                ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");
 
8872
                ndr->depth++;
 
8873
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8874
                ndr->depth++;
 
8875
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8876
                ndr->depth--;
 
8877
                ndr_print_ptr(ndr, "sid", r->in.sid);
 
8878
                ndr->depth++;
 
8879
                ndr_print_dom_sid2(ndr, "sid", r->in.sid);
 
8880
                ndr->depth--;
 
8881
                ndr->depth--;
 
8882
        }
 
8883
        if (flags & NDR_OUT) {
 
8884
                ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");
 
8885
                ndr->depth++;
 
8886
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8887
                ndr->depth--;
 
8888
        }
 
8889
        ndr->depth--;
 
8890
}
 
8891
 
 
8892
static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)
 
8893
{
 
8894
        if (flags & NDR_IN) {
 
8895
                if (r->in.alias_handle == NULL) {
 
8896
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8897
                }
 
8898
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8899
        }
 
8900
        if (flags & NDR_OUT) {
 
8901
                if (r->out.sids == NULL) {
 
8902
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8903
                }
 
8904
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
 
8905
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8906
        }
 
8907
        return NDR_ERR_SUCCESS;
 
8908
}
 
8909
 
 
8910
static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)
 
8911
{
 
8912
        TALLOC_CTX *_mem_save_alias_handle_0;
 
8913
        TALLOC_CTX *_mem_save_sids_0;
 
8914
        if (flags & NDR_IN) {
 
8915
                ZERO_STRUCT(r->out);
 
8916
 
 
8917
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8918
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
8919
                }
 
8920
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8921
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
8922
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
8923
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
8924
                NDR_PULL_ALLOC(ndr, r->out.sids);
 
8925
                ZERO_STRUCTP(r->out.sids);
 
8926
        }
 
8927
        if (flags & NDR_OUT) {
 
8928
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8929
                        NDR_PULL_ALLOC(ndr, r->out.sids);
 
8930
                }
 
8931
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
8932
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
 
8933
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
 
8934
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
 
8935
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
8936
        }
 
8937
        return NDR_ERR_SUCCESS;
 
8938
}
 
8939
 
 
8940
_PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)
 
8941
{
 
8942
        ndr_print_struct(ndr, name, "samr_GetMembersInAlias");
 
8943
        if (r == NULL) { ndr_print_null(ndr); return; }
 
8944
        ndr->depth++;
 
8945
        if (flags & NDR_SET_VALUES) {
 
8946
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
8947
        }
 
8948
        if (flags & NDR_IN) {
 
8949
                ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");
 
8950
                ndr->depth++;
 
8951
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
8952
                ndr->depth++;
 
8953
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
8954
                ndr->depth--;
 
8955
                ndr->depth--;
 
8956
        }
 
8957
        if (flags & NDR_OUT) {
 
8958
                ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");
 
8959
                ndr->depth++;
 
8960
                ndr_print_ptr(ndr, "sids", r->out.sids);
 
8961
                ndr->depth++;
 
8962
                ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
 
8963
                ndr->depth--;
 
8964
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
8965
                ndr->depth--;
 
8966
        }
 
8967
        ndr->depth--;
 
8968
}
 
8969
 
 
8970
_PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)
 
8971
{
 
8972
        if (flags & NDR_IN) {
 
8973
                if (r->in.domain_handle == NULL) {
 
8974
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8975
                }
 
8976
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
8977
                NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
8978
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
8979
        }
 
8980
        if (flags & NDR_OUT) {
 
8981
                if (r->out.user_handle == NULL) {
 
8982
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
8983
                }
 
8984
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
8985
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
8986
        }
 
8987
        return NDR_ERR_SUCCESS;
 
8988
}
 
8989
 
 
8990
_PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)
 
8991
{
 
8992
        TALLOC_CTX *_mem_save_domain_handle_0;
 
8993
        TALLOC_CTX *_mem_save_user_handle_0;
 
8994
        if (flags & NDR_IN) {
 
8995
                ZERO_STRUCT(r->out);
 
8996
 
 
8997
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
8998
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
8999
                }
 
9000
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9001
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9002
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9003
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9004
                NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
9005
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
9006
                NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
9007
                ZERO_STRUCTP(r->out.user_handle);
 
9008
        }
 
9009
        if (flags & NDR_OUT) {
 
9010
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9011
                        NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
9012
                }
 
9013
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9014
                NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9015
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
9016
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9017
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9018
        }
 
9019
        return NDR_ERR_SUCCESS;
 
9020
}
 
9021
 
 
9022
_PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)
 
9023
{
 
9024
        ndr_print_struct(ndr, name, "samr_OpenUser");
 
9025
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9026
        ndr->depth++;
 
9027
        if (flags & NDR_SET_VALUES) {
 
9028
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9029
        }
 
9030
        if (flags & NDR_IN) {
 
9031
                ndr_print_struct(ndr, "in", "samr_OpenUser");
 
9032
                ndr->depth++;
 
9033
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9034
                ndr->depth++;
 
9035
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9036
                ndr->depth--;
 
9037
                ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
 
9038
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
9039
                ndr->depth--;
 
9040
        }
 
9041
        if (flags & NDR_OUT) {
 
9042
                ndr_print_struct(ndr, "out", "samr_OpenUser");
 
9043
                ndr->depth++;
 
9044
                ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
 
9045
                ndr->depth++;
 
9046
                ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
 
9047
                ndr->depth--;
 
9048
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9049
                ndr->depth--;
 
9050
        }
 
9051
        ndr->depth--;
 
9052
}
 
9053
 
 
9054
static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)
 
9055
{
 
9056
        if (flags & NDR_IN) {
 
9057
                if (r->in.user_handle == NULL) {
 
9058
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9059
                }
 
9060
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9061
        }
 
9062
        if (flags & NDR_OUT) {
 
9063
                if (r->out.user_handle == NULL) {
 
9064
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9065
                }
 
9066
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
9067
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9068
        }
 
9069
        return NDR_ERR_SUCCESS;
 
9070
}
 
9071
 
 
9072
static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)
 
9073
{
 
9074
        TALLOC_CTX *_mem_save_user_handle_0;
 
9075
        if (flags & NDR_IN) {
 
9076
                ZERO_STRUCT(r->out);
 
9077
 
 
9078
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9079
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9080
                }
 
9081
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9082
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9083
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9084
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9085
                NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
9086
                *r->out.user_handle = *r->in.user_handle;
 
9087
        }
 
9088
        if (flags & NDR_OUT) {
 
9089
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9090
                        NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
9091
                }
 
9092
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9093
                NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9094
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
9095
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9096
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9097
        }
 
9098
        return NDR_ERR_SUCCESS;
 
9099
}
 
9100
 
 
9101
_PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)
 
9102
{
 
9103
        ndr_print_struct(ndr, name, "samr_DeleteUser");
 
9104
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9105
        ndr->depth++;
 
9106
        if (flags & NDR_SET_VALUES) {
 
9107
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9108
        }
 
9109
        if (flags & NDR_IN) {
 
9110
                ndr_print_struct(ndr, "in", "samr_DeleteUser");
 
9111
                ndr->depth++;
 
9112
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9113
                ndr->depth++;
 
9114
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9115
                ndr->depth--;
 
9116
                ndr->depth--;
 
9117
        }
 
9118
        if (flags & NDR_OUT) {
 
9119
                ndr_print_struct(ndr, "out", "samr_DeleteUser");
 
9120
                ndr->depth++;
 
9121
                ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
 
9122
                ndr->depth++;
 
9123
                ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
 
9124
                ndr->depth--;
 
9125
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9126
                ndr->depth--;
 
9127
        }
 
9128
        ndr->depth--;
 
9129
}
 
9130
 
 
9131
_PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)
 
9132
{
 
9133
        if (flags & NDR_IN) {
 
9134
                if (r->in.user_handle == NULL) {
 
9135
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9136
                }
 
9137
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9138
                NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
 
9139
        }
 
9140
        if (flags & NDR_OUT) {
 
9141
                if (r->out.info == NULL) {
 
9142
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9143
                }
 
9144
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
9145
                if (*r->out.info) {
 
9146
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
9147
                        NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
9148
                }
 
9149
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9150
        }
 
9151
        return NDR_ERR_SUCCESS;
 
9152
}
 
9153
 
 
9154
_PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)
 
9155
{
 
9156
        uint32_t _ptr_info;
 
9157
        TALLOC_CTX *_mem_save_user_handle_0;
 
9158
        TALLOC_CTX *_mem_save_info_0;
 
9159
        TALLOC_CTX *_mem_save_info_1;
 
9160
        if (flags & NDR_IN) {
 
9161
                ZERO_STRUCT(r->out);
 
9162
 
 
9163
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9164
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9165
                }
 
9166
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9167
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9168
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9169
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9170
                NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
 
9171
                NDR_PULL_ALLOC(ndr, r->out.info);
 
9172
                ZERO_STRUCTP(r->out.info);
 
9173
        }
 
9174
        if (flags & NDR_OUT) {
 
9175
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9176
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
9177
                }
 
9178
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9179
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
9180
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
9181
                if (_ptr_info) {
 
9182
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
9183
                } else {
 
9184
                        *r->out.info = NULL;
 
9185
                }
 
9186
                if (*r->out.info) {
 
9187
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
9188
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
9189
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
9190
                        NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
9191
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
9192
                }
 
9193
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
9194
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9195
        }
 
9196
        return NDR_ERR_SUCCESS;
 
9197
}
 
9198
 
 
9199
_PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)
 
9200
{
 
9201
        ndr_print_struct(ndr, name, "samr_QueryUserInfo");
 
9202
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9203
        ndr->depth++;
 
9204
        if (flags & NDR_SET_VALUES) {
 
9205
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9206
        }
 
9207
        if (flags & NDR_IN) {
 
9208
                ndr_print_struct(ndr, "in", "samr_QueryUserInfo");
 
9209
                ndr->depth++;
 
9210
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9211
                ndr->depth++;
 
9212
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9213
                ndr->depth--;
 
9214
                ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
 
9215
                ndr->depth--;
 
9216
        }
 
9217
        if (flags & NDR_OUT) {
 
9218
                ndr_print_struct(ndr, "out", "samr_QueryUserInfo");
 
9219
                ndr->depth++;
 
9220
                ndr_print_ptr(ndr, "info", r->out.info);
 
9221
                ndr->depth++;
 
9222
                ndr_print_ptr(ndr, "info", *r->out.info);
 
9223
                ndr->depth++;
 
9224
                if (*r->out.info) {
 
9225
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
9226
                        ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
 
9227
                }
 
9228
                ndr->depth--;
 
9229
                ndr->depth--;
 
9230
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9231
                ndr->depth--;
 
9232
        }
 
9233
        ndr->depth--;
 
9234
}
 
9235
 
 
9236
_PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)
 
9237
{
 
9238
        if (flags & NDR_IN) {
 
9239
                if (r->in.user_handle == NULL) {
 
9240
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9241
                }
 
9242
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9243
                NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
 
9244
                if (r->in.info == NULL) {
 
9245
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9246
                }
 
9247
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
9248
                NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
9249
        }
 
9250
        if (flags & NDR_OUT) {
 
9251
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9252
        }
 
9253
        return NDR_ERR_SUCCESS;
 
9254
}
 
9255
 
 
9256
_PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)
 
9257
{
 
9258
        TALLOC_CTX *_mem_save_user_handle_0;
 
9259
        TALLOC_CTX *_mem_save_info_0;
 
9260
        if (flags & NDR_IN) {
 
9261
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9262
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9263
                }
 
9264
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9265
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9266
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9267
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9268
                NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
 
9269
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9270
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
9271
                }
 
9272
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9273
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
9274
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
9275
                NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
9276
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
9277
        }
 
9278
        if (flags & NDR_OUT) {
 
9279
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9280
        }
 
9281
        return NDR_ERR_SUCCESS;
 
9282
}
 
9283
 
 
9284
_PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)
 
9285
{
 
9286
        ndr_print_struct(ndr, name, "samr_SetUserInfo");
 
9287
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9288
        ndr->depth++;
 
9289
        if (flags & NDR_SET_VALUES) {
 
9290
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9291
        }
 
9292
        if (flags & NDR_IN) {
 
9293
                ndr_print_struct(ndr, "in", "samr_SetUserInfo");
 
9294
                ndr->depth++;
 
9295
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9296
                ndr->depth++;
 
9297
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9298
                ndr->depth--;
 
9299
                ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
 
9300
                ndr_print_ptr(ndr, "info", r->in.info);
 
9301
                ndr->depth++;
 
9302
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
9303
                ndr_print_samr_UserInfo(ndr, "info", r->in.info);
 
9304
                ndr->depth--;
 
9305
                ndr->depth--;
 
9306
        }
 
9307
        if (flags & NDR_OUT) {
 
9308
                ndr_print_struct(ndr, "out", "samr_SetUserInfo");
 
9309
                ndr->depth++;
 
9310
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9311
                ndr->depth--;
 
9312
        }
 
9313
        ndr->depth--;
 
9314
}
 
9315
 
 
9316
static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)
 
9317
{
 
9318
        if (flags & NDR_IN) {
 
9319
                if (r->in.user_handle == NULL) {
 
9320
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9321
                }
 
9322
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9323
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));
 
9324
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));
 
9325
                if (r->in.old_lm_crypted) {
 
9326
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
 
9327
                }
 
9328
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));
 
9329
                if (r->in.new_lm_crypted) {
 
9330
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
 
9331
                }
 
9332
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));
 
9333
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));
 
9334
                if (r->in.old_nt_crypted) {
 
9335
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
 
9336
                }
 
9337
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));
 
9338
                if (r->in.new_nt_crypted) {
 
9339
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
 
9340
                }
 
9341
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));
 
9342
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));
 
9343
                if (r->in.nt_cross) {
 
9344
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
 
9345
                }
 
9346
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));
 
9347
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));
 
9348
                if (r->in.lm_cross) {
 
9349
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
 
9350
                }
 
9351
        }
 
9352
        if (flags & NDR_OUT) {
 
9353
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9354
        }
 
9355
        return NDR_ERR_SUCCESS;
 
9356
}
 
9357
 
 
9358
static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)
 
9359
{
 
9360
        uint32_t _ptr_old_lm_crypted;
 
9361
        uint32_t _ptr_new_lm_crypted;
 
9362
        uint32_t _ptr_old_nt_crypted;
 
9363
        uint32_t _ptr_new_nt_crypted;
 
9364
        uint32_t _ptr_nt_cross;
 
9365
        uint32_t _ptr_lm_cross;
 
9366
        TALLOC_CTX *_mem_save_user_handle_0;
 
9367
        TALLOC_CTX *_mem_save_old_lm_crypted_0;
 
9368
        TALLOC_CTX *_mem_save_new_lm_crypted_0;
 
9369
        TALLOC_CTX *_mem_save_old_nt_crypted_0;
 
9370
        TALLOC_CTX *_mem_save_new_nt_crypted_0;
 
9371
        TALLOC_CTX *_mem_save_nt_cross_0;
 
9372
        TALLOC_CTX *_mem_save_lm_cross_0;
 
9373
        if (flags & NDR_IN) {
 
9374
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9375
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9376
                }
 
9377
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9378
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9379
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9380
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9381
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));
 
9382
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));
 
9383
                if (_ptr_old_lm_crypted) {
 
9384
                        NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);
 
9385
                } else {
 
9386
                        r->in.old_lm_crypted = NULL;
 
9387
                }
 
9388
                if (r->in.old_lm_crypted) {
 
9389
                        _mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9390
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);
 
9391
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));
 
9392
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);
 
9393
                }
 
9394
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));
 
9395
                if (_ptr_new_lm_crypted) {
 
9396
                        NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);
 
9397
                } else {
 
9398
                        r->in.new_lm_crypted = NULL;
 
9399
                }
 
9400
                if (r->in.new_lm_crypted) {
 
9401
                        _mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9402
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);
 
9403
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));
 
9404
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);
 
9405
                }
 
9406
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));
 
9407
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));
 
9408
                if (_ptr_old_nt_crypted) {
 
9409
                        NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);
 
9410
                } else {
 
9411
                        r->in.old_nt_crypted = NULL;
 
9412
                }
 
9413
                if (r->in.old_nt_crypted) {
 
9414
                        _mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9415
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);
 
9416
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));
 
9417
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);
 
9418
                }
 
9419
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));
 
9420
                if (_ptr_new_nt_crypted) {
 
9421
                        NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);
 
9422
                } else {
 
9423
                        r->in.new_nt_crypted = NULL;
 
9424
                }
 
9425
                if (r->in.new_nt_crypted) {
 
9426
                        _mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9427
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);
 
9428
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));
 
9429
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);
 
9430
                }
 
9431
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));
 
9432
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));
 
9433
                if (_ptr_nt_cross) {
 
9434
                        NDR_PULL_ALLOC(ndr, r->in.nt_cross);
 
9435
                } else {
 
9436
                        r->in.nt_cross = NULL;
 
9437
                }
 
9438
                if (r->in.nt_cross) {
 
9439
                        _mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9440
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);
 
9441
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));
 
9442
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);
 
9443
                }
 
9444
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));
 
9445
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));
 
9446
                if (_ptr_lm_cross) {
 
9447
                        NDR_PULL_ALLOC(ndr, r->in.lm_cross);
 
9448
                } else {
 
9449
                        r->in.lm_cross = NULL;
 
9450
                }
 
9451
                if (r->in.lm_cross) {
 
9452
                        _mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9453
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);
 
9454
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));
 
9455
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);
 
9456
                }
 
9457
        }
 
9458
        if (flags & NDR_OUT) {
 
9459
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9460
        }
 
9461
        return NDR_ERR_SUCCESS;
 
9462
}
 
9463
 
 
9464
_PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)
 
9465
{
 
9466
        ndr_print_struct(ndr, name, "samr_ChangePasswordUser");
 
9467
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9468
        ndr->depth++;
 
9469
        if (flags & NDR_SET_VALUES) {
 
9470
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9471
        }
 
9472
        if (flags & NDR_IN) {
 
9473
                ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");
 
9474
                ndr->depth++;
 
9475
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9476
                ndr->depth++;
 
9477
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9478
                ndr->depth--;
 
9479
                ndr_print_uint8(ndr, "lm_present", r->in.lm_present);
 
9480
                ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);
 
9481
                ndr->depth++;
 
9482
                if (r->in.old_lm_crypted) {
 
9483
                        ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);
 
9484
                }
 
9485
                ndr->depth--;
 
9486
                ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);
 
9487
                ndr->depth++;
 
9488
                if (r->in.new_lm_crypted) {
 
9489
                        ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);
 
9490
                }
 
9491
                ndr->depth--;
 
9492
                ndr_print_uint8(ndr, "nt_present", r->in.nt_present);
 
9493
                ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);
 
9494
                ndr->depth++;
 
9495
                if (r->in.old_nt_crypted) {
 
9496
                        ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);
 
9497
                }
 
9498
                ndr->depth--;
 
9499
                ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);
 
9500
                ndr->depth++;
 
9501
                if (r->in.new_nt_crypted) {
 
9502
                        ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);
 
9503
                }
 
9504
                ndr->depth--;
 
9505
                ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);
 
9506
                ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);
 
9507
                ndr->depth++;
 
9508
                if (r->in.nt_cross) {
 
9509
                        ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);
 
9510
                }
 
9511
                ndr->depth--;
 
9512
                ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);
 
9513
                ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);
 
9514
                ndr->depth++;
 
9515
                if (r->in.lm_cross) {
 
9516
                        ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);
 
9517
                }
 
9518
                ndr->depth--;
 
9519
                ndr->depth--;
 
9520
        }
 
9521
        if (flags & NDR_OUT) {
 
9522
                ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");
 
9523
                ndr->depth++;
 
9524
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9525
                ndr->depth--;
 
9526
        }
 
9527
        ndr->depth--;
 
9528
}
 
9529
 
 
9530
static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)
 
9531
{
 
9532
        if (flags & NDR_IN) {
 
9533
                if (r->in.user_handle == NULL) {
 
9534
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9535
                }
 
9536
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9537
        }
 
9538
        if (flags & NDR_OUT) {
 
9539
                if (r->out.rids == NULL) {
 
9540
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9541
                }
 
9542
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));
 
9543
                if (*r->out.rids) {
 
9544
                        NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
 
9545
                }
 
9546
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9547
        }
 
9548
        return NDR_ERR_SUCCESS;
 
9549
}
 
9550
 
 
9551
static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)
 
9552
{
 
9553
        uint32_t _ptr_rids;
 
9554
        TALLOC_CTX *_mem_save_user_handle_0;
 
9555
        TALLOC_CTX *_mem_save_rids_0;
 
9556
        TALLOC_CTX *_mem_save_rids_1;
 
9557
        if (flags & NDR_IN) {
 
9558
                ZERO_STRUCT(r->out);
 
9559
 
 
9560
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9561
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9562
                }
 
9563
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9564
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9565
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9566
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9567
                NDR_PULL_ALLOC(ndr, r->out.rids);
 
9568
                ZERO_STRUCTP(r->out.rids);
 
9569
        }
 
9570
        if (flags & NDR_OUT) {
 
9571
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9572
                        NDR_PULL_ALLOC(ndr, r->out.rids);
 
9573
                }
 
9574
                _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9575
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
 
9576
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));
 
9577
                if (_ptr_rids) {
 
9578
                        NDR_PULL_ALLOC(ndr, *r->out.rids);
 
9579
                } else {
 
9580
                        *r->out.rids = NULL;
 
9581
                }
 
9582
                if (*r->out.rids) {
 
9583
                        _mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
9584
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);
 
9585
                        NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));
 
9586
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);
 
9587
                }
 
9588
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
 
9589
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9590
        }
 
9591
        return NDR_ERR_SUCCESS;
 
9592
}
 
9593
 
 
9594
_PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)
 
9595
{
 
9596
        ndr_print_struct(ndr, name, "samr_GetGroupsForUser");
 
9597
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9598
        ndr->depth++;
 
9599
        if (flags & NDR_SET_VALUES) {
 
9600
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9601
        }
 
9602
        if (flags & NDR_IN) {
 
9603
                ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");
 
9604
                ndr->depth++;
 
9605
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9606
                ndr->depth++;
 
9607
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9608
                ndr->depth--;
 
9609
                ndr->depth--;
 
9610
        }
 
9611
        if (flags & NDR_OUT) {
 
9612
                ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");
 
9613
                ndr->depth++;
 
9614
                ndr_print_ptr(ndr, "rids", r->out.rids);
 
9615
                ndr->depth++;
 
9616
                ndr_print_ptr(ndr, "rids", *r->out.rids);
 
9617
                ndr->depth++;
 
9618
                if (*r->out.rids) {
 
9619
                        ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);
 
9620
                }
 
9621
                ndr->depth--;
 
9622
                ndr->depth--;
 
9623
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9624
                ndr->depth--;
 
9625
        }
 
9626
        ndr->depth--;
 
9627
}
 
9628
 
 
9629
static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)
 
9630
{
 
9631
        if (flags & NDR_IN) {
 
9632
                if (r->in.domain_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.domain_handle));
 
9636
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
9637
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
 
9638
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
 
9639
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
 
9640
        }
 
9641
        if (flags & NDR_OUT) {
 
9642
                if (r->out.total_size == NULL) {
 
9643
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9644
                }
 
9645
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
 
9646
                if (r->out.returned_size == NULL) {
 
9647
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9648
                }
 
9649
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
 
9650
                if (r->out.info == NULL) {
 
9651
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9652
                }
 
9653
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 
9654
                NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
9655
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9656
        }
 
9657
        return NDR_ERR_SUCCESS;
 
9658
}
 
9659
 
 
9660
static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)
 
9661
{
 
9662
        TALLOC_CTX *_mem_save_domain_handle_0;
 
9663
        TALLOC_CTX *_mem_save_total_size_0;
 
9664
        TALLOC_CTX *_mem_save_returned_size_0;
 
9665
        TALLOC_CTX *_mem_save_info_0;
 
9666
        if (flags & NDR_IN) {
 
9667
                ZERO_STRUCT(r->out);
 
9668
 
 
9669
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9670
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
9671
                }
 
9672
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9673
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9674
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9675
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9676
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
9677
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
 
9678
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
 
9679
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
 
9680
                NDR_PULL_ALLOC(ndr, r->out.total_size);
 
9681
                ZERO_STRUCTP(r->out.total_size);
 
9682
                NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
9683
                ZERO_STRUCTP(r->out.returned_size);
 
9684
                NDR_PULL_ALLOC(ndr, r->out.info);
 
9685
                ZERO_STRUCTP(r->out.info);
 
9686
        }
 
9687
        if (flags & NDR_OUT) {
 
9688
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9689
                        NDR_PULL_ALLOC(ndr, r->out.total_size);
 
9690
                }
 
9691
                _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9692
                NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
 
9693
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
 
9694
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
 
9695
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9696
                        NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
9697
                }
 
9698
                _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9699
                NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
 
9700
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
 
9701
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
 
9702
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9703
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
9704
                }
 
9705
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9706
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
9707
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 
9708
                NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
9709
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
9710
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9711
        }
 
9712
        return NDR_ERR_SUCCESS;
 
9713
}
 
9714
 
 
9715
_PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)
 
9716
{
 
9717
        ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");
 
9718
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9719
        ndr->depth++;
 
9720
        if (flags & NDR_SET_VALUES) {
 
9721
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9722
        }
 
9723
        if (flags & NDR_IN) {
 
9724
                ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");
 
9725
                ndr->depth++;
 
9726
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9727
                ndr->depth++;
 
9728
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9729
                ndr->depth--;
 
9730
                ndr_print_uint16(ndr, "level", r->in.level);
 
9731
                ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
 
9732
                ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
 
9733
                ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
 
9734
                ndr->depth--;
 
9735
        }
 
9736
        if (flags & NDR_OUT) {
 
9737
                ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");
 
9738
                ndr->depth++;
 
9739
                ndr_print_ptr(ndr, "total_size", r->out.total_size);
 
9740
                ndr->depth++;
 
9741
                ndr_print_uint32(ndr, "total_size", *r->out.total_size);
 
9742
                ndr->depth--;
 
9743
                ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
 
9744
                ndr->depth++;
 
9745
                ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
 
9746
                ndr->depth--;
 
9747
                ndr_print_ptr(ndr, "info", r->out.info);
 
9748
                ndr->depth++;
 
9749
                ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 
9750
                ndr_print_samr_DispInfo(ndr, "info", r->out.info);
 
9751
                ndr->depth--;
 
9752
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9753
                ndr->depth--;
 
9754
        }
 
9755
        ndr->depth--;
 
9756
}
 
9757
 
 
9758
static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)
 
9759
{
 
9760
        if (flags & NDR_IN) {
 
9761
                if (r->in.domain_handle == NULL) {
 
9762
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9763
                }
 
9764
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9765
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
9766
                if (r->in.name == NULL) {
 
9767
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9768
                }
 
9769
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
9770
        }
 
9771
        if (flags & NDR_OUT) {
 
9772
                if (r->out.idx == NULL) {
 
9773
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9774
                }
 
9775
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
 
9776
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9777
        }
 
9778
        return NDR_ERR_SUCCESS;
 
9779
}
 
9780
 
 
9781
static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)
 
9782
{
 
9783
        TALLOC_CTX *_mem_save_domain_handle_0;
 
9784
        TALLOC_CTX *_mem_save_name_0;
 
9785
        TALLOC_CTX *_mem_save_idx_0;
 
9786
        if (flags & NDR_IN) {
 
9787
                ZERO_STRUCT(r->out);
 
9788
 
 
9789
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9790
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
9791
                }
 
9792
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9793
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9794
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9795
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9796
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
9797
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9798
                        NDR_PULL_ALLOC(ndr, r->in.name);
 
9799
                }
 
9800
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9801
                NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
 
9802
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
9803
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
 
9804
                NDR_PULL_ALLOC(ndr, r->out.idx);
 
9805
                ZERO_STRUCTP(r->out.idx);
 
9806
        }
 
9807
        if (flags & NDR_OUT) {
 
9808
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9809
                        NDR_PULL_ALLOC(ndr, r->out.idx);
 
9810
                }
 
9811
                _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9812
                NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
 
9813
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
 
9814
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
 
9815
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9816
        }
 
9817
        return NDR_ERR_SUCCESS;
 
9818
}
 
9819
 
 
9820
_PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)
 
9821
{
 
9822
        ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");
 
9823
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9824
        ndr->depth++;
 
9825
        if (flags & NDR_SET_VALUES) {
 
9826
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9827
        }
 
9828
        if (flags & NDR_IN) {
 
9829
                ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");
 
9830
                ndr->depth++;
 
9831
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9832
                ndr->depth++;
 
9833
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9834
                ndr->depth--;
 
9835
                ndr_print_uint16(ndr, "level", r->in.level);
 
9836
                ndr_print_ptr(ndr, "name", r->in.name);
 
9837
                ndr->depth++;
 
9838
                ndr_print_lsa_String(ndr, "name", r->in.name);
 
9839
                ndr->depth--;
 
9840
                ndr->depth--;
 
9841
        }
 
9842
        if (flags & NDR_OUT) {
 
9843
                ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");
 
9844
                ndr->depth++;
 
9845
                ndr_print_ptr(ndr, "idx", r->out.idx);
 
9846
                ndr->depth++;
 
9847
                ndr_print_uint32(ndr, "idx", *r->out.idx);
 
9848
                ndr->depth--;
 
9849
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9850
                ndr->depth--;
 
9851
        }
 
9852
        ndr->depth--;
 
9853
}
 
9854
 
 
9855
static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)
 
9856
{
 
9857
        if (flags & NDR_IN) {
 
9858
                if (r->in.domain_handle == NULL) {
 
9859
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9860
                }
 
9861
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9862
        }
 
9863
        if (flags & NDR_OUT) {
 
9864
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9865
        }
 
9866
        return NDR_ERR_SUCCESS;
 
9867
}
 
9868
 
 
9869
static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)
 
9870
{
 
9871
        TALLOC_CTX *_mem_save_domain_handle_0;
 
9872
        if (flags & NDR_IN) {
 
9873
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9874
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
9875
                }
 
9876
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9877
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
9878
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
9879
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9880
        }
 
9881
        if (flags & NDR_OUT) {
 
9882
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9883
        }
 
9884
        return NDR_ERR_SUCCESS;
 
9885
}
 
9886
 
 
9887
_PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)
 
9888
{
 
9889
        ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");
 
9890
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9891
        ndr->depth++;
 
9892
        if (flags & NDR_SET_VALUES) {
 
9893
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9894
        }
 
9895
        if (flags & NDR_IN) {
 
9896
                ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");
 
9897
                ndr->depth++;
 
9898
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
9899
                ndr->depth++;
 
9900
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
9901
                ndr->depth--;
 
9902
                ndr->depth--;
 
9903
        }
 
9904
        if (flags & NDR_OUT) {
 
9905
                ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");
 
9906
                ndr->depth++;
 
9907
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9908
                ndr->depth--;
 
9909
        }
 
9910
        ndr->depth--;
 
9911
}
 
9912
 
 
9913
static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)
 
9914
{
 
9915
        if (flags & NDR_IN) {
 
9916
                if (r->in.user_handle == NULL) {
 
9917
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9918
                }
 
9919
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9920
        }
 
9921
        if (flags & NDR_OUT) {
 
9922
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9923
        }
 
9924
        return NDR_ERR_SUCCESS;
 
9925
}
 
9926
 
 
9927
static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)
 
9928
{
 
9929
        TALLOC_CTX *_mem_save_user_handle_0;
 
9930
        if (flags & NDR_IN) {
 
9931
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9932
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9933
                }
 
9934
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
9935
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
9936
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9937
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
9938
        }
 
9939
        if (flags & NDR_OUT) {
 
9940
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
9941
        }
 
9942
        return NDR_ERR_SUCCESS;
 
9943
}
 
9944
 
 
9945
_PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)
 
9946
{
 
9947
        ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");
 
9948
        if (r == NULL) { ndr_print_null(ndr); return; }
 
9949
        ndr->depth++;
 
9950
        if (flags & NDR_SET_VALUES) {
 
9951
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
9952
        }
 
9953
        if (flags & NDR_IN) {
 
9954
                ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");
 
9955
                ndr->depth++;
 
9956
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
9957
                ndr->depth++;
 
9958
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
9959
                ndr->depth--;
 
9960
                ndr->depth--;
 
9961
        }
 
9962
        if (flags & NDR_OUT) {
 
9963
                ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");
 
9964
                ndr->depth++;
 
9965
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
9966
                ndr->depth--;
 
9967
        }
 
9968
        ndr->depth--;
 
9969
}
 
9970
 
 
9971
_PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)
 
9972
{
 
9973
        if (flags & NDR_IN) {
 
9974
                if (r->in.user_handle == NULL) {
 
9975
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9976
                }
 
9977
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
9978
        }
 
9979
        if (flags & NDR_OUT) {
 
9980
                if (r->out.info == NULL) {
 
9981
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
9982
                }
 
9983
                NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
 
9984
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
9985
        }
 
9986
        return NDR_ERR_SUCCESS;
 
9987
}
 
9988
 
 
9989
_PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)
 
9990
{
 
9991
        TALLOC_CTX *_mem_save_user_handle_0;
 
9992
        TALLOC_CTX *_mem_save_info_0;
 
9993
        if (flags & NDR_IN) {
 
9994
                ZERO_STRUCT(r->out);
 
9995
 
 
9996
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
9997
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
9998
                }
 
9999
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10000
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
10001
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
10002
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10003
                NDR_PULL_ALLOC(ndr, r->out.info);
 
10004
                ZERO_STRUCTP(r->out.info);
 
10005
        }
 
10006
        if (flags & NDR_OUT) {
 
10007
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10008
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
10009
                }
 
10010
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10011
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
10012
                NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
 
10013
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
10014
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10015
        }
 
10016
        return NDR_ERR_SUCCESS;
 
10017
}
 
10018
 
 
10019
_PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)
 
10020
{
 
10021
        ndr_print_struct(ndr, name, "samr_GetUserPwInfo");
 
10022
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10023
        ndr->depth++;
 
10024
        if (flags & NDR_SET_VALUES) {
 
10025
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10026
        }
 
10027
        if (flags & NDR_IN) {
 
10028
                ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");
 
10029
                ndr->depth++;
 
10030
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
10031
                ndr->depth++;
 
10032
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
10033
                ndr->depth--;
 
10034
                ndr->depth--;
 
10035
        }
 
10036
        if (flags & NDR_OUT) {
 
10037
                ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");
 
10038
                ndr->depth++;
 
10039
                ndr_print_ptr(ndr, "info", r->out.info);
 
10040
                ndr->depth++;
 
10041
                ndr_print_samr_PwInfo(ndr, "info", r->out.info);
 
10042
                ndr->depth--;
 
10043
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10044
                ndr->depth--;
 
10045
        }
 
10046
        ndr->depth--;
 
10047
}
 
10048
 
 
10049
static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
 
10050
{
 
10051
        if (flags & NDR_IN) {
 
10052
                if (r->in.domain_handle == NULL) {
 
10053
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10054
                }
 
10055
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10056
                if (r->in.sid == NULL) {
 
10057
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10058
                }
 
10059
                NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
10060
        }
 
10061
        if (flags & NDR_OUT) {
 
10062
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10063
        }
 
10064
        return NDR_ERR_SUCCESS;
 
10065
}
 
10066
 
 
10067
static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)
 
10068
{
 
10069
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10070
        TALLOC_CTX *_mem_save_sid_0;
 
10071
        if (flags & NDR_IN) {
 
10072
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10073
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10074
                }
 
10075
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10076
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10077
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10078
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10079
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10080
                        NDR_PULL_ALLOC(ndr, r->in.sid);
 
10081
                }
 
10082
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10083
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
 
10084
                NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
 
10085
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
10086
        }
 
10087
        if (flags & NDR_OUT) {
 
10088
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10089
        }
 
10090
        return NDR_ERR_SUCCESS;
 
10091
}
 
10092
 
 
10093
_PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)
 
10094
{
 
10095
        ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");
 
10096
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10097
        ndr->depth++;
 
10098
        if (flags & NDR_SET_VALUES) {
 
10099
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10100
        }
 
10101
        if (flags & NDR_IN) {
 
10102
                ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");
 
10103
                ndr->depth++;
 
10104
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10105
                ndr->depth++;
 
10106
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10107
                ndr->depth--;
 
10108
                ndr_print_ptr(ndr, "sid", r->in.sid);
 
10109
                ndr->depth++;
 
10110
                ndr_print_dom_sid2(ndr, "sid", r->in.sid);
 
10111
                ndr->depth--;
 
10112
                ndr->depth--;
 
10113
        }
 
10114
        if (flags & NDR_OUT) {
 
10115
                ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");
 
10116
                ndr->depth++;
 
10117
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10118
                ndr->depth--;
 
10119
        }
 
10120
        ndr->depth--;
 
10121
}
 
10122
 
 
10123
static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)
 
10124
{
 
10125
        if (flags & NDR_IN) {
 
10126
                if (r->in.domain_handle == NULL) {
 
10127
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10128
                }
 
10129
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10130
                NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));
 
10131
        }
 
10132
        if (flags & NDR_OUT) {
 
10133
                if (r->out.info == NULL) {
 
10134
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10135
                }
 
10136
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
10137
                if (*r->out.info) {
 
10138
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
10139
                        NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
10140
                }
 
10141
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10142
        }
 
10143
        return NDR_ERR_SUCCESS;
 
10144
}
 
10145
 
 
10146
static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)
 
10147
{
 
10148
        uint32_t _ptr_info;
 
10149
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10150
        TALLOC_CTX *_mem_save_info_0;
 
10151
        TALLOC_CTX *_mem_save_info_1;
 
10152
        if (flags & NDR_IN) {
 
10153
                ZERO_STRUCT(r->out);
 
10154
 
 
10155
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10156
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10157
                }
 
10158
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10159
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10160
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10161
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10162
                NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));
 
10163
                NDR_PULL_ALLOC(ndr, r->out.info);
 
10164
                ZERO_STRUCTP(r->out.info);
 
10165
        }
 
10166
        if (flags & NDR_OUT) {
 
10167
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10168
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
10169
                }
 
10170
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10171
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
10172
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
10173
                if (_ptr_info) {
 
10174
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
10175
                } else {
 
10176
                        *r->out.info = NULL;
 
10177
                }
 
10178
                if (*r->out.info) {
 
10179
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
10180
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
10181
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
10182
                        NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
10183
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
10184
                }
 
10185
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
10186
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10187
        }
 
10188
        return NDR_ERR_SUCCESS;
 
10189
}
 
10190
 
 
10191
_PUBLIC_ void ndr_print_samr_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)
 
10192
{
 
10193
        ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");
 
10194
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10195
        ndr->depth++;
 
10196
        if (flags & NDR_SET_VALUES) {
 
10197
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10198
        }
 
10199
        if (flags & NDR_IN) {
 
10200
                ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");
 
10201
                ndr->depth++;
 
10202
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10203
                ndr->depth++;
 
10204
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10205
                ndr->depth--;
 
10206
                ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);
 
10207
                ndr->depth--;
 
10208
        }
 
10209
        if (flags & NDR_OUT) {
 
10210
                ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");
 
10211
                ndr->depth++;
 
10212
                ndr_print_ptr(ndr, "info", r->out.info);
 
10213
                ndr->depth++;
 
10214
                ndr_print_ptr(ndr, "info", *r->out.info);
 
10215
                ndr->depth++;
 
10216
                if (*r->out.info) {
 
10217
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
10218
                        ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);
 
10219
                }
 
10220
                ndr->depth--;
 
10221
                ndr->depth--;
 
10222
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10223
                ndr->depth--;
 
10224
        }
 
10225
        ndr->depth--;
 
10226
}
 
10227
 
 
10228
static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)
 
10229
{
 
10230
        if (flags & NDR_IN) {
 
10231
                if (r->in.user_handle == NULL) {
 
10232
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10233
                }
 
10234
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
10235
                NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
 
10236
        }
 
10237
        if (flags & NDR_OUT) {
 
10238
                if (r->out.info == NULL) {
 
10239
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10240
                }
 
10241
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
 
10242
                if (*r->out.info) {
 
10243
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
 
10244
                        NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
10245
                }
 
10246
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10247
        }
 
10248
        return NDR_ERR_SUCCESS;
 
10249
}
 
10250
 
 
10251
static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)
 
10252
{
 
10253
        uint32_t _ptr_info;
 
10254
        TALLOC_CTX *_mem_save_user_handle_0;
 
10255
        TALLOC_CTX *_mem_save_info_0;
 
10256
        TALLOC_CTX *_mem_save_info_1;
 
10257
        if (flags & NDR_IN) {
 
10258
                ZERO_STRUCT(r->out);
 
10259
 
 
10260
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10261
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
10262
                }
 
10263
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10264
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
10265
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
10266
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10267
                NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
 
10268
                NDR_PULL_ALLOC(ndr, r->out.info);
 
10269
                ZERO_STRUCTP(r->out.info);
 
10270
        }
 
10271
        if (flags & NDR_OUT) {
 
10272
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10273
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
10274
                }
 
10275
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10276
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
10277
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 
10278
                if (_ptr_info) {
 
10279
                        NDR_PULL_ALLOC(ndr, *r->out.info);
 
10280
                } else {
 
10281
                        *r->out.info = NULL;
 
10282
                }
 
10283
                if (*r->out.info) {
 
10284
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
10285
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
 
10286
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
 
10287
                        NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
 
10288
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
 
10289
                }
 
10290
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
10291
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10292
        }
 
10293
        return NDR_ERR_SUCCESS;
 
10294
}
 
10295
 
 
10296
_PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)
 
10297
{
 
10298
        ndr_print_struct(ndr, name, "samr_QueryUserInfo2");
 
10299
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10300
        ndr->depth++;
 
10301
        if (flags & NDR_SET_VALUES) {
 
10302
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10303
        }
 
10304
        if (flags & NDR_IN) {
 
10305
                ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");
 
10306
                ndr->depth++;
 
10307
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
10308
                ndr->depth++;
 
10309
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
10310
                ndr->depth--;
 
10311
                ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
 
10312
                ndr->depth--;
 
10313
        }
 
10314
        if (flags & NDR_OUT) {
 
10315
                ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");
 
10316
                ndr->depth++;
 
10317
                ndr_print_ptr(ndr, "info", r->out.info);
 
10318
                ndr->depth++;
 
10319
                ndr_print_ptr(ndr, "info", *r->out.info);
 
10320
                ndr->depth++;
 
10321
                if (*r->out.info) {
 
10322
                        ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
 
10323
                        ndr_print_samr_UserInfo(ndr, "info", *r->out.info);
 
10324
                }
 
10325
                ndr->depth--;
 
10326
                ndr->depth--;
 
10327
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10328
                ndr->depth--;
 
10329
        }
 
10330
        ndr->depth--;
 
10331
}
 
10332
 
 
10333
static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)
 
10334
{
 
10335
        if (flags & NDR_IN) {
 
10336
                if (r->in.domain_handle == NULL) {
 
10337
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10338
                }
 
10339
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10340
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
10341
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
 
10342
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
 
10343
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
 
10344
        }
 
10345
        if (flags & NDR_OUT) {
 
10346
                if (r->out.total_size == NULL) {
 
10347
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10348
                }
 
10349
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
 
10350
                if (r->out.returned_size == NULL) {
 
10351
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10352
                }
 
10353
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
 
10354
                if (r->out.info == NULL) {
 
10355
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10356
                }
 
10357
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 
10358
                NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
10359
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10360
        }
 
10361
        return NDR_ERR_SUCCESS;
 
10362
}
 
10363
 
 
10364
static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)
 
10365
{
 
10366
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10367
        TALLOC_CTX *_mem_save_total_size_0;
 
10368
        TALLOC_CTX *_mem_save_returned_size_0;
 
10369
        TALLOC_CTX *_mem_save_info_0;
 
10370
        if (flags & NDR_IN) {
 
10371
                ZERO_STRUCT(r->out);
 
10372
 
 
10373
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10374
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10375
                }
 
10376
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10377
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10378
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10379
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10380
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
10381
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
 
10382
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
 
10383
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
 
10384
                NDR_PULL_ALLOC(ndr, r->out.total_size);
 
10385
                ZERO_STRUCTP(r->out.total_size);
 
10386
                NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
10387
                ZERO_STRUCTP(r->out.returned_size);
 
10388
                NDR_PULL_ALLOC(ndr, r->out.info);
 
10389
                ZERO_STRUCTP(r->out.info);
 
10390
        }
 
10391
        if (flags & NDR_OUT) {
 
10392
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10393
                        NDR_PULL_ALLOC(ndr, r->out.total_size);
 
10394
                }
 
10395
                _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10396
                NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
 
10397
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
 
10398
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
 
10399
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10400
                        NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
10401
                }
 
10402
                _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10403
                NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
 
10404
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
 
10405
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
 
10406
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10407
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
10408
                }
 
10409
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10410
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
10411
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 
10412
                NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
10413
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
10414
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10415
        }
 
10416
        return NDR_ERR_SUCCESS;
 
10417
}
 
10418
 
 
10419
_PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)
 
10420
{
 
10421
        ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");
 
10422
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10423
        ndr->depth++;
 
10424
        if (flags & NDR_SET_VALUES) {
 
10425
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10426
        }
 
10427
        if (flags & NDR_IN) {
 
10428
                ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");
 
10429
                ndr->depth++;
 
10430
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10431
                ndr->depth++;
 
10432
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10433
                ndr->depth--;
 
10434
                ndr_print_uint16(ndr, "level", r->in.level);
 
10435
                ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
 
10436
                ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
 
10437
                ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
 
10438
                ndr->depth--;
 
10439
        }
 
10440
        if (flags & NDR_OUT) {
 
10441
                ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");
 
10442
                ndr->depth++;
 
10443
                ndr_print_ptr(ndr, "total_size", r->out.total_size);
 
10444
                ndr->depth++;
 
10445
                ndr_print_uint32(ndr, "total_size", *r->out.total_size);
 
10446
                ndr->depth--;
 
10447
                ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
 
10448
                ndr->depth++;
 
10449
                ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
 
10450
                ndr->depth--;
 
10451
                ndr_print_ptr(ndr, "info", r->out.info);
 
10452
                ndr->depth++;
 
10453
                ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 
10454
                ndr_print_samr_DispInfo(ndr, "info", r->out.info);
 
10455
                ndr->depth--;
 
10456
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10457
                ndr->depth--;
 
10458
        }
 
10459
        ndr->depth--;
 
10460
}
 
10461
 
 
10462
static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
 
10463
{
 
10464
        if (flags & NDR_IN) {
 
10465
                if (r->in.domain_handle == NULL) {
 
10466
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10467
                }
 
10468
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10469
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
10470
                if (r->in.name == NULL) {
 
10471
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10472
                }
 
10473
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
10474
        }
 
10475
        if (flags & NDR_OUT) {
 
10476
                if (r->out.idx == NULL) {
 
10477
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10478
                }
 
10479
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));
 
10480
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10481
        }
 
10482
        return NDR_ERR_SUCCESS;
 
10483
}
 
10484
 
 
10485
static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)
 
10486
{
 
10487
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10488
        TALLOC_CTX *_mem_save_name_0;
 
10489
        TALLOC_CTX *_mem_save_idx_0;
 
10490
        if (flags & NDR_IN) {
 
10491
                ZERO_STRUCT(r->out);
 
10492
 
 
10493
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10494
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10495
                }
 
10496
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10497
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10498
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10499
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10500
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
10501
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10502
                        NDR_PULL_ALLOC(ndr, r->in.name);
 
10503
                }
 
10504
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10505
                NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
 
10506
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
10507
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
 
10508
                NDR_PULL_ALLOC(ndr, r->out.idx);
 
10509
                ZERO_STRUCTP(r->out.idx);
 
10510
        }
 
10511
        if (flags & NDR_OUT) {
 
10512
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10513
                        NDR_PULL_ALLOC(ndr, r->out.idx);
 
10514
                }
 
10515
                _mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10516
                NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);
 
10517
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));
 
10518
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);
 
10519
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10520
        }
 
10521
        return NDR_ERR_SUCCESS;
 
10522
}
 
10523
 
 
10524
_PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)
 
10525
{
 
10526
        ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");
 
10527
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10528
        ndr->depth++;
 
10529
        if (flags & NDR_SET_VALUES) {
 
10530
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10531
        }
 
10532
        if (flags & NDR_IN) {
 
10533
                ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");
 
10534
                ndr->depth++;
 
10535
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10536
                ndr->depth++;
 
10537
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10538
                ndr->depth--;
 
10539
                ndr_print_uint16(ndr, "level", r->in.level);
 
10540
                ndr_print_ptr(ndr, "name", r->in.name);
 
10541
                ndr->depth++;
 
10542
                ndr_print_lsa_String(ndr, "name", r->in.name);
 
10543
                ndr->depth--;
 
10544
                ndr->depth--;
 
10545
        }
 
10546
        if (flags & NDR_OUT) {
 
10547
                ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");
 
10548
                ndr->depth++;
 
10549
                ndr_print_ptr(ndr, "idx", r->out.idx);
 
10550
                ndr->depth++;
 
10551
                ndr_print_uint32(ndr, "idx", *r->out.idx);
 
10552
                ndr->depth--;
 
10553
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10554
                ndr->depth--;
 
10555
        }
 
10556
        ndr->depth--;
 
10557
}
 
10558
 
 
10559
static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)
 
10560
{
 
10561
        if (flags & NDR_IN) {
 
10562
                if (r->in.domain_handle == NULL) {
 
10563
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10564
                }
 
10565
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10566
                if (r->in.account_name == NULL) {
 
10567
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10568
                }
 
10569
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
 
10570
                NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));
 
10571
                NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
10572
        }
 
10573
        if (flags & NDR_OUT) {
 
10574
                if (r->out.user_handle == NULL) {
 
10575
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10576
                }
 
10577
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
10578
                if (r->out.access_granted == NULL) {
 
10579
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10580
                }
 
10581
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));
 
10582
                if (r->out.rid == NULL) {
 
10583
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10584
                }
 
10585
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));
 
10586
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10587
        }
 
10588
        return NDR_ERR_SUCCESS;
 
10589
}
 
10590
 
 
10591
static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)
 
10592
{
 
10593
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10594
        TALLOC_CTX *_mem_save_account_name_0;
 
10595
        TALLOC_CTX *_mem_save_user_handle_0;
 
10596
        TALLOC_CTX *_mem_save_access_granted_0;
 
10597
        TALLOC_CTX *_mem_save_rid_0;
 
10598
        if (flags & NDR_IN) {
 
10599
                ZERO_STRUCT(r->out);
 
10600
 
 
10601
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10602
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10603
                }
 
10604
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10605
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10606
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10607
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10608
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10609
                        NDR_PULL_ALLOC(ndr, r->in.account_name);
 
10610
                }
 
10611
                _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10612
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
 
10613
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
 
10614
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
 
10615
                NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));
 
10616
                NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
10617
                NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
10618
                ZERO_STRUCTP(r->out.user_handle);
 
10619
                NDR_PULL_ALLOC(ndr, r->out.access_granted);
 
10620
                ZERO_STRUCTP(r->out.access_granted);
 
10621
                NDR_PULL_ALLOC(ndr, r->out.rid);
 
10622
                ZERO_STRUCTP(r->out.rid);
 
10623
        }
 
10624
        if (flags & NDR_OUT) {
 
10625
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10626
                        NDR_PULL_ALLOC(ndr, r->out.user_handle);
 
10627
                }
 
10628
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10629
                NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
10630
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));
 
10631
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10632
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10633
                        NDR_PULL_ALLOC(ndr, r->out.access_granted);
 
10634
                }
 
10635
                _mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10636
                NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);
 
10637
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));
 
10638
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);
 
10639
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10640
                        NDR_PULL_ALLOC(ndr, r->out.rid);
 
10641
                }
 
10642
                _mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10643
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);
 
10644
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));
 
10645
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);
 
10646
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10647
        }
 
10648
        return NDR_ERR_SUCCESS;
 
10649
}
 
10650
 
 
10651
_PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)
 
10652
{
 
10653
        ndr_print_struct(ndr, name, "samr_CreateUser2");
 
10654
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10655
        ndr->depth++;
 
10656
        if (flags & NDR_SET_VALUES) {
 
10657
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10658
        }
 
10659
        if (flags & NDR_IN) {
 
10660
                ndr_print_struct(ndr, "in", "samr_CreateUser2");
 
10661
                ndr->depth++;
 
10662
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10663
                ndr->depth++;
 
10664
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10665
                ndr->depth--;
 
10666
                ndr_print_ptr(ndr, "account_name", r->in.account_name);
 
10667
                ndr->depth++;
 
10668
                ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
 
10669
                ndr->depth--;
 
10670
                ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);
 
10671
                ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);
 
10672
                ndr->depth--;
 
10673
        }
 
10674
        if (flags & NDR_OUT) {
 
10675
                ndr_print_struct(ndr, "out", "samr_CreateUser2");
 
10676
                ndr->depth++;
 
10677
                ndr_print_ptr(ndr, "user_handle", r->out.user_handle);
 
10678
                ndr->depth++;
 
10679
                ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);
 
10680
                ndr->depth--;
 
10681
                ndr_print_ptr(ndr, "access_granted", r->out.access_granted);
 
10682
                ndr->depth++;
 
10683
                ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);
 
10684
                ndr->depth--;
 
10685
                ndr_print_ptr(ndr, "rid", r->out.rid);
 
10686
                ndr->depth++;
 
10687
                ndr_print_uint32(ndr, "rid", *r->out.rid);
 
10688
                ndr->depth--;
 
10689
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10690
                ndr->depth--;
 
10691
        }
 
10692
        ndr->depth--;
 
10693
}
 
10694
 
 
10695
static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)
 
10696
{
 
10697
        if (flags & NDR_IN) {
 
10698
                if (r->in.domain_handle == NULL) {
 
10699
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10700
                }
 
10701
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10702
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
 
10703
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));
 
10704
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));
 
10705
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
 
10706
        }
 
10707
        if (flags & NDR_OUT) {
 
10708
                if (r->out.total_size == NULL) {
 
10709
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10710
                }
 
10711
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));
 
10712
                if (r->out.returned_size == NULL) {
 
10713
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10714
                }
 
10715
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));
 
10716
                if (r->out.info == NULL) {
 
10717
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10718
                }
 
10719
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 
10720
                NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
10721
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10722
        }
 
10723
        return NDR_ERR_SUCCESS;
 
10724
}
 
10725
 
 
10726
static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)
 
10727
{
 
10728
        TALLOC_CTX *_mem_save_domain_handle_0;
 
10729
        TALLOC_CTX *_mem_save_total_size_0;
 
10730
        TALLOC_CTX *_mem_save_returned_size_0;
 
10731
        TALLOC_CTX *_mem_save_info_0;
 
10732
        if (flags & NDR_IN) {
 
10733
                ZERO_STRUCT(r->out);
 
10734
 
 
10735
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10736
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
10737
                }
 
10738
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10739
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
10740
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
10741
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10742
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
 
10743
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));
 
10744
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));
 
10745
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
 
10746
                NDR_PULL_ALLOC(ndr, r->out.total_size);
 
10747
                ZERO_STRUCTP(r->out.total_size);
 
10748
                NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
10749
                ZERO_STRUCTP(r->out.returned_size);
 
10750
                NDR_PULL_ALLOC(ndr, r->out.info);
 
10751
                ZERO_STRUCTP(r->out.info);
 
10752
        }
 
10753
        if (flags & NDR_OUT) {
 
10754
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10755
                        NDR_PULL_ALLOC(ndr, r->out.total_size);
 
10756
                }
 
10757
                _mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10758
                NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);
 
10759
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));
 
10760
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);
 
10761
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10762
                        NDR_PULL_ALLOC(ndr, r->out.returned_size);
 
10763
                }
 
10764
                _mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10765
                NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);
 
10766
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));
 
10767
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);
 
10768
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10769
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
10770
                }
 
10771
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10772
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
10773
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 
10774
                NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 
10775
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
10776
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10777
        }
 
10778
        return NDR_ERR_SUCCESS;
 
10779
}
 
10780
 
 
10781
_PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)
 
10782
{
 
10783
        ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");
 
10784
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10785
        ndr->depth++;
 
10786
        if (flags & NDR_SET_VALUES) {
 
10787
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10788
        }
 
10789
        if (flags & NDR_IN) {
 
10790
                ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");
 
10791
                ndr->depth++;
 
10792
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
10793
                ndr->depth++;
 
10794
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
10795
                ndr->depth--;
 
10796
                ndr_print_uint16(ndr, "level", r->in.level);
 
10797
                ndr_print_uint32(ndr, "start_idx", r->in.start_idx);
 
10798
                ndr_print_uint32(ndr, "max_entries", r->in.max_entries);
 
10799
                ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
 
10800
                ndr->depth--;
 
10801
        }
 
10802
        if (flags & NDR_OUT) {
 
10803
                ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");
 
10804
                ndr->depth++;
 
10805
                ndr_print_ptr(ndr, "total_size", r->out.total_size);
 
10806
                ndr->depth++;
 
10807
                ndr_print_uint32(ndr, "total_size", *r->out.total_size);
 
10808
                ndr->depth--;
 
10809
                ndr_print_ptr(ndr, "returned_size", r->out.returned_size);
 
10810
                ndr->depth++;
 
10811
                ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);
 
10812
                ndr->depth--;
 
10813
                ndr_print_ptr(ndr, "info", r->out.info);
 
10814
                ndr->depth++;
 
10815
                ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 
10816
                ndr_print_samr_DispInfo(ndr, "info", r->out.info);
 
10817
                ndr->depth--;
 
10818
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10819
                ndr->depth--;
 
10820
        }
 
10821
        ndr->depth--;
 
10822
}
 
10823
 
 
10824
static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)
 
10825
{
 
10826
        if (flags & NDR_IN) {
 
10827
                if (r->in.alias_handle == NULL) {
 
10828
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10829
                }
 
10830
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
10831
                if (r->in.sids == NULL) {
 
10832
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10833
                }
 
10834
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
10835
        }
 
10836
        if (flags & NDR_OUT) {
 
10837
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10838
        }
 
10839
        return NDR_ERR_SUCCESS;
 
10840
}
 
10841
 
 
10842
static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)
 
10843
{
 
10844
        TALLOC_CTX *_mem_save_alias_handle_0;
 
10845
        TALLOC_CTX *_mem_save_sids_0;
 
10846
        if (flags & NDR_IN) {
 
10847
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10848
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
10849
                }
 
10850
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10851
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
10852
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
10853
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10854
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10855
                        NDR_PULL_ALLOC(ndr, r->in.sids);
 
10856
                }
 
10857
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10858
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
 
10859
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
10860
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
 
10861
        }
 
10862
        if (flags & NDR_OUT) {
 
10863
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10864
        }
 
10865
        return NDR_ERR_SUCCESS;
 
10866
}
 
10867
 
 
10868
_PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)
 
10869
{
 
10870
        ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");
 
10871
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10872
        ndr->depth++;
 
10873
        if (flags & NDR_SET_VALUES) {
 
10874
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10875
        }
 
10876
        if (flags & NDR_IN) {
 
10877
                ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");
 
10878
                ndr->depth++;
 
10879
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
10880
                ndr->depth++;
 
10881
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
10882
                ndr->depth--;
 
10883
                ndr_print_ptr(ndr, "sids", r->in.sids);
 
10884
                ndr->depth++;
 
10885
                ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
 
10886
                ndr->depth--;
 
10887
                ndr->depth--;
 
10888
        }
 
10889
        if (flags & NDR_OUT) {
 
10890
                ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");
 
10891
                ndr->depth++;
 
10892
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10893
                ndr->depth--;
 
10894
        }
 
10895
        ndr->depth--;
 
10896
}
 
10897
 
 
10898
static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
 
10899
{
 
10900
        if (flags & NDR_IN) {
 
10901
                if (r->in.alias_handle == NULL) {
 
10902
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10903
                }
 
10904
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
10905
                if (r->in.sids == NULL) {
 
10906
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10907
                }
 
10908
                NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
10909
        }
 
10910
        if (flags & NDR_OUT) {
 
10911
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10912
        }
 
10913
        return NDR_ERR_SUCCESS;
 
10914
}
 
10915
 
 
10916
static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)
 
10917
{
 
10918
        TALLOC_CTX *_mem_save_alias_handle_0;
 
10919
        TALLOC_CTX *_mem_save_sids_0;
 
10920
        if (flags & NDR_IN) {
 
10921
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10922
                        NDR_PULL_ALLOC(ndr, r->in.alias_handle);
 
10923
                }
 
10924
                _mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10925
                NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);
 
10926
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));
 
10927
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
10928
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
10929
                        NDR_PULL_ALLOC(ndr, r->in.sids);
 
10930
                }
 
10931
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
10932
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
 
10933
                NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
 
10934
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
 
10935
        }
 
10936
        if (flags & NDR_OUT) {
 
10937
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
10938
        }
 
10939
        return NDR_ERR_SUCCESS;
 
10940
}
 
10941
 
 
10942
_PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)
 
10943
{
 
10944
        ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");
 
10945
        if (r == NULL) { ndr_print_null(ndr); return; }
 
10946
        ndr->depth++;
 
10947
        if (flags & NDR_SET_VALUES) {
 
10948
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
10949
        }
 
10950
        if (flags & NDR_IN) {
 
10951
                ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");
 
10952
                ndr->depth++;
 
10953
                ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);
 
10954
                ndr->depth++;
 
10955
                ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);
 
10956
                ndr->depth--;
 
10957
                ndr_print_ptr(ndr, "sids", r->in.sids);
 
10958
                ndr->depth++;
 
10959
                ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
 
10960
                ndr->depth--;
 
10961
                ndr->depth--;
 
10962
        }
 
10963
        if (flags & NDR_OUT) {
 
10964
                ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");
 
10965
                ndr->depth++;
 
10966
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
10967
                ndr->depth--;
 
10968
        }
 
10969
        ndr->depth--;
 
10970
}
 
10971
 
 
10972
static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)
 
10973
{
 
10974
        if (flags & NDR_IN) {
 
10975
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
 
10976
                if (r->in.server) {
 
10977
                        NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
10978
                }
 
10979
                if (r->in.account == NULL) {
 
10980
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
10981
                }
 
10982
                NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
10983
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
 
10984
                if (r->in.password) {
 
10985
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
 
10986
                }
 
10987
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
 
10988
                if (r->in.hash) {
 
10989
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
 
10990
                }
 
10991
        }
 
10992
        if (flags & NDR_OUT) {
 
10993
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
10994
        }
 
10995
        return NDR_ERR_SUCCESS;
 
10996
}
 
10997
 
 
10998
static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)
 
10999
{
 
11000
        uint32_t _ptr_server;
 
11001
        uint32_t _ptr_password;
 
11002
        uint32_t _ptr_hash;
 
11003
        TALLOC_CTX *_mem_save_server_0;
 
11004
        TALLOC_CTX *_mem_save_account_0;
 
11005
        TALLOC_CTX *_mem_save_password_0;
 
11006
        TALLOC_CTX *_mem_save_hash_0;
 
11007
        if (flags & NDR_IN) {
 
11008
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
 
11009
                if (_ptr_server) {
 
11010
                        NDR_PULL_ALLOC(ndr, r->in.server);
 
11011
                } else {
 
11012
                        r->in.server = NULL;
 
11013
                }
 
11014
                if (r->in.server) {
 
11015
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11016
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
 
11017
                        NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
11018
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
 
11019
                }
 
11020
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11021
                        NDR_PULL_ALLOC(ndr, r->in.account);
 
11022
                }
 
11023
                _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11024
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
 
11025
                NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
11026
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
 
11027
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
 
11028
                if (_ptr_password) {
 
11029
                        NDR_PULL_ALLOC(ndr, r->in.password);
 
11030
                } else {
 
11031
                        r->in.password = NULL;
 
11032
                }
 
11033
                if (r->in.password) {
 
11034
                        _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11035
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
 
11036
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));
 
11037
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
 
11038
                }
 
11039
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
 
11040
                if (_ptr_hash) {
 
11041
                        NDR_PULL_ALLOC(ndr, r->in.hash);
 
11042
                } else {
 
11043
                        r->in.hash = NULL;
 
11044
                }
 
11045
                if (r->in.hash) {
 
11046
                        _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11047
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
 
11048
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
 
11049
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
 
11050
                }
 
11051
        }
 
11052
        if (flags & NDR_OUT) {
 
11053
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11054
        }
 
11055
        return NDR_ERR_SUCCESS;
 
11056
}
 
11057
 
 
11058
_PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)
 
11059
{
 
11060
        ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");
 
11061
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11062
        ndr->depth++;
 
11063
        if (flags & NDR_SET_VALUES) {
 
11064
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11065
        }
 
11066
        if (flags & NDR_IN) {
 
11067
                ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");
 
11068
                ndr->depth++;
 
11069
                ndr_print_ptr(ndr, "server", r->in.server);
 
11070
                ndr->depth++;
 
11071
                if (r->in.server) {
 
11072
                        ndr_print_lsa_AsciiString(ndr, "server", r->in.server);
 
11073
                }
 
11074
                ndr->depth--;
 
11075
                ndr_print_ptr(ndr, "account", r->in.account);
 
11076
                ndr->depth++;
 
11077
                ndr_print_lsa_AsciiString(ndr, "account", r->in.account);
 
11078
                ndr->depth--;
 
11079
                ndr_print_ptr(ndr, "password", r->in.password);
 
11080
                ndr->depth++;
 
11081
                if (r->in.password) {
 
11082
                        ndr_print_samr_CryptPassword(ndr, "password", r->in.password);
 
11083
                }
 
11084
                ndr->depth--;
 
11085
                ndr_print_ptr(ndr, "hash", r->in.hash);
 
11086
                ndr->depth++;
 
11087
                if (r->in.hash) {
 
11088
                        ndr_print_samr_Password(ndr, "hash", r->in.hash);
 
11089
                }
 
11090
                ndr->depth--;
 
11091
                ndr->depth--;
 
11092
        }
 
11093
        if (flags & NDR_OUT) {
 
11094
                ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");
 
11095
                ndr->depth++;
 
11096
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11097
                ndr->depth--;
 
11098
        }
 
11099
        ndr->depth--;
 
11100
}
 
11101
 
 
11102
static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)
 
11103
{
 
11104
        if (flags & NDR_IN) {
 
11105
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
 
11106
                if (r->in.server) {
 
11107
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
11108
                }
 
11109
                if (r->in.account == NULL) {
 
11110
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11111
                }
 
11112
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
11113
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
 
11114
                if (r->in.nt_password) {
 
11115
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
 
11116
                }
 
11117
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
 
11118
                if (r->in.nt_verifier) {
 
11119
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
 
11120
                }
 
11121
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
 
11122
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
 
11123
                if (r->in.lm_password) {
 
11124
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
 
11125
                }
 
11126
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
 
11127
                if (r->in.lm_verifier) {
 
11128
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
 
11129
                }
 
11130
        }
 
11131
        if (flags & NDR_OUT) {
 
11132
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11133
        }
 
11134
        return NDR_ERR_SUCCESS;
 
11135
}
 
11136
 
 
11137
static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)
 
11138
{
 
11139
        uint32_t _ptr_server;
 
11140
        uint32_t _ptr_nt_password;
 
11141
        uint32_t _ptr_nt_verifier;
 
11142
        uint32_t _ptr_lm_password;
 
11143
        uint32_t _ptr_lm_verifier;
 
11144
        TALLOC_CTX *_mem_save_server_0;
 
11145
        TALLOC_CTX *_mem_save_account_0;
 
11146
        TALLOC_CTX *_mem_save_nt_password_0;
 
11147
        TALLOC_CTX *_mem_save_nt_verifier_0;
 
11148
        TALLOC_CTX *_mem_save_lm_password_0;
 
11149
        TALLOC_CTX *_mem_save_lm_verifier_0;
 
11150
        if (flags & NDR_IN) {
 
11151
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
 
11152
                if (_ptr_server) {
 
11153
                        NDR_PULL_ALLOC(ndr, r->in.server);
 
11154
                } else {
 
11155
                        r->in.server = NULL;
 
11156
                }
 
11157
                if (r->in.server) {
 
11158
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11159
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
 
11160
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
11161
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
 
11162
                }
 
11163
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11164
                        NDR_PULL_ALLOC(ndr, r->in.account);
 
11165
                }
 
11166
                _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11167
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
 
11168
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
11169
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
 
11170
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
 
11171
                if (_ptr_nt_password) {
 
11172
                        NDR_PULL_ALLOC(ndr, r->in.nt_password);
 
11173
                } else {
 
11174
                        r->in.nt_password = NULL;
 
11175
                }
 
11176
                if (r->in.nt_password) {
 
11177
                        _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11178
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
 
11179
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
 
11180
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
 
11181
                }
 
11182
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
 
11183
                if (_ptr_nt_verifier) {
 
11184
                        NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
 
11185
                } else {
 
11186
                        r->in.nt_verifier = NULL;
 
11187
                }
 
11188
                if (r->in.nt_verifier) {
 
11189
                        _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11190
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
 
11191
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
 
11192
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
 
11193
                }
 
11194
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
 
11195
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
 
11196
                if (_ptr_lm_password) {
 
11197
                        NDR_PULL_ALLOC(ndr, r->in.lm_password);
 
11198
                } else {
 
11199
                        r->in.lm_password = NULL;
 
11200
                }
 
11201
                if (r->in.lm_password) {
 
11202
                        _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11203
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
 
11204
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
 
11205
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
 
11206
                }
 
11207
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
 
11208
                if (_ptr_lm_verifier) {
 
11209
                        NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
 
11210
                } else {
 
11211
                        r->in.lm_verifier = NULL;
 
11212
                }
 
11213
                if (r->in.lm_verifier) {
 
11214
                        _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11215
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
 
11216
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
 
11217
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
 
11218
                }
 
11219
        }
 
11220
        if (flags & NDR_OUT) {
 
11221
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11222
        }
 
11223
        return NDR_ERR_SUCCESS;
 
11224
}
 
11225
 
 
11226
_PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)
 
11227
{
 
11228
        ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");
 
11229
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11230
        ndr->depth++;
 
11231
        if (flags & NDR_SET_VALUES) {
 
11232
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11233
        }
 
11234
        if (flags & NDR_IN) {
 
11235
                ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");
 
11236
                ndr->depth++;
 
11237
                ndr_print_ptr(ndr, "server", r->in.server);
 
11238
                ndr->depth++;
 
11239
                if (r->in.server) {
 
11240
                        ndr_print_lsa_String(ndr, "server", r->in.server);
 
11241
                }
 
11242
                ndr->depth--;
 
11243
                ndr_print_ptr(ndr, "account", r->in.account);
 
11244
                ndr->depth++;
 
11245
                ndr_print_lsa_String(ndr, "account", r->in.account);
 
11246
                ndr->depth--;
 
11247
                ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
 
11248
                ndr->depth++;
 
11249
                if (r->in.nt_password) {
 
11250
                        ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
 
11251
                }
 
11252
                ndr->depth--;
 
11253
                ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
 
11254
                ndr->depth++;
 
11255
                if (r->in.nt_verifier) {
 
11256
                        ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
 
11257
                }
 
11258
                ndr->depth--;
 
11259
                ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
 
11260
                ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
 
11261
                ndr->depth++;
 
11262
                if (r->in.lm_password) {
 
11263
                        ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
 
11264
                }
 
11265
                ndr->depth--;
 
11266
                ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
 
11267
                ndr->depth++;
 
11268
                if (r->in.lm_verifier) {
 
11269
                        ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
 
11270
                }
 
11271
                ndr->depth--;
 
11272
                ndr->depth--;
 
11273
        }
 
11274
        if (flags & NDR_OUT) {
 
11275
                ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");
 
11276
                ndr->depth++;
 
11277
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11278
                ndr->depth--;
 
11279
        }
 
11280
        ndr->depth--;
 
11281
}
 
11282
 
 
11283
static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)
 
11284
{
 
11285
        if (flags & NDR_IN) {
 
11286
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));
 
11287
                if (r->in.domain_name) {
 
11288
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
 
11289
                }
 
11290
        }
 
11291
        if (flags & NDR_OUT) {
 
11292
                if (r->out.info == NULL) {
 
11293
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11294
                }
 
11295
                NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
 
11296
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11297
        }
 
11298
        return NDR_ERR_SUCCESS;
 
11299
}
 
11300
 
 
11301
static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)
 
11302
{
 
11303
        uint32_t _ptr_domain_name;
 
11304
        TALLOC_CTX *_mem_save_domain_name_0;
 
11305
        TALLOC_CTX *_mem_save_info_0;
 
11306
        if (flags & NDR_IN) {
 
11307
                ZERO_STRUCT(r->out);
 
11308
 
 
11309
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
 
11310
                if (_ptr_domain_name) {
 
11311
                        NDR_PULL_ALLOC(ndr, r->in.domain_name);
 
11312
                } else {
 
11313
                        r->in.domain_name = NULL;
 
11314
                }
 
11315
                if (r->in.domain_name) {
 
11316
                        _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11317
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);
 
11318
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));
 
11319
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
 
11320
                }
 
11321
                NDR_PULL_ALLOC(ndr, r->out.info);
 
11322
                ZERO_STRUCTP(r->out.info);
 
11323
        }
 
11324
        if (flags & NDR_OUT) {
 
11325
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11326
                        NDR_PULL_ALLOC(ndr, r->out.info);
 
11327
                }
 
11328
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11329
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
 
11330
                NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));
 
11331
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
11332
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11333
        }
 
11334
        return NDR_ERR_SUCCESS;
 
11335
}
 
11336
 
 
11337
_PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)
 
11338
{
 
11339
        ndr_print_struct(ndr, name, "samr_GetDomPwInfo");
 
11340
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11341
        ndr->depth++;
 
11342
        if (flags & NDR_SET_VALUES) {
 
11343
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11344
        }
 
11345
        if (flags & NDR_IN) {
 
11346
                ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");
 
11347
                ndr->depth++;
 
11348
                ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
 
11349
                ndr->depth++;
 
11350
                if (r->in.domain_name) {
 
11351
                        ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);
 
11352
                }
 
11353
                ndr->depth--;
 
11354
                ndr->depth--;
 
11355
        }
 
11356
        if (flags & NDR_OUT) {
 
11357
                ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");
 
11358
                ndr->depth++;
 
11359
                ndr_print_ptr(ndr, "info", r->out.info);
 
11360
                ndr->depth++;
 
11361
                ndr_print_samr_PwInfo(ndr, "info", r->out.info);
 
11362
                ndr->depth--;
 
11363
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11364
                ndr->depth--;
 
11365
        }
 
11366
        ndr->depth--;
 
11367
}
 
11368
 
 
11369
static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)
 
11370
{
 
11371
        if (flags & NDR_IN) {
 
11372
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
11373
                if (r->in.system_name) {
 
11374
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11375
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
11376
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11377
                        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));
 
11378
                }
 
11379
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
11380
        }
 
11381
        if (flags & NDR_OUT) {
 
11382
                if (r->out.connect_handle == NULL) {
 
11383
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11384
                }
 
11385
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11386
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11387
        }
 
11388
        return NDR_ERR_SUCCESS;
 
11389
}
 
11390
 
 
11391
static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)
 
11392
{
 
11393
        uint32_t _ptr_system_name;
 
11394
        TALLOC_CTX *_mem_save_system_name_0;
 
11395
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11396
        if (flags & NDR_IN) {
 
11397
                ZERO_STRUCT(r->out);
 
11398
 
 
11399
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
11400
                if (_ptr_system_name) {
 
11401
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
11402
                } else {
 
11403
                        r->in.system_name = NULL;
 
11404
                }
 
11405
                if (r->in.system_name) {
 
11406
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11407
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
11408
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
 
11409
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
 
11410
                        if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
 
11411
                                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));
 
11412
                        }
 
11413
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
 
11414
                        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));
 
11415
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
11416
                }
 
11417
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
11418
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11419
                ZERO_STRUCTP(r->out.connect_handle);
 
11420
        }
 
11421
        if (flags & NDR_OUT) {
 
11422
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11423
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11424
                }
 
11425
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11426
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11427
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11428
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11429
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11430
        }
 
11431
        return NDR_ERR_SUCCESS;
 
11432
}
 
11433
 
 
11434
_PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)
 
11435
{
 
11436
        ndr_print_struct(ndr, name, "samr_Connect2");
 
11437
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11438
        ndr->depth++;
 
11439
        if (flags & NDR_SET_VALUES) {
 
11440
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11441
        }
 
11442
        if (flags & NDR_IN) {
 
11443
                ndr_print_struct(ndr, "in", "samr_Connect2");
 
11444
                ndr->depth++;
 
11445
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
11446
                ndr->depth++;
 
11447
                if (r->in.system_name) {
 
11448
                        ndr_print_string(ndr, "system_name", r->in.system_name);
 
11449
                }
 
11450
                ndr->depth--;
 
11451
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
11452
                ndr->depth--;
 
11453
        }
 
11454
        if (flags & NDR_OUT) {
 
11455
                ndr_print_struct(ndr, "out", "samr_Connect2");
 
11456
                ndr->depth++;
 
11457
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
11458
                ndr->depth++;
 
11459
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
11460
                ndr->depth--;
 
11461
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11462
                ndr->depth--;
 
11463
        }
 
11464
        ndr->depth--;
 
11465
}
 
11466
 
 
11467
_PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)
 
11468
{
 
11469
        if (flags & NDR_IN) {
 
11470
                if (r->in.user_handle == NULL) {
 
11471
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11472
                }
 
11473
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
11474
                NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));
 
11475
                if (r->in.info == NULL) {
 
11476
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11477
                }
 
11478
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
 
11479
                NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
11480
        }
 
11481
        if (flags & NDR_OUT) {
 
11482
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11483
        }
 
11484
        return NDR_ERR_SUCCESS;
 
11485
}
 
11486
 
 
11487
_PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)
 
11488
{
 
11489
        TALLOC_CTX *_mem_save_user_handle_0;
 
11490
        TALLOC_CTX *_mem_save_info_0;
 
11491
        if (flags & NDR_IN) {
 
11492
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11493
                        NDR_PULL_ALLOC(ndr, r->in.user_handle);
 
11494
                }
 
11495
                _mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11496
                NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);
 
11497
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));
 
11498
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11499
                NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));
 
11500
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11501
                        NDR_PULL_ALLOC(ndr, r->in.info);
 
11502
                }
 
11503
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11504
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
 
11505
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
 
11506
                NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
 
11507
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
 
11508
        }
 
11509
        if (flags & NDR_OUT) {
 
11510
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11511
        }
 
11512
        return NDR_ERR_SUCCESS;
 
11513
}
 
11514
 
 
11515
_PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)
 
11516
{
 
11517
        ndr_print_struct(ndr, name, "samr_SetUserInfo2");
 
11518
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11519
        ndr->depth++;
 
11520
        if (flags & NDR_SET_VALUES) {
 
11521
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11522
        }
 
11523
        if (flags & NDR_IN) {
 
11524
                ndr_print_struct(ndr, "in", "samr_SetUserInfo2");
 
11525
                ndr->depth++;
 
11526
                ndr_print_ptr(ndr, "user_handle", r->in.user_handle);
 
11527
                ndr->depth++;
 
11528
                ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);
 
11529
                ndr->depth--;
 
11530
                ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);
 
11531
                ndr_print_ptr(ndr, "info", r->in.info);
 
11532
                ndr->depth++;
 
11533
                ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
 
11534
                ndr_print_samr_UserInfo(ndr, "info", r->in.info);
 
11535
                ndr->depth--;
 
11536
                ndr->depth--;
 
11537
        }
 
11538
        if (flags & NDR_OUT) {
 
11539
                ndr_print_struct(ndr, "out", "samr_SetUserInfo2");
 
11540
                ndr->depth++;
 
11541
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11542
                ndr->depth--;
 
11543
        }
 
11544
        ndr->depth--;
 
11545
}
 
11546
 
 
11547
static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)
 
11548
{
 
11549
        if (flags & NDR_IN) {
 
11550
                if (r->in.connect_handle == NULL) {
 
11551
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11552
                }
 
11553
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
11554
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
 
11555
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
 
11556
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));
 
11557
        }
 
11558
        if (flags & NDR_OUT) {
 
11559
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11560
        }
 
11561
        return NDR_ERR_SUCCESS;
 
11562
}
 
11563
 
 
11564
static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)
 
11565
{
 
11566
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11567
        if (flags & NDR_IN) {
 
11568
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11569
                        NDR_PULL_ALLOC(ndr, r->in.connect_handle);
 
11570
                }
 
11571
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11572
                NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11573
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));
 
11574
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11575
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
 
11576
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
 
11577
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));
 
11578
        }
 
11579
        if (flags & NDR_OUT) {
 
11580
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11581
        }
 
11582
        return NDR_ERR_SUCCESS;
 
11583
}
 
11584
 
 
11585
_PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)
 
11586
{
 
11587
        ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");
 
11588
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11589
        ndr->depth++;
 
11590
        if (flags & NDR_SET_VALUES) {
 
11591
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11592
        }
 
11593
        if (flags & NDR_IN) {
 
11594
                ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");
 
11595
                ndr->depth++;
 
11596
                ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);
 
11597
                ndr->depth++;
 
11598
                ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);
 
11599
                ndr->depth--;
 
11600
                ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
 
11601
                ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
 
11602
                ndr_print_uint32(ndr, "unknown3", r->in.unknown3);
 
11603
                ndr->depth--;
 
11604
        }
 
11605
        if (flags & NDR_OUT) {
 
11606
                ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");
 
11607
                ndr->depth++;
 
11608
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11609
                ndr->depth--;
 
11610
        }
 
11611
        ndr->depth--;
 
11612
}
 
11613
 
 
11614
static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)
 
11615
{
 
11616
        if (flags & NDR_IN) {
 
11617
                if (r->in.domain_handle == NULL) {
 
11618
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11619
                }
 
11620
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
11621
        }
 
11622
        if (flags & NDR_OUT) {
 
11623
                if (r->out.unknown == NULL) {
 
11624
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11625
                }
 
11626
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));
 
11627
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11628
        }
 
11629
        return NDR_ERR_SUCCESS;
 
11630
}
 
11631
 
 
11632
static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)
 
11633
{
 
11634
        TALLOC_CTX *_mem_save_domain_handle_0;
 
11635
        TALLOC_CTX *_mem_save_unknown_0;
 
11636
        if (flags & NDR_IN) {
 
11637
                ZERO_STRUCT(r->out);
 
11638
 
 
11639
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11640
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
11641
                }
 
11642
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11643
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
11644
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
11645
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11646
                NDR_PULL_ALLOC(ndr, r->out.unknown);
 
11647
                ZERO_STRUCTP(r->out.unknown);
 
11648
        }
 
11649
        if (flags & NDR_OUT) {
 
11650
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11651
                        NDR_PULL_ALLOC(ndr, r->out.unknown);
 
11652
                }
 
11653
                _mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11654
                NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);
 
11655
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));
 
11656
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);
 
11657
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11658
        }
 
11659
        return NDR_ERR_SUCCESS;
 
11660
}
 
11661
 
 
11662
_PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)
 
11663
{
 
11664
        ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");
 
11665
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11666
        ndr->depth++;
 
11667
        if (flags & NDR_SET_VALUES) {
 
11668
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11669
        }
 
11670
        if (flags & NDR_IN) {
 
11671
                ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");
 
11672
                ndr->depth++;
 
11673
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
11674
                ndr->depth++;
 
11675
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
11676
                ndr->depth--;
 
11677
                ndr->depth--;
 
11678
        }
 
11679
        if (flags & NDR_OUT) {
 
11680
                ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");
 
11681
                ndr->depth++;
 
11682
                ndr_print_ptr(ndr, "unknown", r->out.unknown);
 
11683
                ndr->depth++;
 
11684
                ndr_print_uint32(ndr, "unknown", *r->out.unknown);
 
11685
                ndr->depth--;
 
11686
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11687
                ndr->depth--;
 
11688
        }
 
11689
        ndr->depth--;
 
11690
}
 
11691
 
 
11692
static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)
 
11693
{
 
11694
        if (flags & NDR_IN) {
 
11695
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
11696
                if (r->in.system_name) {
 
11697
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11698
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
11699
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11700
                        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));
 
11701
                }
 
11702
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
 
11703
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
11704
        }
 
11705
        if (flags & NDR_OUT) {
 
11706
                if (r->out.connect_handle == NULL) {
 
11707
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11708
                }
 
11709
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11710
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11711
        }
 
11712
        return NDR_ERR_SUCCESS;
 
11713
}
 
11714
 
 
11715
static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)
 
11716
{
 
11717
        uint32_t _ptr_system_name;
 
11718
        TALLOC_CTX *_mem_save_system_name_0;
 
11719
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11720
        if (flags & NDR_IN) {
 
11721
                ZERO_STRUCT(r->out);
 
11722
 
 
11723
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
11724
                if (_ptr_system_name) {
 
11725
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
11726
                } else {
 
11727
                        r->in.system_name = NULL;
 
11728
                }
 
11729
                if (r->in.system_name) {
 
11730
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11731
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
11732
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
 
11733
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
 
11734
                        if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
 
11735
                                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));
 
11736
                        }
 
11737
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
 
11738
                        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));
 
11739
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
11740
                }
 
11741
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
 
11742
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
11743
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11744
                ZERO_STRUCTP(r->out.connect_handle);
 
11745
        }
 
11746
        if (flags & NDR_OUT) {
 
11747
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11748
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11749
                }
 
11750
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11751
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11752
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11753
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11754
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11755
        }
 
11756
        return NDR_ERR_SUCCESS;
 
11757
}
 
11758
 
 
11759
_PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)
 
11760
{
 
11761
        ndr_print_struct(ndr, name, "samr_Connect3");
 
11762
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11763
        ndr->depth++;
 
11764
        if (flags & NDR_SET_VALUES) {
 
11765
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11766
        }
 
11767
        if (flags & NDR_IN) {
 
11768
                ndr_print_struct(ndr, "in", "samr_Connect3");
 
11769
                ndr->depth++;
 
11770
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
11771
                ndr->depth++;
 
11772
                if (r->in.system_name) {
 
11773
                        ndr_print_string(ndr, "system_name", r->in.system_name);
 
11774
                }
 
11775
                ndr->depth--;
 
11776
                ndr_print_uint32(ndr, "unknown", r->in.unknown);
 
11777
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
11778
                ndr->depth--;
 
11779
        }
 
11780
        if (flags & NDR_OUT) {
 
11781
                ndr_print_struct(ndr, "out", "samr_Connect3");
 
11782
                ndr->depth++;
 
11783
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
11784
                ndr->depth++;
 
11785
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
11786
                ndr->depth--;
 
11787
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11788
                ndr->depth--;
 
11789
        }
 
11790
        ndr->depth--;
 
11791
}
 
11792
 
 
11793
static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)
 
11794
{
 
11795
        if (flags & NDR_IN) {
 
11796
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
11797
                if (r->in.system_name) {
 
11798
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11799
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
11800
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
11801
                        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));
 
11802
                }
 
11803
                NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));
 
11804
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
11805
        }
 
11806
        if (flags & NDR_OUT) {
 
11807
                if (r->out.connect_handle == NULL) {
 
11808
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11809
                }
 
11810
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11811
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11812
        }
 
11813
        return NDR_ERR_SUCCESS;
 
11814
}
 
11815
 
 
11816
static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)
 
11817
{
 
11818
        uint32_t _ptr_system_name;
 
11819
        TALLOC_CTX *_mem_save_system_name_0;
 
11820
        TALLOC_CTX *_mem_save_connect_handle_0;
 
11821
        if (flags & NDR_IN) {
 
11822
                ZERO_STRUCT(r->out);
 
11823
 
 
11824
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
11825
                if (_ptr_system_name) {
 
11826
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
11827
                } else {
 
11828
                        r->in.system_name = NULL;
 
11829
                }
 
11830
                if (r->in.system_name) {
 
11831
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11832
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
11833
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
 
11834
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
 
11835
                        if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
 
11836
                                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));
 
11837
                        }
 
11838
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
 
11839
                        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));
 
11840
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
11841
                }
 
11842
                NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));
 
11843
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
11844
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11845
                ZERO_STRUCTP(r->out.connect_handle);
 
11846
        }
 
11847
        if (flags & NDR_OUT) {
 
11848
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11849
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
11850
                }
 
11851
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11852
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
11853
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
11854
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
11855
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
11856
        }
 
11857
        return NDR_ERR_SUCCESS;
 
11858
}
 
11859
 
 
11860
_PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)
 
11861
{
 
11862
        ndr_print_struct(ndr, name, "samr_Connect4");
 
11863
        if (r == NULL) { ndr_print_null(ndr); return; }
 
11864
        ndr->depth++;
 
11865
        if (flags & NDR_SET_VALUES) {
 
11866
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
11867
        }
 
11868
        if (flags & NDR_IN) {
 
11869
                ndr_print_struct(ndr, "in", "samr_Connect4");
 
11870
                ndr->depth++;
 
11871
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
11872
                ndr->depth++;
 
11873
                if (r->in.system_name) {
 
11874
                        ndr_print_string(ndr, "system_name", r->in.system_name);
 
11875
                }
 
11876
                ndr->depth--;
 
11877
                ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);
 
11878
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
11879
                ndr->depth--;
 
11880
        }
 
11881
        if (flags & NDR_OUT) {
 
11882
                ndr_print_struct(ndr, "out", "samr_Connect4");
 
11883
                ndr->depth++;
 
11884
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
11885
                ndr->depth++;
 
11886
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
11887
                ndr->depth--;
 
11888
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
11889
                ndr->depth--;
 
11890
        }
 
11891
        ndr->depth--;
 
11892
}
 
11893
 
 
11894
_PUBLIC_ enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)
 
11895
{
 
11896
        if (flags & NDR_IN) {
 
11897
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
 
11898
                if (r->in.server) {
 
11899
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
11900
                }
 
11901
                if (r->in.account == NULL) {
 
11902
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11903
                }
 
11904
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
11905
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));
 
11906
                if (r->in.nt_password) {
 
11907
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
 
11908
                }
 
11909
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));
 
11910
                if (r->in.nt_verifier) {
 
11911
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
 
11912
                }
 
11913
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));
 
11914
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));
 
11915
                if (r->in.lm_password) {
 
11916
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
 
11917
                }
 
11918
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));
 
11919
                if (r->in.lm_verifier) {
 
11920
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
 
11921
                }
 
11922
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));
 
11923
                if (r->in.password3) {
 
11924
                        NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
 
11925
                }
 
11926
        }
 
11927
        if (flags & NDR_OUT) {
 
11928
                if (r->out.dominfo == NULL) {
 
11929
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11930
                }
 
11931
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));
 
11932
                if (*r->out.dominfo) {
 
11933
                        NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
 
11934
                }
 
11935
                if (r->out.reject == NULL) {
 
11936
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
11937
                }
 
11938
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));
 
11939
                if (*r->out.reject) {
 
11940
                        NDR_CHECK(ndr_push_userPwdChangeFailureInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.reject));
 
11941
                }
 
11942
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
11943
        }
 
11944
        return NDR_ERR_SUCCESS;
 
11945
}
 
11946
 
 
11947
_PUBLIC_ enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)
 
11948
{
 
11949
        uint32_t _ptr_server;
 
11950
        uint32_t _ptr_nt_password;
 
11951
        uint32_t _ptr_nt_verifier;
 
11952
        uint32_t _ptr_lm_password;
 
11953
        uint32_t _ptr_lm_verifier;
 
11954
        uint32_t _ptr_password3;
 
11955
        uint32_t _ptr_dominfo;
 
11956
        uint32_t _ptr_reject;
 
11957
        TALLOC_CTX *_mem_save_server_0;
 
11958
        TALLOC_CTX *_mem_save_account_0;
 
11959
        TALLOC_CTX *_mem_save_nt_password_0;
 
11960
        TALLOC_CTX *_mem_save_nt_verifier_0;
 
11961
        TALLOC_CTX *_mem_save_lm_password_0;
 
11962
        TALLOC_CTX *_mem_save_lm_verifier_0;
 
11963
        TALLOC_CTX *_mem_save_password3_0;
 
11964
        TALLOC_CTX *_mem_save_dominfo_0;
 
11965
        TALLOC_CTX *_mem_save_dominfo_1;
 
11966
        TALLOC_CTX *_mem_save_reject_0;
 
11967
        TALLOC_CTX *_mem_save_reject_1;
 
11968
        if (flags & NDR_IN) {
 
11969
                ZERO_STRUCT(r->out);
 
11970
 
 
11971
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
 
11972
                if (_ptr_server) {
 
11973
                        NDR_PULL_ALLOC(ndr, r->in.server);
 
11974
                } else {
 
11975
                        r->in.server = NULL;
 
11976
                }
 
11977
                if (r->in.server) {
 
11978
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11979
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
 
11980
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));
 
11981
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
 
11982
                }
 
11983
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
11984
                        NDR_PULL_ALLOC(ndr, r->in.account);
 
11985
                }
 
11986
                _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11987
                NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);
 
11988
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));
 
11989
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);
 
11990
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));
 
11991
                if (_ptr_nt_password) {
 
11992
                        NDR_PULL_ALLOC(ndr, r->in.nt_password);
 
11993
                } else {
 
11994
                        r->in.nt_password = NULL;
 
11995
                }
 
11996
                if (r->in.nt_password) {
 
11997
                        _mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
11998
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);
 
11999
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));
 
12000
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);
 
12001
                }
 
12002
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));
 
12003
                if (_ptr_nt_verifier) {
 
12004
                        NDR_PULL_ALLOC(ndr, r->in.nt_verifier);
 
12005
                } else {
 
12006
                        r->in.nt_verifier = NULL;
 
12007
                }
 
12008
                if (r->in.nt_verifier) {
 
12009
                        _mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12010
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);
 
12011
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));
 
12012
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);
 
12013
                }
 
12014
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));
 
12015
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));
 
12016
                if (_ptr_lm_password) {
 
12017
                        NDR_PULL_ALLOC(ndr, r->in.lm_password);
 
12018
                } else {
 
12019
                        r->in.lm_password = NULL;
 
12020
                }
 
12021
                if (r->in.lm_password) {
 
12022
                        _mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12023
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);
 
12024
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));
 
12025
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);
 
12026
                }
 
12027
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));
 
12028
                if (_ptr_lm_verifier) {
 
12029
                        NDR_PULL_ALLOC(ndr, r->in.lm_verifier);
 
12030
                } else {
 
12031
                        r->in.lm_verifier = NULL;
 
12032
                }
 
12033
                if (r->in.lm_verifier) {
 
12034
                        _mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12035
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);
 
12036
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));
 
12037
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);
 
12038
                }
 
12039
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));
 
12040
                if (_ptr_password3) {
 
12041
                        NDR_PULL_ALLOC(ndr, r->in.password3);
 
12042
                } else {
 
12043
                        r->in.password3 = NULL;
 
12044
                }
 
12045
                if (r->in.password3) {
 
12046
                        _mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12047
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);
 
12048
                        NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));
 
12049
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);
 
12050
                }
 
12051
                NDR_PULL_ALLOC(ndr, r->out.dominfo);
 
12052
                ZERO_STRUCTP(r->out.dominfo);
 
12053
                NDR_PULL_ALLOC(ndr, r->out.reject);
 
12054
                ZERO_STRUCTP(r->out.reject);
 
12055
        }
 
12056
        if (flags & NDR_OUT) {
 
12057
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12058
                        NDR_PULL_ALLOC(ndr, r->out.dominfo);
 
12059
                }
 
12060
                _mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12061
                NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);
 
12062
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));
 
12063
                if (_ptr_dominfo) {
 
12064
                        NDR_PULL_ALLOC(ndr, *r->out.dominfo);
 
12065
                } else {
 
12066
                        *r->out.dominfo = NULL;
 
12067
                }
 
12068
                if (*r->out.dominfo) {
 
12069
                        _mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
12070
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);
 
12071
                        NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));
 
12072
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);
 
12073
                }
 
12074
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);
 
12075
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12076
                        NDR_PULL_ALLOC(ndr, r->out.reject);
 
12077
                }
 
12078
                _mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12079
                NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);
 
12080
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));
 
12081
                if (_ptr_reject) {
 
12082
                        NDR_PULL_ALLOC(ndr, *r->out.reject);
 
12083
                } else {
 
12084
                        *r->out.reject = NULL;
 
12085
                }
 
12086
                if (*r->out.reject) {
 
12087
                        _mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
12088
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);
 
12089
                        NDR_CHECK(ndr_pull_userPwdChangeFailureInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.reject));
 
12090
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);
 
12091
                }
 
12092
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);
 
12093
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
12094
        }
 
12095
        return NDR_ERR_SUCCESS;
 
12096
}
 
12097
 
 
12098
_PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)
 
12099
{
 
12100
        ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");
 
12101
        if (r == NULL) { ndr_print_null(ndr); return; }
 
12102
        ndr->depth++;
 
12103
        if (flags & NDR_SET_VALUES) {
 
12104
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
12105
        }
 
12106
        if (flags & NDR_IN) {
 
12107
                ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");
 
12108
                ndr->depth++;
 
12109
                ndr_print_ptr(ndr, "server", r->in.server);
 
12110
                ndr->depth++;
 
12111
                if (r->in.server) {
 
12112
                        ndr_print_lsa_String(ndr, "server", r->in.server);
 
12113
                }
 
12114
                ndr->depth--;
 
12115
                ndr_print_ptr(ndr, "account", r->in.account);
 
12116
                ndr->depth++;
 
12117
                ndr_print_lsa_String(ndr, "account", r->in.account);
 
12118
                ndr->depth--;
 
12119
                ndr_print_ptr(ndr, "nt_password", r->in.nt_password);
 
12120
                ndr->depth++;
 
12121
                if (r->in.nt_password) {
 
12122
                        ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);
 
12123
                }
 
12124
                ndr->depth--;
 
12125
                ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);
 
12126
                ndr->depth++;
 
12127
                if (r->in.nt_verifier) {
 
12128
                        ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);
 
12129
                }
 
12130
                ndr->depth--;
 
12131
                ndr_print_uint8(ndr, "lm_change", r->in.lm_change);
 
12132
                ndr_print_ptr(ndr, "lm_password", r->in.lm_password);
 
12133
                ndr->depth++;
 
12134
                if (r->in.lm_password) {
 
12135
                        ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);
 
12136
                }
 
12137
                ndr->depth--;
 
12138
                ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);
 
12139
                ndr->depth++;
 
12140
                if (r->in.lm_verifier) {
 
12141
                        ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);
 
12142
                }
 
12143
                ndr->depth--;
 
12144
                ndr_print_ptr(ndr, "password3", r->in.password3);
 
12145
                ndr->depth++;
 
12146
                if (r->in.password3) {
 
12147
                        ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);
 
12148
                }
 
12149
                ndr->depth--;
 
12150
                ndr->depth--;
 
12151
        }
 
12152
        if (flags & NDR_OUT) {
 
12153
                ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");
 
12154
                ndr->depth++;
 
12155
                ndr_print_ptr(ndr, "dominfo", r->out.dominfo);
 
12156
                ndr->depth++;
 
12157
                ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);
 
12158
                ndr->depth++;
 
12159
                if (*r->out.dominfo) {
 
12160
                        ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);
 
12161
                }
 
12162
                ndr->depth--;
 
12163
                ndr->depth--;
 
12164
                ndr_print_ptr(ndr, "reject", r->out.reject);
 
12165
                ndr->depth++;
 
12166
                ndr_print_ptr(ndr, "reject", *r->out.reject);
 
12167
                ndr->depth++;
 
12168
                if (*r->out.reject) {
 
12169
                        ndr_print_userPwdChangeFailureInformation(ndr, "reject", *r->out.reject);
 
12170
                }
 
12171
                ndr->depth--;
 
12172
                ndr->depth--;
 
12173
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
12174
                ndr->depth--;
 
12175
        }
 
12176
        ndr->depth--;
 
12177
}
 
12178
 
 
12179
_PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)
 
12180
{
 
12181
        if (flags & NDR_IN) {
 
12182
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
 
12183
                if (r->in.system_name) {
 
12184
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
12185
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
12186
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
 
12187
                        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));
 
12188
                }
 
12189
                NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
 
12190
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));
 
12191
                if (r->in.info_in == NULL) {
 
12192
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12193
                }
 
12194
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));
 
12195
                NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
 
12196
        }
 
12197
        if (flags & NDR_OUT) {
 
12198
                if (r->out.level_out == NULL) {
 
12199
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12200
                }
 
12201
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
 
12202
                if (r->out.info_out == NULL) {
 
12203
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12204
                }
 
12205
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
 
12206
                NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
 
12207
                if (r->out.connect_handle == NULL) {
 
12208
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12209
                }
 
12210
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
12211
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
12212
        }
 
12213
        return NDR_ERR_SUCCESS;
 
12214
}
 
12215
 
 
12216
_PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)
 
12217
{
 
12218
        uint32_t _ptr_system_name;
 
12219
        TALLOC_CTX *_mem_save_system_name_0;
 
12220
        TALLOC_CTX *_mem_save_info_in_0;
 
12221
        TALLOC_CTX *_mem_save_level_out_0;
 
12222
        TALLOC_CTX *_mem_save_info_out_0;
 
12223
        TALLOC_CTX *_mem_save_connect_handle_0;
 
12224
        if (flags & NDR_IN) {
 
12225
                ZERO_STRUCT(r->out);
 
12226
 
 
12227
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
 
12228
                if (_ptr_system_name) {
 
12229
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
 
12230
                } else {
 
12231
                        r->in.system_name = NULL;
 
12232
                }
 
12233
                if (r->in.system_name) {
 
12234
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12235
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
 
12236
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
 
12237
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
 
12238
                        if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
 
12239
                                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));
 
12240
                        }
 
12241
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
 
12242
                        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));
 
12243
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
 
12244
                }
 
12245
                NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
 
12246
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));
 
12247
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12248
                        NDR_PULL_ALLOC(ndr, r->in.info_in);
 
12249
                }
 
12250
                _mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12251
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);
 
12252
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));
 
12253
                NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));
 
12254
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);
 
12255
                NDR_PULL_ALLOC(ndr, r->out.level_out);
 
12256
                ZERO_STRUCTP(r->out.level_out);
 
12257
                NDR_PULL_ALLOC(ndr, r->out.info_out);
 
12258
                ZERO_STRUCTP(r->out.info_out);
 
12259
                NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
12260
                ZERO_STRUCTP(r->out.connect_handle);
 
12261
        }
 
12262
        if (flags & NDR_OUT) {
 
12263
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12264
                        NDR_PULL_ALLOC(ndr, r->out.level_out);
 
12265
                }
 
12266
                _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12267
                NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
 
12268
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
 
12269
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
 
12270
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12271
                        NDR_PULL_ALLOC(ndr, r->out.info_out);
 
12272
                }
 
12273
                _mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12274
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);
 
12275
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));
 
12276
                NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));
 
12277
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);
 
12278
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12279
                        NDR_PULL_ALLOC(ndr, r->out.connect_handle);
 
12280
                }
 
12281
                _mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12282
                NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);
 
12283
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));
 
12284
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
12285
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
12286
        }
 
12287
        return NDR_ERR_SUCCESS;
 
12288
}
 
12289
 
 
12290
_PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)
 
12291
{
 
12292
        ndr_print_struct(ndr, name, "samr_Connect5");
 
12293
        if (r == NULL) { ndr_print_null(ndr); return; }
 
12294
        ndr->depth++;
 
12295
        if (flags & NDR_SET_VALUES) {
 
12296
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
12297
        }
 
12298
        if (flags & NDR_IN) {
 
12299
                ndr_print_struct(ndr, "in", "samr_Connect5");
 
12300
                ndr->depth++;
 
12301
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
 
12302
                ndr->depth++;
 
12303
                if (r->in.system_name) {
 
12304
                        ndr_print_string(ndr, "system_name", r->in.system_name);
 
12305
                }
 
12306
                ndr->depth--;
 
12307
                ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);
 
12308
                ndr_print_uint32(ndr, "level_in", r->in.level_in);
 
12309
                ndr_print_ptr(ndr, "info_in", r->in.info_in);
 
12310
                ndr->depth++;
 
12311
                ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);
 
12312
                ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);
 
12313
                ndr->depth--;
 
12314
                ndr->depth--;
 
12315
        }
 
12316
        if (flags & NDR_OUT) {
 
12317
                ndr_print_struct(ndr, "out", "samr_Connect5");
 
12318
                ndr->depth++;
 
12319
                ndr_print_ptr(ndr, "level_out", r->out.level_out);
 
12320
                ndr->depth++;
 
12321
                ndr_print_uint32(ndr, "level_out", *r->out.level_out);
 
12322
                ndr->depth--;
 
12323
                ndr_print_ptr(ndr, "info_out", r->out.info_out);
 
12324
                ndr->depth++;
 
12325
                ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);
 
12326
                ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);
 
12327
                ndr->depth--;
 
12328
                ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);
 
12329
                ndr->depth++;
 
12330
                ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);
 
12331
                ndr->depth--;
 
12332
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
12333
                ndr->depth--;
 
12334
        }
 
12335
        ndr->depth--;
 
12336
}
 
12337
 
 
12338
static enum ndr_err_code ndr_push_samr_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)
 
12339
{
 
12340
        if (flags & NDR_IN) {
 
12341
                if (r->in.domain_handle == NULL) {
 
12342
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12343
                }
 
12344
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
12345
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));
 
12346
        }
 
12347
        if (flags & NDR_OUT) {
 
12348
                if (r->out.sid == NULL) {
 
12349
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12350
                }
 
12351
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));
 
12352
                if (*r->out.sid) {
 
12353
                        NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
 
12354
                }
 
12355
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
12356
        }
 
12357
        return NDR_ERR_SUCCESS;
 
12358
}
 
12359
 
 
12360
static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)
 
12361
{
 
12362
        uint32_t _ptr_sid;
 
12363
        TALLOC_CTX *_mem_save_domain_handle_0;
 
12364
        TALLOC_CTX *_mem_save_sid_0;
 
12365
        TALLOC_CTX *_mem_save_sid_1;
 
12366
        if (flags & NDR_IN) {
 
12367
                ZERO_STRUCT(r->out);
 
12368
 
 
12369
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12370
                        NDR_PULL_ALLOC(ndr, r->in.domain_handle);
 
12371
                }
 
12372
                _mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12373
                NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);
 
12374
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));
 
12375
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);
 
12376
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));
 
12377
                NDR_PULL_ALLOC(ndr, r->out.sid);
 
12378
                ZERO_STRUCTP(r->out.sid);
 
12379
        }
 
12380
        if (flags & NDR_OUT) {
 
12381
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12382
                        NDR_PULL_ALLOC(ndr, r->out.sid);
 
12383
                }
 
12384
                _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12385
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
 
12386
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 
12387
                if (_ptr_sid) {
 
12388
                        NDR_PULL_ALLOC(ndr, *r->out.sid);
 
12389
                } else {
 
12390
                        *r->out.sid = NULL;
 
12391
                }
 
12392
                if (*r->out.sid) {
 
12393
                        _mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
12394
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);
 
12395
                        NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));
 
12396
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);
 
12397
                }
 
12398
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
 
12399
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
12400
        }
 
12401
        return NDR_ERR_SUCCESS;
 
12402
}
 
12403
 
 
12404
_PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)
 
12405
{
 
12406
        ndr_print_struct(ndr, name, "samr_RidToSid");
 
12407
        if (r == NULL) { ndr_print_null(ndr); return; }
 
12408
        ndr->depth++;
 
12409
        if (flags & NDR_SET_VALUES) {
 
12410
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
12411
        }
 
12412
        if (flags & NDR_IN) {
 
12413
                ndr_print_struct(ndr, "in", "samr_RidToSid");
 
12414
                ndr->depth++;
 
12415
                ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);
 
12416
                ndr->depth++;
 
12417
                ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);
 
12418
                ndr->depth--;
 
12419
                ndr_print_uint32(ndr, "rid", r->in.rid);
 
12420
                ndr->depth--;
 
12421
        }
 
12422
        if (flags & NDR_OUT) {
 
12423
                ndr_print_struct(ndr, "out", "samr_RidToSid");
 
12424
                ndr->depth++;
 
12425
                ndr_print_ptr(ndr, "sid", r->out.sid);
 
12426
                ndr->depth++;
 
12427
                ndr_print_ptr(ndr, "sid", *r->out.sid);
 
12428
                ndr->depth++;
 
12429
                if (*r->out.sid) {
 
12430
                        ndr_print_dom_sid2(ndr, "sid", *r->out.sid);
 
12431
                }
 
12432
                ndr->depth--;
 
12433
                ndr->depth--;
 
12434
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
12435
                ndr->depth--;
 
12436
        }
 
12437
        ndr->depth--;
 
12438
}
 
12439
 
 
12440
static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)
 
12441
{
 
12442
        if (flags & NDR_IN) {
 
12443
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
 
12444
                if (r->in.name) {
 
12445
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
12446
                }
 
12447
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
 
12448
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));
 
12449
                if (r->in.hash) {
 
12450
                        NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));
 
12451
                }
 
12452
        }
 
12453
        if (flags & NDR_OUT) {
 
12454
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
12455
        }
 
12456
        return NDR_ERR_SUCCESS;
 
12457
}
 
12458
 
 
12459
static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)
 
12460
{
 
12461
        uint32_t _ptr_name;
 
12462
        uint32_t _ptr_hash;
 
12463
        TALLOC_CTX *_mem_save_name_0;
 
12464
        TALLOC_CTX *_mem_save_hash_0;
 
12465
        if (flags & NDR_IN) {
 
12466
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 
12467
                if (_ptr_name) {
 
12468
                        NDR_PULL_ALLOC(ndr, r->in.name);
 
12469
                } else {
 
12470
                        r->in.name = NULL;
 
12471
                }
 
12472
                if (r->in.name) {
 
12473
                        _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12474
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
 
12475
                        NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
 
12476
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 
12477
                }
 
12478
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
 
12479
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));
 
12480
                if (_ptr_hash) {
 
12481
                        NDR_PULL_ALLOC(ndr, r->in.hash);
 
12482
                } else {
 
12483
                        r->in.hash = NULL;
 
12484
                }
 
12485
                if (r->in.hash) {
 
12486
                        _mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12487
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);
 
12488
                        NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));
 
12489
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);
 
12490
                }
 
12491
        }
 
12492
        if (flags & NDR_OUT) {
 
12493
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
12494
        }
 
12495
        return NDR_ERR_SUCCESS;
 
12496
}
 
12497
 
 
12498
_PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)
 
12499
{
 
12500
        ndr_print_struct(ndr, name, "samr_SetDsrmPassword");
 
12501
        if (r == NULL) { ndr_print_null(ndr); return; }
 
12502
        ndr->depth++;
 
12503
        if (flags & NDR_SET_VALUES) {
 
12504
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
12505
        }
 
12506
        if (flags & NDR_IN) {
 
12507
                ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");
 
12508
                ndr->depth++;
 
12509
                ndr_print_ptr(ndr, "name", r->in.name);
 
12510
                ndr->depth++;
 
12511
                if (r->in.name) {
 
12512
                        ndr_print_lsa_String(ndr, "name", r->in.name);
 
12513
                }
 
12514
                ndr->depth--;
 
12515
                ndr_print_uint32(ndr, "unknown", r->in.unknown);
 
12516
                ndr_print_ptr(ndr, "hash", r->in.hash);
 
12517
                ndr->depth++;
 
12518
                if (r->in.hash) {
 
12519
                        ndr_print_samr_Password(ndr, "hash", r->in.hash);
 
12520
                }
 
12521
                ndr->depth--;
 
12522
                ndr->depth--;
 
12523
        }
 
12524
        if (flags & NDR_OUT) {
 
12525
                ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");
 
12526
                ndr->depth++;
 
12527
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
12528
                ndr->depth--;
 
12529
        }
 
12530
        ndr->depth--;
 
12531
}
 
12532
 
 
12533
static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)
 
12534
{
 
12535
        if (flags & NDR_IN) {
 
12536
                NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));
 
12537
                if (r->in.req == NULL) {
 
12538
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12539
                }
 
12540
                NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
 
12541
                NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
 
12542
        }
 
12543
        if (flags & NDR_OUT) {
 
12544
                if (r->out.rep == NULL) {
 
12545
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
12546
                }
 
12547
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));
 
12548
                if (*r->out.rep) {
 
12549
                        NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));
 
12550
                        NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
 
12551
                }
 
12552
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
 
12553
        }
 
12554
        return NDR_ERR_SUCCESS;
 
12555
}
 
12556
 
 
12557
static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)
 
12558
{
 
12559
        uint32_t _ptr_rep;
 
12560
        TALLOC_CTX *_mem_save_req_0;
 
12561
        TALLOC_CTX *_mem_save_rep_0;
 
12562
        TALLOC_CTX *_mem_save_rep_1;
 
12563
        if (flags & NDR_IN) {
 
12564
                ZERO_STRUCT(r->out);
 
12565
 
 
12566
                NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));
 
12567
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12568
                        NDR_PULL_ALLOC(ndr, r->in.req);
 
12569
                }
 
12570
                _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12571
                NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
 
12572
                NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
 
12573
                NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
 
12574
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
 
12575
                NDR_PULL_ALLOC(ndr, r->out.rep);
 
12576
                ZERO_STRUCTP(r->out.rep);
 
12577
        }
 
12578
        if (flags & NDR_OUT) {
 
12579
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
12580
                        NDR_PULL_ALLOC(ndr, r->out.rep);
 
12581
                }
 
12582
                _mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
12583
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);
 
12584
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));
 
12585
                if (_ptr_rep) {
 
12586
                        NDR_PULL_ALLOC(ndr, *r->out.rep);
 
12587
                } else {
 
12588
                        *r->out.rep = NULL;
 
12589
                }
 
12590
                if (*r->out.rep) {
 
12591
                        _mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
12592
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);
 
12593
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));
 
12594
                        NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));
 
12595
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);
 
12596
                }
 
12597
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);
 
12598
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
 
12599
        }
 
12600
        return NDR_ERR_SUCCESS;
 
12601
}
 
12602
 
 
12603
_PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)
 
12604
{
 
12605
        ndr_print_struct(ndr, name, "samr_ValidatePassword");
 
12606
        if (r == NULL) { ndr_print_null(ndr); return; }
 
12607
        ndr->depth++;
 
12608
        if (flags & NDR_SET_VALUES) {
 
12609
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
12610
        }
 
12611
        if (flags & NDR_IN) {
 
12612
                ndr_print_struct(ndr, "in", "samr_ValidatePassword");
 
12613
                ndr->depth++;
 
12614
                ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);
 
12615
                ndr_print_ptr(ndr, "req", r->in.req);
 
12616
                ndr->depth++;
 
12617
                ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
 
12618
                ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);
 
12619
                ndr->depth--;
 
12620
                ndr->depth--;
 
12621
        }
 
12622
        if (flags & NDR_OUT) {
 
12623
                ndr_print_struct(ndr, "out", "samr_ValidatePassword");
 
12624
                ndr->depth++;
 
12625
                ndr_print_ptr(ndr, "rep", r->out.rep);
 
12626
                ndr->depth++;
 
12627
                ndr_print_ptr(ndr, "rep", *r->out.rep);
 
12628
                ndr->depth++;
 
12629
                if (*r->out.rep) {
 
12630
                        ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);
 
12631
                        ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);
 
12632
                }
 
12633
                ndr->depth--;
 
12634
                ndr->depth--;
 
12635
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
 
12636
                ndr->depth--;
 
12637
        }
 
12638
        ndr->depth--;
 
12639
}
 
12640
 
 
12641
static const struct ndr_interface_call samr_calls[] = {
 
12642
        {
 
12643
                "samr_Connect",
 
12644
                sizeof(struct samr_Connect),
 
12645
                (ndr_push_flags_fn_t) ndr_push_samr_Connect,
 
12646
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect,
 
12647
                (ndr_print_function_t) ndr_print_samr_Connect,
 
12648
                { 0, NULL },
 
12649
                { 0, NULL },
 
12650
        },
 
12651
        {
 
12652
                "samr_Close",
 
12653
                sizeof(struct samr_Close),
 
12654
                (ndr_push_flags_fn_t) ndr_push_samr_Close,
 
12655
                (ndr_pull_flags_fn_t) ndr_pull_samr_Close,
 
12656
                (ndr_print_function_t) ndr_print_samr_Close,
 
12657
                { 0, NULL },
 
12658
                { 0, NULL },
 
12659
        },
 
12660
        {
 
12661
                "samr_SetSecurity",
 
12662
                sizeof(struct samr_SetSecurity),
 
12663
                (ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,
 
12664
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,
 
12665
                (ndr_print_function_t) ndr_print_samr_SetSecurity,
 
12666
                { 0, NULL },
 
12667
                { 0, NULL },
 
12668
        },
 
12669
        {
 
12670
                "samr_QuerySecurity",
 
12671
                sizeof(struct samr_QuerySecurity),
 
12672
                (ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,
 
12673
                (ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,
 
12674
                (ndr_print_function_t) ndr_print_samr_QuerySecurity,
 
12675
                { 0, NULL },
 
12676
                { 0, NULL },
 
12677
        },
 
12678
        {
 
12679
                "samr_Shutdown",
 
12680
                sizeof(struct samr_Shutdown),
 
12681
                (ndr_push_flags_fn_t) ndr_push_samr_Shutdown,
 
12682
                (ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,
 
12683
                (ndr_print_function_t) ndr_print_samr_Shutdown,
 
12684
                { 0, NULL },
 
12685
                { 0, NULL },
 
12686
        },
 
12687
        {
 
12688
                "samr_LookupDomain",
 
12689
                sizeof(struct samr_LookupDomain),
 
12690
                (ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,
 
12691
                (ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,
 
12692
                (ndr_print_function_t) ndr_print_samr_LookupDomain,
 
12693
                { 0, NULL },
 
12694
                { 0, NULL },
 
12695
        },
 
12696
        {
 
12697
                "samr_EnumDomains",
 
12698
                sizeof(struct samr_EnumDomains),
 
12699
                (ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,
 
12700
                (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,
 
12701
                (ndr_print_function_t) ndr_print_samr_EnumDomains,
 
12702
                { 0, NULL },
 
12703
                { 0, NULL },
 
12704
        },
 
12705
        {
 
12706
                "samr_OpenDomain",
 
12707
                sizeof(struct samr_OpenDomain),
 
12708
                (ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,
 
12709
                (ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,
 
12710
                (ndr_print_function_t) ndr_print_samr_OpenDomain,
 
12711
                { 0, NULL },
 
12712
                { 0, NULL },
 
12713
        },
 
12714
        {
 
12715
                "samr_QueryDomainInfo",
 
12716
                sizeof(struct samr_QueryDomainInfo),
 
12717
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,
 
12718
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,
 
12719
                (ndr_print_function_t) ndr_print_samr_QueryDomainInfo,
 
12720
                { 0, NULL },
 
12721
                { 0, NULL },
 
12722
        },
 
12723
        {
 
12724
                "samr_SetDomainInfo",
 
12725
                sizeof(struct samr_SetDomainInfo),
 
12726
                (ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,
 
12727
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,
 
12728
                (ndr_print_function_t) ndr_print_samr_SetDomainInfo,
 
12729
                { 0, NULL },
 
12730
                { 0, NULL },
 
12731
        },
 
12732
        {
 
12733
                "samr_CreateDomainGroup",
 
12734
                sizeof(struct samr_CreateDomainGroup),
 
12735
                (ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,
 
12736
                (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,
 
12737
                (ndr_print_function_t) ndr_print_samr_CreateDomainGroup,
 
12738
                { 0, NULL },
 
12739
                { 0, NULL },
 
12740
        },
 
12741
        {
 
12742
                "samr_EnumDomainGroups",
 
12743
                sizeof(struct samr_EnumDomainGroups),
 
12744
                (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,
 
12745
                (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,
 
12746
                (ndr_print_function_t) ndr_print_samr_EnumDomainGroups,
 
12747
                { 0, NULL },
 
12748
                { 0, NULL },
 
12749
        },
 
12750
        {
 
12751
                "samr_CreateUser",
 
12752
                sizeof(struct samr_CreateUser),
 
12753
                (ndr_push_flags_fn_t) ndr_push_samr_CreateUser,
 
12754
                (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,
 
12755
                (ndr_print_function_t) ndr_print_samr_CreateUser,
 
12756
                { 0, NULL },
 
12757
                { 0, NULL },
 
12758
        },
 
12759
        {
 
12760
                "samr_EnumDomainUsers",
 
12761
                sizeof(struct samr_EnumDomainUsers),
 
12762
                (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,
 
12763
                (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,
 
12764
                (ndr_print_function_t) ndr_print_samr_EnumDomainUsers,
 
12765
                { 0, NULL },
 
12766
                { 0, NULL },
 
12767
        },
 
12768
        {
 
12769
                "samr_CreateDomAlias",
 
12770
                sizeof(struct samr_CreateDomAlias),
 
12771
                (ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,
 
12772
                (ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,
 
12773
                (ndr_print_function_t) ndr_print_samr_CreateDomAlias,
 
12774
                { 0, NULL },
 
12775
                { 0, NULL },
 
12776
        },
 
12777
        {
 
12778
                "samr_EnumDomainAliases",
 
12779
                sizeof(struct samr_EnumDomainAliases),
 
12780
                (ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,
 
12781
                (ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,
 
12782
                (ndr_print_function_t) ndr_print_samr_EnumDomainAliases,
 
12783
                { 0, NULL },
 
12784
                { 0, NULL },
 
12785
        },
 
12786
        {
 
12787
                "samr_GetAliasMembership",
 
12788
                sizeof(struct samr_GetAliasMembership),
 
12789
                (ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,
 
12790
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,
 
12791
                (ndr_print_function_t) ndr_print_samr_GetAliasMembership,
 
12792
                { 0, NULL },
 
12793
                { 0, NULL },
 
12794
        },
 
12795
        {
 
12796
                "samr_LookupNames",
 
12797
                sizeof(struct samr_LookupNames),
 
12798
                (ndr_push_flags_fn_t) ndr_push_samr_LookupNames,
 
12799
                (ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,
 
12800
                (ndr_print_function_t) ndr_print_samr_LookupNames,
 
12801
                { 0, NULL },
 
12802
                { 0, NULL },
 
12803
        },
 
12804
        {
 
12805
                "samr_LookupRids",
 
12806
                sizeof(struct samr_LookupRids),
 
12807
                (ndr_push_flags_fn_t) ndr_push_samr_LookupRids,
 
12808
                (ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,
 
12809
                (ndr_print_function_t) ndr_print_samr_LookupRids,
 
12810
                { 0, NULL },
 
12811
                { 0, NULL },
 
12812
        },
 
12813
        {
 
12814
                "samr_OpenGroup",
 
12815
                sizeof(struct samr_OpenGroup),
 
12816
                (ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,
 
12817
                (ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,
 
12818
                (ndr_print_function_t) ndr_print_samr_OpenGroup,
 
12819
                { 0, NULL },
 
12820
                { 0, NULL },
 
12821
        },
 
12822
        {
 
12823
                "samr_QueryGroupInfo",
 
12824
                sizeof(struct samr_QueryGroupInfo),
 
12825
                (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,
 
12826
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,
 
12827
                (ndr_print_function_t) ndr_print_samr_QueryGroupInfo,
 
12828
                { 0, NULL },
 
12829
                { 0, NULL },
 
12830
        },
 
12831
        {
 
12832
                "samr_SetGroupInfo",
 
12833
                sizeof(struct samr_SetGroupInfo),
 
12834
                (ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,
 
12835
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,
 
12836
                (ndr_print_function_t) ndr_print_samr_SetGroupInfo,
 
12837
                { 0, NULL },
 
12838
                { 0, NULL },
 
12839
        },
 
12840
        {
 
12841
                "samr_AddGroupMember",
 
12842
                sizeof(struct samr_AddGroupMember),
 
12843
                (ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,
 
12844
                (ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,
 
12845
                (ndr_print_function_t) ndr_print_samr_AddGroupMember,
 
12846
                { 0, NULL },
 
12847
                { 0, NULL },
 
12848
        },
 
12849
        {
 
12850
                "samr_DeleteDomainGroup",
 
12851
                sizeof(struct samr_DeleteDomainGroup),
 
12852
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,
 
12853
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,
 
12854
                (ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,
 
12855
                { 0, NULL },
 
12856
                { 0, NULL },
 
12857
        },
 
12858
        {
 
12859
                "samr_DeleteGroupMember",
 
12860
                sizeof(struct samr_DeleteGroupMember),
 
12861
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,
 
12862
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,
 
12863
                (ndr_print_function_t) ndr_print_samr_DeleteGroupMember,
 
12864
                { 0, NULL },
 
12865
                { 0, NULL },
 
12866
        },
 
12867
        {
 
12868
                "samr_QueryGroupMember",
 
12869
                sizeof(struct samr_QueryGroupMember),
 
12870
                (ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,
 
12871
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,
 
12872
                (ndr_print_function_t) ndr_print_samr_QueryGroupMember,
 
12873
                { 0, NULL },
 
12874
                { 0, NULL },
 
12875
        },
 
12876
        {
 
12877
                "samr_SetMemberAttributesOfGroup",
 
12878
                sizeof(struct samr_SetMemberAttributesOfGroup),
 
12879
                (ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,
 
12880
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,
 
12881
                (ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,
 
12882
                { 0, NULL },
 
12883
                { 0, NULL },
 
12884
        },
 
12885
        {
 
12886
                "samr_OpenAlias",
 
12887
                sizeof(struct samr_OpenAlias),
 
12888
                (ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,
 
12889
                (ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,
 
12890
                (ndr_print_function_t) ndr_print_samr_OpenAlias,
 
12891
                { 0, NULL },
 
12892
                { 0, NULL },
 
12893
        },
 
12894
        {
 
12895
                "samr_QueryAliasInfo",
 
12896
                sizeof(struct samr_QueryAliasInfo),
 
12897
                (ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,
 
12898
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,
 
12899
                (ndr_print_function_t) ndr_print_samr_QueryAliasInfo,
 
12900
                { 0, NULL },
 
12901
                { 0, NULL },
 
12902
        },
 
12903
        {
 
12904
                "samr_SetAliasInfo",
 
12905
                sizeof(struct samr_SetAliasInfo),
 
12906
                (ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,
 
12907
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,
 
12908
                (ndr_print_function_t) ndr_print_samr_SetAliasInfo,
 
12909
                { 0, NULL },
 
12910
                { 0, NULL },
 
12911
        },
 
12912
        {
 
12913
                "samr_DeleteDomAlias",
 
12914
                sizeof(struct samr_DeleteDomAlias),
 
12915
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,
 
12916
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,
 
12917
                (ndr_print_function_t) ndr_print_samr_DeleteDomAlias,
 
12918
                { 0, NULL },
 
12919
                { 0, NULL },
 
12920
        },
 
12921
        {
 
12922
                "samr_AddAliasMember",
 
12923
                sizeof(struct samr_AddAliasMember),
 
12924
                (ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,
 
12925
                (ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,
 
12926
                (ndr_print_function_t) ndr_print_samr_AddAliasMember,
 
12927
                { 0, NULL },
 
12928
                { 0, NULL },
 
12929
        },
 
12930
        {
 
12931
                "samr_DeleteAliasMember",
 
12932
                sizeof(struct samr_DeleteAliasMember),
 
12933
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,
 
12934
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,
 
12935
                (ndr_print_function_t) ndr_print_samr_DeleteAliasMember,
 
12936
                { 0, NULL },
 
12937
                { 0, NULL },
 
12938
        },
 
12939
        {
 
12940
                "samr_GetMembersInAlias",
 
12941
                sizeof(struct samr_GetMembersInAlias),
 
12942
                (ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,
 
12943
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,
 
12944
                (ndr_print_function_t) ndr_print_samr_GetMembersInAlias,
 
12945
                { 0, NULL },
 
12946
                { 0, NULL },
 
12947
        },
 
12948
        {
 
12949
                "samr_OpenUser",
 
12950
                sizeof(struct samr_OpenUser),
 
12951
                (ndr_push_flags_fn_t) ndr_push_samr_OpenUser,
 
12952
                (ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,
 
12953
                (ndr_print_function_t) ndr_print_samr_OpenUser,
 
12954
                { 0, NULL },
 
12955
                { 0, NULL },
 
12956
        },
 
12957
        {
 
12958
                "samr_DeleteUser",
 
12959
                sizeof(struct samr_DeleteUser),
 
12960
                (ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,
 
12961
                (ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,
 
12962
                (ndr_print_function_t) ndr_print_samr_DeleteUser,
 
12963
                { 0, NULL },
 
12964
                { 0, NULL },
 
12965
        },
 
12966
        {
 
12967
                "samr_QueryUserInfo",
 
12968
                sizeof(struct samr_QueryUserInfo),
 
12969
                (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,
 
12970
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,
 
12971
                (ndr_print_function_t) ndr_print_samr_QueryUserInfo,
 
12972
                { 0, NULL },
 
12973
                { 0, NULL },
 
12974
        },
 
12975
        {
 
12976
                "samr_SetUserInfo",
 
12977
                sizeof(struct samr_SetUserInfo),
 
12978
                (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,
 
12979
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,
 
12980
                (ndr_print_function_t) ndr_print_samr_SetUserInfo,
 
12981
                { 0, NULL },
 
12982
                { 0, NULL },
 
12983
        },
 
12984
        {
 
12985
                "samr_ChangePasswordUser",
 
12986
                sizeof(struct samr_ChangePasswordUser),
 
12987
                (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,
 
12988
                (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,
 
12989
                (ndr_print_function_t) ndr_print_samr_ChangePasswordUser,
 
12990
                { 0, NULL },
 
12991
                { 0, NULL },
 
12992
        },
 
12993
        {
 
12994
                "samr_GetGroupsForUser",
 
12995
                sizeof(struct samr_GetGroupsForUser),
 
12996
                (ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,
 
12997
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,
 
12998
                (ndr_print_function_t) ndr_print_samr_GetGroupsForUser,
 
12999
                { 0, NULL },
 
13000
                { 0, NULL },
 
13001
        },
 
13002
        {
 
13003
                "samr_QueryDisplayInfo",
 
13004
                sizeof(struct samr_QueryDisplayInfo),
 
13005
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,
 
13006
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,
 
13007
                (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,
 
13008
                { 0, NULL },
 
13009
                { 0, NULL },
 
13010
        },
 
13011
        {
 
13012
                "samr_GetDisplayEnumerationIndex",
 
13013
                sizeof(struct samr_GetDisplayEnumerationIndex),
 
13014
                (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,
 
13015
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,
 
13016
                (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,
 
13017
                { 0, NULL },
 
13018
                { 0, NULL },
 
13019
        },
 
13020
        {
 
13021
                "samr_TestPrivateFunctionsDomain",
 
13022
                sizeof(struct samr_TestPrivateFunctionsDomain),
 
13023
                (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,
 
13024
                (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,
 
13025
                (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,
 
13026
                { 0, NULL },
 
13027
                { 0, NULL },
 
13028
        },
 
13029
        {
 
13030
                "samr_TestPrivateFunctionsUser",
 
13031
                sizeof(struct samr_TestPrivateFunctionsUser),
 
13032
                (ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,
 
13033
                (ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,
 
13034
                (ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,
 
13035
                { 0, NULL },
 
13036
                { 0, NULL },
 
13037
        },
 
13038
        {
 
13039
                "samr_GetUserPwInfo",
 
13040
                sizeof(struct samr_GetUserPwInfo),
 
13041
                (ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,
 
13042
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,
 
13043
                (ndr_print_function_t) ndr_print_samr_GetUserPwInfo,
 
13044
                { 0, NULL },
 
13045
                { 0, NULL },
 
13046
        },
 
13047
        {
 
13048
                "samr_RemoveMemberFromForeignDomain",
 
13049
                sizeof(struct samr_RemoveMemberFromForeignDomain),
 
13050
                (ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,
 
13051
                (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,
 
13052
                (ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,
 
13053
                { 0, NULL },
 
13054
                { 0, NULL },
 
13055
        },
 
13056
        {
 
13057
                "samr_QueryDomainInfo2",
 
13058
                sizeof(struct samr_QueryDomainInfo2),
 
13059
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,
 
13060
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,
 
13061
                (ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,
 
13062
                { 0, NULL },
 
13063
                { 0, NULL },
 
13064
        },
 
13065
        {
 
13066
                "samr_QueryUserInfo2",
 
13067
                sizeof(struct samr_QueryUserInfo2),
 
13068
                (ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,
 
13069
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,
 
13070
                (ndr_print_function_t) ndr_print_samr_QueryUserInfo2,
 
13071
                { 0, NULL },
 
13072
                { 0, NULL },
 
13073
        },
 
13074
        {
 
13075
                "samr_QueryDisplayInfo2",
 
13076
                sizeof(struct samr_QueryDisplayInfo2),
 
13077
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,
 
13078
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,
 
13079
                (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,
 
13080
                { 0, NULL },
 
13081
                { 0, NULL },
 
13082
        },
 
13083
        {
 
13084
                "samr_GetDisplayEnumerationIndex2",
 
13085
                sizeof(struct samr_GetDisplayEnumerationIndex2),
 
13086
                (ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,
 
13087
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,
 
13088
                (ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,
 
13089
                { 0, NULL },
 
13090
                { 0, NULL },
 
13091
        },
 
13092
        {
 
13093
                "samr_CreateUser2",
 
13094
                sizeof(struct samr_CreateUser2),
 
13095
                (ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,
 
13096
                (ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,
 
13097
                (ndr_print_function_t) ndr_print_samr_CreateUser2,
 
13098
                { 0, NULL },
 
13099
                { 0, NULL },
 
13100
        },
 
13101
        {
 
13102
                "samr_QueryDisplayInfo3",
 
13103
                sizeof(struct samr_QueryDisplayInfo3),
 
13104
                (ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,
 
13105
                (ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,
 
13106
                (ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,
 
13107
                { 0, NULL },
 
13108
                { 0, NULL },
 
13109
        },
 
13110
        {
 
13111
                "samr_AddMultipleMembersToAlias",
 
13112
                sizeof(struct samr_AddMultipleMembersToAlias),
 
13113
                (ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,
 
13114
                (ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,
 
13115
                (ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,
 
13116
                { 0, NULL },
 
13117
                { 0, NULL },
 
13118
        },
 
13119
        {
 
13120
                "samr_RemoveMultipleMembersFromAlias",
 
13121
                sizeof(struct samr_RemoveMultipleMembersFromAlias),
 
13122
                (ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,
 
13123
                (ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,
 
13124
                (ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,
 
13125
                { 0, NULL },
 
13126
                { 0, NULL },
 
13127
        },
 
13128
        {
 
13129
                "samr_OemChangePasswordUser2",
 
13130
                sizeof(struct samr_OemChangePasswordUser2),
 
13131
                (ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,
 
13132
                (ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,
 
13133
                (ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,
 
13134
                { 0, NULL },
 
13135
                { 0, NULL },
 
13136
        },
 
13137
        {
 
13138
                "samr_ChangePasswordUser2",
 
13139
                sizeof(struct samr_ChangePasswordUser2),
 
13140
                (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,
 
13141
                (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,
 
13142
                (ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,
 
13143
                { 0, NULL },
 
13144
                { 0, NULL },
 
13145
        },
 
13146
        {
 
13147
                "samr_GetDomPwInfo",
 
13148
                sizeof(struct samr_GetDomPwInfo),
 
13149
                (ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,
 
13150
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,
 
13151
                (ndr_print_function_t) ndr_print_samr_GetDomPwInfo,
 
13152
                { 0, NULL },
 
13153
                { 0, NULL },
 
13154
        },
 
13155
        {
 
13156
                "samr_Connect2",
 
13157
                sizeof(struct samr_Connect2),
 
13158
                (ndr_push_flags_fn_t) ndr_push_samr_Connect2,
 
13159
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,
 
13160
                (ndr_print_function_t) ndr_print_samr_Connect2,
 
13161
                { 0, NULL },
 
13162
                { 0, NULL },
 
13163
        },
 
13164
        {
 
13165
                "samr_SetUserInfo2",
 
13166
                sizeof(struct samr_SetUserInfo2),
 
13167
                (ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,
 
13168
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,
 
13169
                (ndr_print_function_t) ndr_print_samr_SetUserInfo2,
 
13170
                { 0, NULL },
 
13171
                { 0, NULL },
 
13172
        },
 
13173
        {
 
13174
                "samr_SetBootKeyInformation",
 
13175
                sizeof(struct samr_SetBootKeyInformation),
 
13176
                (ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,
 
13177
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,
 
13178
                (ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,
 
13179
                { 0, NULL },
 
13180
                { 0, NULL },
 
13181
        },
 
13182
        {
 
13183
                "samr_GetBootKeyInformation",
 
13184
                sizeof(struct samr_GetBootKeyInformation),
 
13185
                (ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,
 
13186
                (ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,
 
13187
                (ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,
 
13188
                { 0, NULL },
 
13189
                { 0, NULL },
 
13190
        },
 
13191
        {
 
13192
                "samr_Connect3",
 
13193
                sizeof(struct samr_Connect3),
 
13194
                (ndr_push_flags_fn_t) ndr_push_samr_Connect3,
 
13195
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,
 
13196
                (ndr_print_function_t) ndr_print_samr_Connect3,
 
13197
                { 0, NULL },
 
13198
                { 0, NULL },
 
13199
        },
 
13200
        {
 
13201
                "samr_Connect4",
 
13202
                sizeof(struct samr_Connect4),
 
13203
                (ndr_push_flags_fn_t) ndr_push_samr_Connect4,
 
13204
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,
 
13205
                (ndr_print_function_t) ndr_print_samr_Connect4,
 
13206
                { 0, NULL },
 
13207
                { 0, NULL },
 
13208
        },
 
13209
        {
 
13210
                "samr_ChangePasswordUser3",
 
13211
                sizeof(struct samr_ChangePasswordUser3),
 
13212
                (ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,
 
13213
                (ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,
 
13214
                (ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,
 
13215
                { 0, NULL },
 
13216
                { 0, NULL },
 
13217
        },
 
13218
        {
 
13219
                "samr_Connect5",
 
13220
                sizeof(struct samr_Connect5),
 
13221
                (ndr_push_flags_fn_t) ndr_push_samr_Connect5,
 
13222
                (ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,
 
13223
                (ndr_print_function_t) ndr_print_samr_Connect5,
 
13224
                { 0, NULL },
 
13225
                { 0, NULL },
 
13226
        },
 
13227
        {
 
13228
                "samr_RidToSid",
 
13229
                sizeof(struct samr_RidToSid),
 
13230
                (ndr_push_flags_fn_t) ndr_push_samr_RidToSid,
 
13231
                (ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,
 
13232
                (ndr_print_function_t) ndr_print_samr_RidToSid,
 
13233
                { 0, NULL },
 
13234
                { 0, NULL },
 
13235
        },
 
13236
        {
 
13237
                "samr_SetDsrmPassword",
 
13238
                sizeof(struct samr_SetDsrmPassword),
 
13239
                (ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,
 
13240
                (ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,
 
13241
                (ndr_print_function_t) ndr_print_samr_SetDsrmPassword,
 
13242
                { 0, NULL },
 
13243
                { 0, NULL },
 
13244
        },
 
13245
        {
 
13246
                "samr_ValidatePassword",
 
13247
                sizeof(struct samr_ValidatePassword),
 
13248
                (ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,
 
13249
                (ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,
 
13250
                (ndr_print_function_t) ndr_print_samr_ValidatePassword,
 
13251
                { 0, NULL },
 
13252
                { 0, NULL },
 
13253
        },
 
13254
        { NULL, 0, NULL, NULL, NULL }
 
13255
};
 
13256
 
 
13257
static const char * const samr_endpoint_strings[] = {
 
13258
        "ncacn_np:[\\pipe\\samr]", 
 
13259
        "ncacn_ip_tcp:", 
 
13260
        "ncalrpc:", 
 
13261
};
 
13262
 
 
13263
static const struct ndr_interface_string_array samr_endpoints = {
 
13264
        .count  = 3,
 
13265
        .names  = samr_endpoint_strings
 
13266
};
 
13267
 
 
13268
static const char * const samr_authservice_strings[] = {
 
13269
        "host", 
 
13270
};
 
13271
 
 
13272
static const struct ndr_interface_string_array samr_authservices = {
 
13273
        .count  = 1,
 
13274
        .names  = samr_authservice_strings
 
13275
};
 
13276
 
 
13277
 
 
13278
const struct ndr_interface_table ndr_table_samr = {
 
13279
        .name           = "samr",
 
13280
        .syntax_id      = {
 
13281
                {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},
 
13282
                NDR_SAMR_VERSION
 
13283
        },
 
13284
        .helpstring     = NDR_SAMR_HELPSTRING,
 
13285
        .num_calls      = 68,
 
13286
        .calls          = samr_calls,
 
13287
        .endpoints      = &samr_endpoints,
 
13288
        .authservices   = &samr_authservices
 
13289
};
 
13290