97b29761ee3c47ab39b6de5da6837c101bfbb9d1
[ira/wip.git] / source3 / librpc / gen_ndr / ndr_wbint.c
1 /* parser auto-generated by pidl */
2
3 #include "includes.h"
4 #include "librpc/gen_ndr/ndr_wbint.h"
5
6 #include "librpc/gen_ndr/ndr_lsa.h"
7 #include "librpc/gen_ndr/ndr_netlogon.h"
8 _PUBLIC_ enum ndr_err_code ndr_push_wbint_userinfo(struct ndr_push *ndr, int ndr_flags, const struct wbint_userinfo *r)
9 {
10         if (ndr_flags & NDR_SCALARS) {
11                 NDR_CHECK(ndr_push_align(ndr, 8));
12                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->acct_name));
13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->full_name));
14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->homedir));
15                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->shell));
16                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->primary_gid));
17                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->user_sid));
18                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->group_sid));
19                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20         }
21         if (ndr_flags & NDR_BUFFERS) {
22                 if (r->acct_name) {
23                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
24                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->acct_name, CH_UTF8)));
26                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->acct_name, ndr_charset_length(r->acct_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
27                 }
28                 if (r->full_name) {
29                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
30                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
31                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->full_name, CH_UTF8)));
32                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->full_name, ndr_charset_length(r->full_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
33                 }
34                 if (r->homedir) {
35                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
36                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
37                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->homedir, CH_UTF8)));
38                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->homedir, ndr_charset_length(r->homedir, CH_UTF8), sizeof(uint8_t), CH_UTF8));
39                 }
40                 if (r->shell) {
41                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
42                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
43                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->shell, CH_UTF8)));
44                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->shell, ndr_charset_length(r->shell, CH_UTF8), sizeof(uint8_t), CH_UTF8));
45                 }
46         }
47         return NDR_ERR_SUCCESS;
48 }
49
50 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_userinfo(struct ndr_pull *ndr, int ndr_flags, struct wbint_userinfo *r)
51 {
52         uint32_t _ptr_acct_name;
53         TALLOC_CTX *_mem_save_acct_name_0;
54         uint32_t _ptr_full_name;
55         TALLOC_CTX *_mem_save_full_name_0;
56         uint32_t _ptr_homedir;
57         TALLOC_CTX *_mem_save_homedir_0;
58         uint32_t _ptr_shell;
59         TALLOC_CTX *_mem_save_shell_0;
60         if (ndr_flags & NDR_SCALARS) {
61                 NDR_CHECK(ndr_pull_align(ndr, 8));
62                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_acct_name));
63                 if (_ptr_acct_name) {
64                         NDR_PULL_ALLOC(ndr, r->acct_name);
65                 } else {
66                         r->acct_name = NULL;
67                 }
68                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_full_name));
69                 if (_ptr_full_name) {
70                         NDR_PULL_ALLOC(ndr, r->full_name);
71                 } else {
72                         r->full_name = NULL;
73                 }
74                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_homedir));
75                 if (_ptr_homedir) {
76                         NDR_PULL_ALLOC(ndr, r->homedir);
77                 } else {
78                         r->homedir = NULL;
79                 }
80                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_shell));
81                 if (_ptr_shell) {
82                         NDR_PULL_ALLOC(ndr, r->shell);
83                 } else {
84                         r->shell = NULL;
85                 }
86                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->primary_gid));
87                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->user_sid));
88                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->group_sid));
89                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
90         }
91         if (ndr_flags & NDR_BUFFERS) {
92                 if (r->acct_name) {
93                         _mem_save_acct_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
94                         NDR_PULL_SET_MEM_CTX(ndr, r->acct_name, 0);
95                         NDR_CHECK(ndr_pull_array_size(ndr, &r->acct_name));
96                         NDR_CHECK(ndr_pull_array_length(ndr, &r->acct_name));
97                         if (ndr_get_array_length(ndr, &r->acct_name) > ndr_get_array_size(ndr, &r->acct_name)) {
98                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->acct_name), ndr_get_array_length(ndr, &r->acct_name));
99                         }
100                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->acct_name), sizeof(uint8_t)));
101                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->acct_name, ndr_get_array_length(ndr, &r->acct_name), sizeof(uint8_t), CH_UTF8));
102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_name_0, 0);
103                 }
104                 if (r->full_name) {
105                         _mem_save_full_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
106                         NDR_PULL_SET_MEM_CTX(ndr, r->full_name, 0);
107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->full_name));
108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->full_name));
109                         if (ndr_get_array_length(ndr, &r->full_name) > ndr_get_array_size(ndr, &r->full_name)) {
110                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->full_name), ndr_get_array_length(ndr, &r->full_name));
111                         }
112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->full_name), sizeof(uint8_t)));
113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->full_name, ndr_get_array_length(ndr, &r->full_name), sizeof(uint8_t), CH_UTF8));
114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_full_name_0, 0);
115                 }
116                 if (r->homedir) {
117                         _mem_save_homedir_0 = NDR_PULL_GET_MEM_CTX(ndr);
118                         NDR_PULL_SET_MEM_CTX(ndr, r->homedir, 0);
119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->homedir));
120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->homedir));
121                         if (ndr_get_array_length(ndr, &r->homedir) > ndr_get_array_size(ndr, &r->homedir)) {
122                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->homedir), ndr_get_array_length(ndr, &r->homedir));
123                         }
124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->homedir), sizeof(uint8_t)));
125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->homedir, ndr_get_array_length(ndr, &r->homedir), sizeof(uint8_t), CH_UTF8));
126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_homedir_0, 0);
127                 }
128                 if (r->shell) {
129                         _mem_save_shell_0 = NDR_PULL_GET_MEM_CTX(ndr);
130                         NDR_PULL_SET_MEM_CTX(ndr, r->shell, 0);
131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->shell));
132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->shell));
133                         if (ndr_get_array_length(ndr, &r->shell) > ndr_get_array_size(ndr, &r->shell)) {
134                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->shell), ndr_get_array_length(ndr, &r->shell));
135                         }
136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->shell), sizeof(uint8_t)));
137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->shell, ndr_get_array_length(ndr, &r->shell), sizeof(uint8_t), CH_UTF8));
138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_shell_0, 0);
139                 }
140         }
141         return NDR_ERR_SUCCESS;
142 }
143
144 _PUBLIC_ void ndr_print_wbint_userinfo(struct ndr_print *ndr, const char *name, const struct wbint_userinfo *r)
145 {
146         ndr_print_struct(ndr, name, "wbint_userinfo");
147         ndr->depth++;
148         ndr_print_ptr(ndr, "acct_name", r->acct_name);
149         ndr->depth++;
150         if (r->acct_name) {
151                 ndr_print_string(ndr, "acct_name", r->acct_name);
152         }
153         ndr->depth--;
154         ndr_print_ptr(ndr, "full_name", r->full_name);
155         ndr->depth++;
156         if (r->full_name) {
157                 ndr_print_string(ndr, "full_name", r->full_name);
158         }
159         ndr->depth--;
160         ndr_print_ptr(ndr, "homedir", r->homedir);
161         ndr->depth++;
162         if (r->homedir) {
163                 ndr_print_string(ndr, "homedir", r->homedir);
164         }
165         ndr->depth--;
166         ndr_print_ptr(ndr, "shell", r->shell);
167         ndr->depth++;
168         if (r->shell) {
169                 ndr_print_string(ndr, "shell", r->shell);
170         }
171         ndr->depth--;
172         ndr_print_hyper(ndr, "primary_gid", r->primary_gid);
173         ndr_print_dom_sid(ndr, "user_sid", &r->user_sid);
174         ndr_print_dom_sid(ndr, "group_sid", &r->group_sid);
175         ndr->depth--;
176 }
177
178 _PUBLIC_ enum ndr_err_code ndr_push_wbint_SidArray(struct ndr_push *ndr, int ndr_flags, const struct wbint_SidArray *r)
179 {
180         uint32_t cntr_sids_0;
181         if (ndr_flags & NDR_SCALARS) {
182                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
183                 NDR_CHECK(ndr_push_align(ndr, 4));
184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
185                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
186                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
187                 }
188                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
189         }
190         if (ndr_flags & NDR_BUFFERS) {
191         }
192         return NDR_ERR_SUCCESS;
193 }
194
195 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_SidArray(struct ndr_pull *ndr, int ndr_flags, struct wbint_SidArray *r)
196 {
197         uint32_t cntr_sids_0;
198         TALLOC_CTX *_mem_save_sids_0;
199         if (ndr_flags & NDR_SCALARS) {
200                 NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
201                 NDR_CHECK(ndr_pull_align(ndr, 4));
202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
203                 NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
204                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
205                 NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
206                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
207                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sids[cntr_sids_0]));
208                 }
209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
210                 if (r->sids) {
211                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
212                 }
213                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
214         }
215         if (ndr_flags & NDR_BUFFERS) {
216         }
217         return NDR_ERR_SUCCESS;
218 }
219
220 _PUBLIC_ void ndr_print_wbint_SidArray(struct ndr_print *ndr, const char *name, const struct wbint_SidArray *r)
221 {
222         uint32_t cntr_sids_0;
223         ndr_print_struct(ndr, name, "wbint_SidArray");
224         ndr->depth++;
225         ndr_print_uint32(ndr, "num_sids", r->num_sids);
226         ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
227         ndr->depth++;
228         for (cntr_sids_0=0;cntr_sids_0<r->num_sids;cntr_sids_0++) {
229                 char *idx_0=NULL;
230                 if (asprintf(&idx_0, "[%d]", cntr_sids_0) != -1) {
231                         ndr_print_dom_sid(ndr, "sids", &r->sids[cntr_sids_0]);
232                         free(idx_0);
233                 }
234         }
235         ndr->depth--;
236         ndr->depth--;
237 }
238
239 _PUBLIC_ enum ndr_err_code ndr_push_wbint_RidArray(struct ndr_push *ndr, int ndr_flags, const struct wbint_RidArray *r)
240 {
241         uint32_t cntr_rids_0;
242         if (ndr_flags & NDR_SCALARS) {
243                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_rids));
244                 NDR_CHECK(ndr_push_align(ndr, 4));
245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_rids));
246                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_0]));
248                 }
249                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
250         }
251         if (ndr_flags & NDR_BUFFERS) {
252         }
253         return NDR_ERR_SUCCESS;
254 }
255
256 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_RidArray(struct ndr_pull *ndr, int ndr_flags, struct wbint_RidArray *r)
257 {
258         uint32_t cntr_rids_0;
259         TALLOC_CTX *_mem_save_rids_0;
260         if (ndr_flags & NDR_SCALARS) {
261                 NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));
262                 NDR_CHECK(ndr_pull_align(ndr, 4));
263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_rids));
264                 NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));
265                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
266                 NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);
267                 for (cntr_rids_0 = 0; cntr_rids_0 < r->num_rids; cntr_rids_0++) {
268                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_0]));
269                 }
270                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);
271                 if (r->rids) {
272                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->num_rids));
273                 }
274                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
275         }
276         if (ndr_flags & NDR_BUFFERS) {
277         }
278         return NDR_ERR_SUCCESS;
279 }
280
281 _PUBLIC_ void ndr_print_wbint_RidArray(struct ndr_print *ndr, const char *name, const struct wbint_RidArray *r)
282 {
283         uint32_t cntr_rids_0;
284         ndr_print_struct(ndr, name, "wbint_RidArray");
285         ndr->depth++;
286         ndr_print_uint32(ndr, "num_rids", r->num_rids);
287         ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->num_rids);
288         ndr->depth++;
289         for (cntr_rids_0=0;cntr_rids_0<r->num_rids;cntr_rids_0++) {
290                 char *idx_0=NULL;
291                 if (asprintf(&idx_0, "[%d]", cntr_rids_0) != -1) {
292                         ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_0]);
293                         free(idx_0);
294                 }
295         }
296         ndr->depth--;
297         ndr->depth--;
298 }
299
300 _PUBLIC_ enum ndr_err_code ndr_push_wbint_Principal(struct ndr_push *ndr, int ndr_flags, const struct wbint_Principal *r)
301 {
302         if (ndr_flags & NDR_SCALARS) {
303                 NDR_CHECK(ndr_push_align(ndr, 5));
304                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sid));
305                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->type));
306                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
307                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
308         }
309         if (ndr_flags & NDR_BUFFERS) {
310                 if (r->name) {
311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
313                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF8)));
314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
315                 }
316         }
317         return NDR_ERR_SUCCESS;
318 }
319
320 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principal(struct ndr_pull *ndr, int ndr_flags, struct wbint_Principal *r)
321 {
322         uint32_t _ptr_name;
323         TALLOC_CTX *_mem_save_name_0;
324         if (ndr_flags & NDR_SCALARS) {
325                 NDR_CHECK(ndr_pull_align(ndr, 5));
326                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sid));
327                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->type));
328                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
329                 if (_ptr_name) {
330                         NDR_PULL_ALLOC(ndr, r->name);
331                 } else {
332                         r->name = NULL;
333                 }
334                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
335         }
336         if (ndr_flags & NDR_BUFFERS) {
337                 if (r->name) {
338                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
339                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
341                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
342                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
343                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
344                         }
345                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t)));
346                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint8_t), CH_UTF8));
347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
348                 }
349         }
350         return NDR_ERR_SUCCESS;
351 }
352
353 _PUBLIC_ void ndr_print_wbint_Principal(struct ndr_print *ndr, const char *name, const struct wbint_Principal *r)
354 {
355         ndr_print_struct(ndr, name, "wbint_Principal");
356         ndr->depth++;
357         ndr_print_dom_sid(ndr, "sid", &r->sid);
358         ndr_print_lsa_SidType(ndr, "type", r->type);
359         ndr_print_ptr(ndr, "name", r->name);
360         ndr->depth++;
361         if (r->name) {
362                 ndr_print_string(ndr, "name", r->name);
363         }
364         ndr->depth--;
365         ndr->depth--;
366 }
367
368 _PUBLIC_ enum ndr_err_code ndr_push_wbint_Principals(struct ndr_push *ndr, int ndr_flags, const struct wbint_Principals *r)
369 {
370         uint32_t cntr_principals_0;
371         if (ndr_flags & NDR_SCALARS) {
372                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_principals));
373                 NDR_CHECK(ndr_push_align(ndr, 5));
374                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->num_principals));
375                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
376                         NDR_CHECK(ndr_push_wbint_Principal(ndr, NDR_SCALARS, &r->principals[cntr_principals_0]));
377                 }
378                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
379         }
380         if (ndr_flags & NDR_BUFFERS) {
381                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
382                         NDR_CHECK(ndr_push_wbint_Principal(ndr, NDR_BUFFERS, &r->principals[cntr_principals_0]));
383                 }
384         }
385         return NDR_ERR_SUCCESS;
386 }
387
388 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_Principals(struct ndr_pull *ndr, int ndr_flags, struct wbint_Principals *r)
389 {
390         uint32_t cntr_principals_0;
391         TALLOC_CTX *_mem_save_principals_0;
392         if (ndr_flags & NDR_SCALARS) {
393                 NDR_CHECK(ndr_pull_array_size(ndr, &r->principals));
394                 NDR_CHECK(ndr_pull_align(ndr, 5));
395                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->num_principals));
396                 NDR_PULL_ALLOC_N(ndr, r->principals, ndr_get_array_size(ndr, &r->principals));
397                 _mem_save_principals_0 = NDR_PULL_GET_MEM_CTX(ndr);
398                 NDR_PULL_SET_MEM_CTX(ndr, r->principals, 0);
399                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
400                         NDR_CHECK(ndr_pull_wbint_Principal(ndr, NDR_SCALARS, &r->principals[cntr_principals_0]));
401                 }
402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_principals_0, 0);
403                 if (r->principals) {
404                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->principals, r->num_principals));
405                 }
406                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
407         }
408         if (ndr_flags & NDR_BUFFERS) {
409                 _mem_save_principals_0 = NDR_PULL_GET_MEM_CTX(ndr);
410                 NDR_PULL_SET_MEM_CTX(ndr, r->principals, 0);
411                 for (cntr_principals_0 = 0; cntr_principals_0 < r->num_principals; cntr_principals_0++) {
412                         NDR_CHECK(ndr_pull_wbint_Principal(ndr, NDR_BUFFERS, &r->principals[cntr_principals_0]));
413                 }
414                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_principals_0, 0);
415         }
416         return NDR_ERR_SUCCESS;
417 }
418
419 _PUBLIC_ void ndr_print_wbint_Principals(struct ndr_print *ndr, const char *name, const struct wbint_Principals *r)
420 {
421         uint32_t cntr_principals_0;
422         ndr_print_struct(ndr, name, "wbint_Principals");
423         ndr->depth++;
424         ndr_print_int32(ndr, "num_principals", r->num_principals);
425         ndr->print(ndr, "%s: ARRAY(%d)", "principals", (int)r->num_principals);
426         ndr->depth++;
427         for (cntr_principals_0=0;cntr_principals_0<r->num_principals;cntr_principals_0++) {
428                 char *idx_0=NULL;
429                 if (asprintf(&idx_0, "[%d]", cntr_principals_0) != -1) {
430                         ndr_print_wbint_Principal(ndr, "principals", &r->principals[cntr_principals_0]);
431                         free(idx_0);
432                 }
433         }
434         ndr->depth--;
435         ndr->depth--;
436 }
437
438 _PUBLIC_ enum ndr_err_code ndr_push_wbint_userinfos(struct ndr_push *ndr, int ndr_flags, const struct wbint_userinfos *r)
439 {
440         uint32_t cntr_userinfos_0;
441         if (ndr_flags & NDR_SCALARS) {
442                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_userinfos));
443                 NDR_CHECK(ndr_push_align(ndr, 8));
444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_userinfos));
445                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
446                         NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_SCALARS, &r->userinfos[cntr_userinfos_0]));
447                 }
448                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
449         }
450         if (ndr_flags & NDR_BUFFERS) {
451                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
452                         NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_BUFFERS, &r->userinfos[cntr_userinfos_0]));
453                 }
454         }
455         return NDR_ERR_SUCCESS;
456 }
457
458 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_userinfos(struct ndr_pull *ndr, int ndr_flags, struct wbint_userinfos *r)
459 {
460         uint32_t cntr_userinfos_0;
461         TALLOC_CTX *_mem_save_userinfos_0;
462         if (ndr_flags & NDR_SCALARS) {
463                 NDR_CHECK(ndr_pull_array_size(ndr, &r->userinfos));
464                 NDR_CHECK(ndr_pull_align(ndr, 8));
465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_userinfos));
466                 NDR_PULL_ALLOC_N(ndr, r->userinfos, ndr_get_array_size(ndr, &r->userinfos));
467                 _mem_save_userinfos_0 = NDR_PULL_GET_MEM_CTX(ndr);
468                 NDR_PULL_SET_MEM_CTX(ndr, r->userinfos, 0);
469                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
470                         NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_SCALARS, &r->userinfos[cntr_userinfos_0]));
471                 }
472                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userinfos_0, 0);
473                 if (r->userinfos) {
474                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->userinfos, r->num_userinfos));
475                 }
476                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
477         }
478         if (ndr_flags & NDR_BUFFERS) {
479                 _mem_save_userinfos_0 = NDR_PULL_GET_MEM_CTX(ndr);
480                 NDR_PULL_SET_MEM_CTX(ndr, r->userinfos, 0);
481                 for (cntr_userinfos_0 = 0; cntr_userinfos_0 < r->num_userinfos; cntr_userinfos_0++) {
482                         NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_BUFFERS, &r->userinfos[cntr_userinfos_0]));
483                 }
484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userinfos_0, 0);
485         }
486         return NDR_ERR_SUCCESS;
487 }
488
489 _PUBLIC_ void ndr_print_wbint_userinfos(struct ndr_print *ndr, const char *name, const struct wbint_userinfos *r)
490 {
491         uint32_t cntr_userinfos_0;
492         ndr_print_struct(ndr, name, "wbint_userinfos");
493         ndr->depth++;
494         ndr_print_uint32(ndr, "num_userinfos", r->num_userinfos);
495         ndr->print(ndr, "%s: ARRAY(%d)", "userinfos", (int)r->num_userinfos);
496         ndr->depth++;
497         for (cntr_userinfos_0=0;cntr_userinfos_0<r->num_userinfos;cntr_userinfos_0++) {
498                 char *idx_0=NULL;
499                 if (asprintf(&idx_0, "[%d]", cntr_userinfos_0) != -1) {
500                         ndr_print_wbint_userinfo(ndr, "userinfos", &r->userinfos[cntr_userinfos_0]);
501                         free(idx_0);
502                 }
503         }
504         ndr->depth--;
505         ndr->depth--;
506 }
507
508 _PUBLIC_ enum ndr_err_code ndr_push_wbint_IdType(struct ndr_push *ndr, int ndr_flags, enum wbint_IdType r)
509 {
510         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
511         return NDR_ERR_SUCCESS;
512 }
513
514 _PUBLIC_ enum ndr_err_code ndr_pull_wbint_IdType(struct ndr_pull *ndr, int ndr_flags, enum wbint_IdType *r)
515 {
516         uint16_t v;
517         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
518         *r = v;
519         return NDR_ERR_SUCCESS;
520 }
521
522 _PUBLIC_ void ndr_print_wbint_IdType(struct ndr_print *ndr, const char *name, enum wbint_IdType r)
523 {
524         const char *val = NULL;
525
526         switch (r) {
527                 case WBINT_ID_TYPE_NOT_SPECIFIED: val = "WBINT_ID_TYPE_NOT_SPECIFIED"; break;
528                 case WBINT_ID_TYPE_UID: val = "WBINT_ID_TYPE_UID"; break;
529                 case WBINT_ID_TYPE_GID: val = "WBINT_ID_TYPE_GID"; break;
530         }
531         ndr_print_enum(ndr, name, "ENUM", val, r);
532 }
533
534 static enum ndr_err_code ndr_push_wbint_Ping(struct ndr_push *ndr, int flags, const struct wbint_Ping *r)
535 {
536         if (flags & NDR_IN) {
537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data));
538         }
539         if (flags & NDR_OUT) {
540                 if (r->out.out_data == NULL) {
541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
542                 }
543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.out_data));
544         }
545         return NDR_ERR_SUCCESS;
546 }
547
548 static enum ndr_err_code ndr_pull_wbint_Ping(struct ndr_pull *ndr, int flags, struct wbint_Ping *r)
549 {
550         TALLOC_CTX *_mem_save_out_data_0;
551         if (flags & NDR_IN) {
552                 ZERO_STRUCT(r->out);
553
554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.in_data));
555                 NDR_PULL_ALLOC(ndr, r->out.out_data);
556                 ZERO_STRUCTP(r->out.out_data);
557         }
558         if (flags & NDR_OUT) {
559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
560                         NDR_PULL_ALLOC(ndr, r->out.out_data);
561                 }
562                 _mem_save_out_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
563                 NDR_PULL_SET_MEM_CTX(ndr, r->out.out_data, LIBNDR_FLAG_REF_ALLOC);
564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.out_data));
565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_out_data_0, LIBNDR_FLAG_REF_ALLOC);
566         }
567         return NDR_ERR_SUCCESS;
568 }
569
570 _PUBLIC_ void ndr_print_wbint_Ping(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Ping *r)
571 {
572         ndr_print_struct(ndr, name, "wbint_Ping");
573         ndr->depth++;
574         if (flags & NDR_SET_VALUES) {
575                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
576         }
577         if (flags & NDR_IN) {
578                 ndr_print_struct(ndr, "in", "wbint_Ping");
579                 ndr->depth++;
580                 ndr_print_uint32(ndr, "in_data", r->in.in_data);
581                 ndr->depth--;
582         }
583         if (flags & NDR_OUT) {
584                 ndr_print_struct(ndr, "out", "wbint_Ping");
585                 ndr->depth++;
586                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
587                 ndr->depth++;
588                 ndr_print_uint32(ndr, "out_data", *r->out.out_data);
589                 ndr->depth--;
590                 ndr->depth--;
591         }
592         ndr->depth--;
593 }
594
595 static enum ndr_err_code ndr_push_wbint_LookupSid(struct ndr_push *ndr, int flags, const struct wbint_LookupSid *r)
596 {
597         if (flags & NDR_IN) {
598                 if (r->in.sid == NULL) {
599                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
600                 }
601                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
602         }
603         if (flags & NDR_OUT) {
604                 if (r->out.type == NULL) {
605                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
606                 }
607                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, *r->out.type));
608                 if (r->out.domain == NULL) {
609                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
610                 }
611                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domain));
612                 if (*r->out.domain) {
613                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
614                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
615                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.domain, CH_UTF8)));
616                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.domain, ndr_charset_length(*r->out.domain, CH_UTF8), sizeof(uint8_t), CH_UTF8));
617                 }
618                 if (r->out.name == NULL) {
619                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
620                 }
621                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name));
622                 if (*r->out.name) {
623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
625                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name, CH_UTF8)));
626                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.name, ndr_charset_length(*r->out.name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
627                 }
628                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
629         }
630         return NDR_ERR_SUCCESS;
631 }
632
633 static enum ndr_err_code ndr_pull_wbint_LookupSid(struct ndr_pull *ndr, int flags, struct wbint_LookupSid *r)
634 {
635         uint32_t _ptr_domain;
636         uint32_t _ptr_name;
637         TALLOC_CTX *_mem_save_sid_0;
638         TALLOC_CTX *_mem_save_type_0;
639         TALLOC_CTX *_mem_save_domain_0;
640         TALLOC_CTX *_mem_save_domain_1;
641         TALLOC_CTX *_mem_save_name_0;
642         TALLOC_CTX *_mem_save_name_1;
643         if (flags & NDR_IN) {
644                 ZERO_STRUCT(r->out);
645
646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
647                         NDR_PULL_ALLOC(ndr, r->in.sid);
648                 }
649                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
650                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
651                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
653                 NDR_PULL_ALLOC(ndr, r->out.type);
654                 ZERO_STRUCTP(r->out.type);
655                 NDR_PULL_ALLOC(ndr, r->out.domain);
656                 ZERO_STRUCTP(r->out.domain);
657                 NDR_PULL_ALLOC(ndr, r->out.name);
658                 ZERO_STRUCTP(r->out.name);
659         }
660         if (flags & NDR_OUT) {
661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
662                         NDR_PULL_ALLOC(ndr, r->out.type);
663                 }
664                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
665                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
666                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, r->out.type));
667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
669                         NDR_PULL_ALLOC(ndr, r->out.domain);
670                 }
671                 _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
672                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domain, LIBNDR_FLAG_REF_ALLOC);
673                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
674                 if (_ptr_domain) {
675                         NDR_PULL_ALLOC(ndr, *r->out.domain);
676                 } else {
677                         *r->out.domain = NULL;
678                 }
679                 if (*r->out.domain) {
680                         _mem_save_domain_1 = NDR_PULL_GET_MEM_CTX(ndr);
681                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domain, 0);
682                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.domain));
683                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.domain));
684                         if (ndr_get_array_length(ndr, r->out.domain) > ndr_get_array_size(ndr, r->out.domain)) {
685                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.domain), ndr_get_array_length(ndr, r->out.domain));
686                         }
687                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.domain), sizeof(uint8_t)));
688                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.domain, ndr_get_array_length(ndr, r->out.domain), sizeof(uint8_t), CH_UTF8));
689                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_1, 0);
690                 }
691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, LIBNDR_FLAG_REF_ALLOC);
692                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
693                         NDR_PULL_ALLOC(ndr, r->out.name);
694                 }
695                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
696                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
697                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
698                 if (_ptr_name) {
699                         NDR_PULL_ALLOC(ndr, *r->out.name);
700                 } else {
701                         *r->out.name = NULL;
702                 }
703                 if (*r->out.name) {
704                         _mem_save_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
705                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name, 0);
706                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.name));
707                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.name));
708                         if (ndr_get_array_length(ndr, r->out.name) > ndr_get_array_size(ndr, r->out.name)) {
709                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.name), ndr_get_array_length(ndr, r->out.name));
710                         }
711                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name), sizeof(uint8_t)));
712                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.name, ndr_get_array_length(ndr, r->out.name), sizeof(uint8_t), CH_UTF8));
713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_1, 0);
714                 }
715                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
716                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
717         }
718         return NDR_ERR_SUCCESS;
719 }
720
721 _PUBLIC_ void ndr_print_wbint_LookupSid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupSid *r)
722 {
723         ndr_print_struct(ndr, name, "wbint_LookupSid");
724         ndr->depth++;
725         if (flags & NDR_SET_VALUES) {
726                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
727         }
728         if (flags & NDR_IN) {
729                 ndr_print_struct(ndr, "in", "wbint_LookupSid");
730                 ndr->depth++;
731                 ndr_print_ptr(ndr, "sid", r->in.sid);
732                 ndr->depth++;
733                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
734                 ndr->depth--;
735                 ndr->depth--;
736         }
737         if (flags & NDR_OUT) {
738                 ndr_print_struct(ndr, "out", "wbint_LookupSid");
739                 ndr->depth++;
740                 ndr_print_ptr(ndr, "type", r->out.type);
741                 ndr->depth++;
742                 ndr_print_lsa_SidType(ndr, "type", *r->out.type);
743                 ndr->depth--;
744                 ndr_print_ptr(ndr, "domain", r->out.domain);
745                 ndr->depth++;
746                 ndr_print_ptr(ndr, "domain", *r->out.domain);
747                 ndr->depth++;
748                 if (*r->out.domain) {
749                         ndr_print_string(ndr, "domain", *r->out.domain);
750                 }
751                 ndr->depth--;
752                 ndr->depth--;
753                 ndr_print_ptr(ndr, "name", r->out.name);
754                 ndr->depth++;
755                 ndr_print_ptr(ndr, "name", *r->out.name);
756                 ndr->depth++;
757                 if (*r->out.name) {
758                         ndr_print_string(ndr, "name", *r->out.name);
759                 }
760                 ndr->depth--;
761                 ndr->depth--;
762                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
763                 ndr->depth--;
764         }
765         ndr->depth--;
766 }
767
768 static enum ndr_err_code ndr_push_wbint_LookupName(struct ndr_push *ndr, int flags, const struct wbint_LookupName *r)
769 {
770         if (flags & NDR_IN) {
771                 if (r->in.domain == NULL) {
772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
773                 }
774                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
775                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
776                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain, CH_UTF8)));
777                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain, ndr_charset_length(r->in.domain, CH_UTF8), sizeof(uint8_t), CH_UTF8));
778                 if (r->in.name == NULL) {
779                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
780                 }
781                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
782                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
783                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF8)));
784                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
786         }
787         if (flags & NDR_OUT) {
788                 if (r->out.type == NULL) {
789                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
790                 }
791                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, *r->out.type));
792                 if (r->out.sid == NULL) {
793                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
794                 }
795                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
796                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
797         }
798         return NDR_ERR_SUCCESS;
799 }
800
801 static enum ndr_err_code ndr_pull_wbint_LookupName(struct ndr_pull *ndr, int flags, struct wbint_LookupName *r)
802 {
803         TALLOC_CTX *_mem_save_type_0;
804         TALLOC_CTX *_mem_save_sid_0;
805         if (flags & NDR_IN) {
806                 ZERO_STRUCT(r->out);
807
808                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain));
809                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain));
810                 if (ndr_get_array_length(ndr, &r->in.domain) > ndr_get_array_size(ndr, &r->in.domain)) {
811                         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.domain), ndr_get_array_length(ndr, &r->in.domain));
812                 }
813                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain), sizeof(uint8_t)));
814                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain, ndr_get_array_length(ndr, &r->in.domain), sizeof(uint8_t), CH_UTF8));
815                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
816                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
817                 if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {
818                         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.name), ndr_get_array_length(ndr, &r->in.name));
819                 }
820                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint8_t)));
821                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint8_t), CH_UTF8));
822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
823                 NDR_PULL_ALLOC(ndr, r->out.type);
824                 ZERO_STRUCTP(r->out.type);
825                 NDR_PULL_ALLOC(ndr, r->out.sid);
826                 ZERO_STRUCTP(r->out.sid);
827         }
828         if (flags & NDR_OUT) {
829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
830                         NDR_PULL_ALLOC(ndr, r->out.type);
831                 }
832                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
833                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
834                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, r->out.type));
835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
836                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
837                         NDR_PULL_ALLOC(ndr, r->out.sid);
838                 }
839                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
840                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
841                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
842                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
843                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
844         }
845         return NDR_ERR_SUCCESS;
846 }
847
848 _PUBLIC_ void ndr_print_wbint_LookupName(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupName *r)
849 {
850         ndr_print_struct(ndr, name, "wbint_LookupName");
851         ndr->depth++;
852         if (flags & NDR_SET_VALUES) {
853                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
854         }
855         if (flags & NDR_IN) {
856                 ndr_print_struct(ndr, "in", "wbint_LookupName");
857                 ndr->depth++;
858                 ndr_print_ptr(ndr, "domain", r->in.domain);
859                 ndr->depth++;
860                 ndr_print_string(ndr, "domain", r->in.domain);
861                 ndr->depth--;
862                 ndr_print_ptr(ndr, "name", r->in.name);
863                 ndr->depth++;
864                 ndr_print_string(ndr, "name", r->in.name);
865                 ndr->depth--;
866                 ndr_print_uint32(ndr, "flags", r->in.flags);
867                 ndr->depth--;
868         }
869         if (flags & NDR_OUT) {
870                 ndr_print_struct(ndr, "out", "wbint_LookupName");
871                 ndr->depth++;
872                 ndr_print_ptr(ndr, "type", r->out.type);
873                 ndr->depth++;
874                 ndr_print_lsa_SidType(ndr, "type", *r->out.type);
875                 ndr->depth--;
876                 ndr_print_ptr(ndr, "sid", r->out.sid);
877                 ndr->depth++;
878                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
879                 ndr->depth--;
880                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
881                 ndr->depth--;
882         }
883         ndr->depth--;
884 }
885
886 static enum ndr_err_code ndr_push_wbint_Sid2Uid(struct ndr_push *ndr, int flags, const struct wbint_Sid2Uid *r)
887 {
888         if (flags & NDR_IN) {
889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
890                 if (r->in.dom_name) {
891                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
892                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
893                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
894                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
895                 }
896                 if (r->in.sid == NULL) {
897                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
898                 }
899                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
900         }
901         if (flags & NDR_OUT) {
902                 if (r->out.uid == NULL) {
903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
904                 }
905                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.uid));
906                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
907         }
908         return NDR_ERR_SUCCESS;
909 }
910
911 static enum ndr_err_code ndr_pull_wbint_Sid2Uid(struct ndr_pull *ndr, int flags, struct wbint_Sid2Uid *r)
912 {
913         uint32_t _ptr_dom_name;
914         TALLOC_CTX *_mem_save_dom_name_0;
915         TALLOC_CTX *_mem_save_sid_0;
916         TALLOC_CTX *_mem_save_uid_0;
917         if (flags & NDR_IN) {
918                 ZERO_STRUCT(r->out);
919
920                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
921                 if (_ptr_dom_name) {
922                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
923                 } else {
924                         r->in.dom_name = NULL;
925                 }
926                 if (r->in.dom_name) {
927                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
928                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
929                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
930                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
931                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
932                                 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.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
933                         }
934                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
935                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
937                 }
938                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
939                         NDR_PULL_ALLOC(ndr, r->in.sid);
940                 }
941                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
942                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
943                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
944                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
945                 NDR_PULL_ALLOC(ndr, r->out.uid);
946                 ZERO_STRUCTP(r->out.uid);
947         }
948         if (flags & NDR_OUT) {
949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
950                         NDR_PULL_ALLOC(ndr, r->out.uid);
951                 }
952                 _mem_save_uid_0 = NDR_PULL_GET_MEM_CTX(ndr);
953                 NDR_PULL_SET_MEM_CTX(ndr, r->out.uid, LIBNDR_FLAG_REF_ALLOC);
954                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.uid));
955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uid_0, LIBNDR_FLAG_REF_ALLOC);
956                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
957         }
958         return NDR_ERR_SUCCESS;
959 }
960
961 _PUBLIC_ void ndr_print_wbint_Sid2Uid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Sid2Uid *r)
962 {
963         ndr_print_struct(ndr, name, "wbint_Sid2Uid");
964         ndr->depth++;
965         if (flags & NDR_SET_VALUES) {
966                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
967         }
968         if (flags & NDR_IN) {
969                 ndr_print_struct(ndr, "in", "wbint_Sid2Uid");
970                 ndr->depth++;
971                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
972                 ndr->depth++;
973                 if (r->in.dom_name) {
974                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
975                 }
976                 ndr->depth--;
977                 ndr_print_ptr(ndr, "sid", r->in.sid);
978                 ndr->depth++;
979                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
980                 ndr->depth--;
981                 ndr->depth--;
982         }
983         if (flags & NDR_OUT) {
984                 ndr_print_struct(ndr, "out", "wbint_Sid2Uid");
985                 ndr->depth++;
986                 ndr_print_ptr(ndr, "uid", r->out.uid);
987                 ndr->depth++;
988                 ndr_print_hyper(ndr, "uid", *r->out.uid);
989                 ndr->depth--;
990                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
991                 ndr->depth--;
992         }
993         ndr->depth--;
994 }
995
996 static enum ndr_err_code ndr_push_wbint_Sid2Gid(struct ndr_push *ndr, int flags, const struct wbint_Sid2Gid *r)
997 {
998         if (flags & NDR_IN) {
999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
1000                 if (r->in.dom_name) {
1001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1002                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1004                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1005                 }
1006                 if (r->in.sid == NULL) {
1007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1008                 }
1009                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1010         }
1011         if (flags & NDR_OUT) {
1012                 if (r->out.gid == NULL) {
1013                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1014                 }
1015                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.gid));
1016                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1017         }
1018         return NDR_ERR_SUCCESS;
1019 }
1020
1021 static enum ndr_err_code ndr_pull_wbint_Sid2Gid(struct ndr_pull *ndr, int flags, struct wbint_Sid2Gid *r)
1022 {
1023         uint32_t _ptr_dom_name;
1024         TALLOC_CTX *_mem_save_dom_name_0;
1025         TALLOC_CTX *_mem_save_sid_0;
1026         TALLOC_CTX *_mem_save_gid_0;
1027         if (flags & NDR_IN) {
1028                 ZERO_STRUCT(r->out);
1029
1030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
1031                 if (_ptr_dom_name) {
1032                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
1033                 } else {
1034                         r->in.dom_name = NULL;
1035                 }
1036                 if (r->in.dom_name) {
1037                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1038                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1039                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1040                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1041                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1042                                 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.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1043                         }
1044                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1045                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1047                 }
1048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1049                         NDR_PULL_ALLOC(ndr, r->in.sid);
1050                 }
1051                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1052                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1053                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1055                 NDR_PULL_ALLOC(ndr, r->out.gid);
1056                 ZERO_STRUCTP(r->out.gid);
1057         }
1058         if (flags & NDR_OUT) {
1059                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1060                         NDR_PULL_ALLOC(ndr, r->out.gid);
1061                 }
1062                 _mem_save_gid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1063                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gid, LIBNDR_FLAG_REF_ALLOC);
1064                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.gid));
1065                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gid_0, LIBNDR_FLAG_REF_ALLOC);
1066                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1067         }
1068         return NDR_ERR_SUCCESS;
1069 }
1070
1071 _PUBLIC_ void ndr_print_wbint_Sid2Gid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Sid2Gid *r)
1072 {
1073         ndr_print_struct(ndr, name, "wbint_Sid2Gid");
1074         ndr->depth++;
1075         if (flags & NDR_SET_VALUES) {
1076                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1077         }
1078         if (flags & NDR_IN) {
1079                 ndr_print_struct(ndr, "in", "wbint_Sid2Gid");
1080                 ndr->depth++;
1081                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1082                 ndr->depth++;
1083                 if (r->in.dom_name) {
1084                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1085                 }
1086                 ndr->depth--;
1087                 ndr_print_ptr(ndr, "sid", r->in.sid);
1088                 ndr->depth++;
1089                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1090                 ndr->depth--;
1091                 ndr->depth--;
1092         }
1093         if (flags & NDR_OUT) {
1094                 ndr_print_struct(ndr, "out", "wbint_Sid2Gid");
1095                 ndr->depth++;
1096                 ndr_print_ptr(ndr, "gid", r->out.gid);
1097                 ndr->depth++;
1098                 ndr_print_hyper(ndr, "gid", *r->out.gid);
1099                 ndr->depth--;
1100                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1101                 ndr->depth--;
1102         }
1103         ndr->depth--;
1104 }
1105
1106 static enum ndr_err_code ndr_push_wbint_Uid2Sid(struct ndr_push *ndr, int flags, const struct wbint_Uid2Sid *r)
1107 {
1108         if (flags & NDR_IN) {
1109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
1110                 if (r->in.dom_name) {
1111                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1112                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1115                 }
1116                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.uid));
1117         }
1118         if (flags & NDR_OUT) {
1119                 if (r->out.sid == NULL) {
1120                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1121                 }
1122                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1123                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1124         }
1125         return NDR_ERR_SUCCESS;
1126 }
1127
1128 static enum ndr_err_code ndr_pull_wbint_Uid2Sid(struct ndr_pull *ndr, int flags, struct wbint_Uid2Sid *r)
1129 {
1130         uint32_t _ptr_dom_name;
1131         TALLOC_CTX *_mem_save_dom_name_0;
1132         TALLOC_CTX *_mem_save_sid_0;
1133         if (flags & NDR_IN) {
1134                 ZERO_STRUCT(r->out);
1135
1136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
1137                 if (_ptr_dom_name) {
1138                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
1139                 } else {
1140                         r->in.dom_name = NULL;
1141                 }
1142                 if (r->in.dom_name) {
1143                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1144                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1145                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1146                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1147                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1148                                 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.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1149                         }
1150                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1151                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1153                 }
1154                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.uid));
1155                 NDR_PULL_ALLOC(ndr, r->out.sid);
1156                 ZERO_STRUCTP(r->out.sid);
1157         }
1158         if (flags & NDR_OUT) {
1159                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1160                         NDR_PULL_ALLOC(ndr, r->out.sid);
1161                 }
1162                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1163                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
1164                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1166                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1167         }
1168         return NDR_ERR_SUCCESS;
1169 }
1170
1171 _PUBLIC_ void ndr_print_wbint_Uid2Sid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Uid2Sid *r)
1172 {
1173         ndr_print_struct(ndr, name, "wbint_Uid2Sid");
1174         ndr->depth++;
1175         if (flags & NDR_SET_VALUES) {
1176                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1177         }
1178         if (flags & NDR_IN) {
1179                 ndr_print_struct(ndr, "in", "wbint_Uid2Sid");
1180                 ndr->depth++;
1181                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1182                 ndr->depth++;
1183                 if (r->in.dom_name) {
1184                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1185                 }
1186                 ndr->depth--;
1187                 ndr_print_hyper(ndr, "uid", r->in.uid);
1188                 ndr->depth--;
1189         }
1190         if (flags & NDR_OUT) {
1191                 ndr_print_struct(ndr, "out", "wbint_Uid2Sid");
1192                 ndr->depth++;
1193                 ndr_print_ptr(ndr, "sid", r->out.sid);
1194                 ndr->depth++;
1195                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
1196                 ndr->depth--;
1197                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1198                 ndr->depth--;
1199         }
1200         ndr->depth--;
1201 }
1202
1203 static enum ndr_err_code ndr_push_wbint_Gid2Sid(struct ndr_push *ndr, int flags, const struct wbint_Gid2Sid *r)
1204 {
1205         if (flags & NDR_IN) {
1206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dom_name));
1207                 if (r->in.dom_name) {
1208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dom_name, CH_UTF8)));
1211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dom_name, ndr_charset_length(r->in.dom_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1212                 }
1213                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.gid));
1214         }
1215         if (flags & NDR_OUT) {
1216                 if (r->out.sid == NULL) {
1217                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1218                 }
1219                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1220                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1221         }
1222         return NDR_ERR_SUCCESS;
1223 }
1224
1225 static enum ndr_err_code ndr_pull_wbint_Gid2Sid(struct ndr_pull *ndr, int flags, struct wbint_Gid2Sid *r)
1226 {
1227         uint32_t _ptr_dom_name;
1228         TALLOC_CTX *_mem_save_dom_name_0;
1229         TALLOC_CTX *_mem_save_sid_0;
1230         if (flags & NDR_IN) {
1231                 ZERO_STRUCT(r->out);
1232
1233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dom_name));
1234                 if (_ptr_dom_name) {
1235                         NDR_PULL_ALLOC(ndr, r->in.dom_name);
1236                 } else {
1237                         r->in.dom_name = NULL;
1238                 }
1239                 if (r->in.dom_name) {
1240                         _mem_save_dom_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1241                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_name, 0);
1242                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dom_name));
1243                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dom_name));
1244                         if (ndr_get_array_length(ndr, &r->in.dom_name) > ndr_get_array_size(ndr, &r->in.dom_name)) {
1245                                 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.dom_name), ndr_get_array_length(ndr, &r->in.dom_name));
1246                         }
1247                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t)));
1248                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dom_name, ndr_get_array_length(ndr, &r->in.dom_name), sizeof(uint8_t), CH_UTF8));
1249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_name_0, 0);
1250                 }
1251                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.gid));
1252                 NDR_PULL_ALLOC(ndr, r->out.sid);
1253                 ZERO_STRUCTP(r->out.sid);
1254         }
1255         if (flags & NDR_OUT) {
1256                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1257                         NDR_PULL_ALLOC(ndr, r->out.sid);
1258                 }
1259                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1260                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);
1261                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->out.sid));
1262                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1263                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1264         }
1265         return NDR_ERR_SUCCESS;
1266 }
1267
1268 _PUBLIC_ void ndr_print_wbint_Gid2Sid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_Gid2Sid *r)
1269 {
1270         ndr_print_struct(ndr, name, "wbint_Gid2Sid");
1271         ndr->depth++;
1272         if (flags & NDR_SET_VALUES) {
1273                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1274         }
1275         if (flags & NDR_IN) {
1276                 ndr_print_struct(ndr, "in", "wbint_Gid2Sid");
1277                 ndr->depth++;
1278                 ndr_print_ptr(ndr, "dom_name", r->in.dom_name);
1279                 ndr->depth++;
1280                 if (r->in.dom_name) {
1281                         ndr_print_string(ndr, "dom_name", r->in.dom_name);
1282                 }
1283                 ndr->depth--;
1284                 ndr_print_hyper(ndr, "gid", r->in.gid);
1285                 ndr->depth--;
1286         }
1287         if (flags & NDR_OUT) {
1288                 ndr_print_struct(ndr, "out", "wbint_Gid2Sid");
1289                 ndr->depth++;
1290                 ndr_print_ptr(ndr, "sid", r->out.sid);
1291                 ndr->depth++;
1292                 ndr_print_dom_sid(ndr, "sid", r->out.sid);
1293                 ndr->depth--;
1294                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1295                 ndr->depth--;
1296         }
1297         ndr->depth--;
1298 }
1299
1300 static enum ndr_err_code ndr_push_wbint_AllocateUid(struct ndr_push *ndr, int flags, const struct wbint_AllocateUid *r)
1301 {
1302         if (flags & NDR_IN) {
1303         }
1304         if (flags & NDR_OUT) {
1305                 if (r->out.uid == NULL) {
1306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1307                 }
1308                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.uid));
1309                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1310         }
1311         return NDR_ERR_SUCCESS;
1312 }
1313
1314 static enum ndr_err_code ndr_pull_wbint_AllocateUid(struct ndr_pull *ndr, int flags, struct wbint_AllocateUid *r)
1315 {
1316         TALLOC_CTX *_mem_save_uid_0;
1317         if (flags & NDR_IN) {
1318                 ZERO_STRUCT(r->out);
1319
1320                 NDR_PULL_ALLOC(ndr, r->out.uid);
1321                 ZERO_STRUCTP(r->out.uid);
1322         }
1323         if (flags & NDR_OUT) {
1324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1325                         NDR_PULL_ALLOC(ndr, r->out.uid);
1326                 }
1327                 _mem_save_uid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1328                 NDR_PULL_SET_MEM_CTX(ndr, r->out.uid, LIBNDR_FLAG_REF_ALLOC);
1329                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.uid));
1330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uid_0, LIBNDR_FLAG_REF_ALLOC);
1331                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1332         }
1333         return NDR_ERR_SUCCESS;
1334 }
1335
1336 _PUBLIC_ void ndr_print_wbint_AllocateUid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_AllocateUid *r)
1337 {
1338         ndr_print_struct(ndr, name, "wbint_AllocateUid");
1339         ndr->depth++;
1340         if (flags & NDR_SET_VALUES) {
1341                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1342         }
1343         if (flags & NDR_IN) {
1344                 ndr_print_struct(ndr, "in", "wbint_AllocateUid");
1345                 ndr->depth++;
1346                 ndr->depth--;
1347         }
1348         if (flags & NDR_OUT) {
1349                 ndr_print_struct(ndr, "out", "wbint_AllocateUid");
1350                 ndr->depth++;
1351                 ndr_print_ptr(ndr, "uid", r->out.uid);
1352                 ndr->depth++;
1353                 ndr_print_hyper(ndr, "uid", *r->out.uid);
1354                 ndr->depth--;
1355                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1356                 ndr->depth--;
1357         }
1358         ndr->depth--;
1359 }
1360
1361 static enum ndr_err_code ndr_push_wbint_AllocateGid(struct ndr_push *ndr, int flags, const struct wbint_AllocateGid *r)
1362 {
1363         if (flags & NDR_IN) {
1364         }
1365         if (flags & NDR_OUT) {
1366                 if (r->out.gid == NULL) {
1367                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1368                 }
1369                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.gid));
1370                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1371         }
1372         return NDR_ERR_SUCCESS;
1373 }
1374
1375 static enum ndr_err_code ndr_pull_wbint_AllocateGid(struct ndr_pull *ndr, int flags, struct wbint_AllocateGid *r)
1376 {
1377         TALLOC_CTX *_mem_save_gid_0;
1378         if (flags & NDR_IN) {
1379                 ZERO_STRUCT(r->out);
1380
1381                 NDR_PULL_ALLOC(ndr, r->out.gid);
1382                 ZERO_STRUCTP(r->out.gid);
1383         }
1384         if (flags & NDR_OUT) {
1385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1386                         NDR_PULL_ALLOC(ndr, r->out.gid);
1387                 }
1388                 _mem_save_gid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gid, LIBNDR_FLAG_REF_ALLOC);
1390                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.gid));
1391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gid_0, LIBNDR_FLAG_REF_ALLOC);
1392                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1393         }
1394         return NDR_ERR_SUCCESS;
1395 }
1396
1397 _PUBLIC_ void ndr_print_wbint_AllocateGid(struct ndr_print *ndr, const char *name, int flags, const struct wbint_AllocateGid *r)
1398 {
1399         ndr_print_struct(ndr, name, "wbint_AllocateGid");
1400         ndr->depth++;
1401         if (flags & NDR_SET_VALUES) {
1402                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1403         }
1404         if (flags & NDR_IN) {
1405                 ndr_print_struct(ndr, "in", "wbint_AllocateGid");
1406                 ndr->depth++;
1407                 ndr->depth--;
1408         }
1409         if (flags & NDR_OUT) {
1410                 ndr_print_struct(ndr, "out", "wbint_AllocateGid");
1411                 ndr->depth++;
1412                 ndr_print_ptr(ndr, "gid", r->out.gid);
1413                 ndr->depth++;
1414                 ndr_print_hyper(ndr, "gid", *r->out.gid);
1415                 ndr->depth--;
1416                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1417                 ndr->depth--;
1418         }
1419         ndr->depth--;
1420 }
1421
1422 static enum ndr_err_code ndr_push_wbint_QueryUser(struct ndr_push *ndr, int flags, const struct wbint_QueryUser *r)
1423 {
1424         if (flags & NDR_IN) {
1425                 if (r->in.sid == NULL) {
1426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1427                 }
1428                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1429         }
1430         if (flags & NDR_OUT) {
1431                 if (r->out.info == NULL) {
1432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1433                 }
1434                 NDR_CHECK(ndr_push_wbint_userinfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
1435                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1436         }
1437         return NDR_ERR_SUCCESS;
1438 }
1439
1440 static enum ndr_err_code ndr_pull_wbint_QueryUser(struct ndr_pull *ndr, int flags, struct wbint_QueryUser *r)
1441 {
1442         TALLOC_CTX *_mem_save_sid_0;
1443         TALLOC_CTX *_mem_save_info_0;
1444         if (flags & NDR_IN) {
1445                 ZERO_STRUCT(r->out);
1446
1447                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1448                         NDR_PULL_ALLOC(ndr, r->in.sid);
1449                 }
1450                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1451                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1452                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1454                 NDR_PULL_ALLOC(ndr, r->out.info);
1455                 ZERO_STRUCTP(r->out.info);
1456         }
1457         if (flags & NDR_OUT) {
1458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1459                         NDR_PULL_ALLOC(ndr, r->out.info);
1460                 }
1461                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1462                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
1463                 NDR_CHECK(ndr_pull_wbint_userinfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
1464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
1465                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1466         }
1467         return NDR_ERR_SUCCESS;
1468 }
1469
1470 _PUBLIC_ void ndr_print_wbint_QueryUser(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QueryUser *r)
1471 {
1472         ndr_print_struct(ndr, name, "wbint_QueryUser");
1473         ndr->depth++;
1474         if (flags & NDR_SET_VALUES) {
1475                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1476         }
1477         if (flags & NDR_IN) {
1478                 ndr_print_struct(ndr, "in", "wbint_QueryUser");
1479                 ndr->depth++;
1480                 ndr_print_ptr(ndr, "sid", r->in.sid);
1481                 ndr->depth++;
1482                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1483                 ndr->depth--;
1484                 ndr->depth--;
1485         }
1486         if (flags & NDR_OUT) {
1487                 ndr_print_struct(ndr, "out", "wbint_QueryUser");
1488                 ndr->depth++;
1489                 ndr_print_ptr(ndr, "info", r->out.info);
1490                 ndr->depth++;
1491                 ndr_print_wbint_userinfo(ndr, "info", r->out.info);
1492                 ndr->depth--;
1493                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1494                 ndr->depth--;
1495         }
1496         ndr->depth--;
1497 }
1498
1499 static enum ndr_err_code ndr_push_wbint_LookupUserAliases(struct ndr_push *ndr, int flags, const struct wbint_LookupUserAliases *r)
1500 {
1501         if (flags & NDR_IN) {
1502                 if (r->in.sids == NULL) {
1503                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1504                 }
1505                 NDR_CHECK(ndr_push_wbint_SidArray(ndr, NDR_SCALARS, r->in.sids));
1506         }
1507         if (flags & NDR_OUT) {
1508                 if (r->out.rids == NULL) {
1509                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1510                 }
1511                 NDR_CHECK(ndr_push_wbint_RidArray(ndr, NDR_SCALARS, r->out.rids));
1512                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1513         }
1514         return NDR_ERR_SUCCESS;
1515 }
1516
1517 static enum ndr_err_code ndr_pull_wbint_LookupUserAliases(struct ndr_pull *ndr, int flags, struct wbint_LookupUserAliases *r)
1518 {
1519         TALLOC_CTX *_mem_save_sids_0;
1520         TALLOC_CTX *_mem_save_rids_0;
1521         if (flags & NDR_IN) {
1522                 ZERO_STRUCT(r->out);
1523
1524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1525                         NDR_PULL_ALLOC(ndr, r->in.sids);
1526                 }
1527                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1528                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
1529                 NDR_CHECK(ndr_pull_wbint_SidArray(ndr, NDR_SCALARS, r->in.sids));
1530                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
1531                 NDR_PULL_ALLOC(ndr, r->out.rids);
1532                 ZERO_STRUCTP(r->out.rids);
1533         }
1534         if (flags & NDR_OUT) {
1535                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1536                         NDR_PULL_ALLOC(ndr, r->out.rids);
1537                 }
1538                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1539                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);
1540                 NDR_CHECK(ndr_pull_wbint_RidArray(ndr, NDR_SCALARS, r->out.rids));
1541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
1542                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1543         }
1544         return NDR_ERR_SUCCESS;
1545 }
1546
1547 _PUBLIC_ void ndr_print_wbint_LookupUserAliases(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupUserAliases *r)
1548 {
1549         ndr_print_struct(ndr, name, "wbint_LookupUserAliases");
1550         ndr->depth++;
1551         if (flags & NDR_SET_VALUES) {
1552                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1553         }
1554         if (flags & NDR_IN) {
1555                 ndr_print_struct(ndr, "in", "wbint_LookupUserAliases");
1556                 ndr->depth++;
1557                 ndr_print_ptr(ndr, "sids", r->in.sids);
1558                 ndr->depth++;
1559                 ndr_print_wbint_SidArray(ndr, "sids", r->in.sids);
1560                 ndr->depth--;
1561                 ndr->depth--;
1562         }
1563         if (flags & NDR_OUT) {
1564                 ndr_print_struct(ndr, "out", "wbint_LookupUserAliases");
1565                 ndr->depth++;
1566                 ndr_print_ptr(ndr, "rids", r->out.rids);
1567                 ndr->depth++;
1568                 ndr_print_wbint_RidArray(ndr, "rids", r->out.rids);
1569                 ndr->depth--;
1570                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1571                 ndr->depth--;
1572         }
1573         ndr->depth--;
1574 }
1575
1576 static enum ndr_err_code ndr_push_wbint_LookupUserGroups(struct ndr_push *ndr, int flags, const struct wbint_LookupUserGroups *r)
1577 {
1578         if (flags & NDR_IN) {
1579                 if (r->in.sid == NULL) {
1580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1581                 }
1582                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1583         }
1584         if (flags & NDR_OUT) {
1585                 if (r->out.sids == NULL) {
1586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1587                 }
1588                 NDR_CHECK(ndr_push_wbint_SidArray(ndr, NDR_SCALARS, r->out.sids));
1589                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1590         }
1591         return NDR_ERR_SUCCESS;
1592 }
1593
1594 static enum ndr_err_code ndr_pull_wbint_LookupUserGroups(struct ndr_pull *ndr, int flags, struct wbint_LookupUserGroups *r)
1595 {
1596         TALLOC_CTX *_mem_save_sid_0;
1597         TALLOC_CTX *_mem_save_sids_0;
1598         if (flags & NDR_IN) {
1599                 ZERO_STRUCT(r->out);
1600
1601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1602                         NDR_PULL_ALLOC(ndr, r->in.sid);
1603                 }
1604                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1605                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1606                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1608                 NDR_PULL_ALLOC(ndr, r->out.sids);
1609                 ZERO_STRUCTP(r->out.sids);
1610         }
1611         if (flags & NDR_OUT) {
1612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1613                         NDR_PULL_ALLOC(ndr, r->out.sids);
1614                 }
1615                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1616                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
1617                 NDR_CHECK(ndr_pull_wbint_SidArray(ndr, NDR_SCALARS, r->out.sids));
1618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
1619                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1620         }
1621         return NDR_ERR_SUCCESS;
1622 }
1623
1624 _PUBLIC_ void ndr_print_wbint_LookupUserGroups(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupUserGroups *r)
1625 {
1626         ndr_print_struct(ndr, name, "wbint_LookupUserGroups");
1627         ndr->depth++;
1628         if (flags & NDR_SET_VALUES) {
1629                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1630         }
1631         if (flags & NDR_IN) {
1632                 ndr_print_struct(ndr, "in", "wbint_LookupUserGroups");
1633                 ndr->depth++;
1634                 ndr_print_ptr(ndr, "sid", r->in.sid);
1635                 ndr->depth++;
1636                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1637                 ndr->depth--;
1638                 ndr->depth--;
1639         }
1640         if (flags & NDR_OUT) {
1641                 ndr_print_struct(ndr, "out", "wbint_LookupUserGroups");
1642                 ndr->depth++;
1643                 ndr_print_ptr(ndr, "sids", r->out.sids);
1644                 ndr->depth++;
1645                 ndr_print_wbint_SidArray(ndr, "sids", r->out.sids);
1646                 ndr->depth--;
1647                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1648                 ndr->depth--;
1649         }
1650         ndr->depth--;
1651 }
1652
1653 static enum ndr_err_code ndr_push_wbint_QuerySequenceNumber(struct ndr_push *ndr, int flags, const struct wbint_QuerySequenceNumber *r)
1654 {
1655         if (flags & NDR_IN) {
1656         }
1657         if (flags & NDR_OUT) {
1658                 if (r->out.sequence == NULL) {
1659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1660                 }
1661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.sequence));
1662                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1663         }
1664         return NDR_ERR_SUCCESS;
1665 }
1666
1667 static enum ndr_err_code ndr_pull_wbint_QuerySequenceNumber(struct ndr_pull *ndr, int flags, struct wbint_QuerySequenceNumber *r)
1668 {
1669         TALLOC_CTX *_mem_save_sequence_0;
1670         if (flags & NDR_IN) {
1671                 ZERO_STRUCT(r->out);
1672
1673                 NDR_PULL_ALLOC(ndr, r->out.sequence);
1674                 ZERO_STRUCTP(r->out.sequence);
1675         }
1676         if (flags & NDR_OUT) {
1677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1678                         NDR_PULL_ALLOC(ndr, r->out.sequence);
1679                 }
1680                 _mem_save_sequence_0 = NDR_PULL_GET_MEM_CTX(ndr);
1681                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sequence, LIBNDR_FLAG_REF_ALLOC);
1682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.sequence));
1683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sequence_0, LIBNDR_FLAG_REF_ALLOC);
1684                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1685         }
1686         return NDR_ERR_SUCCESS;
1687 }
1688
1689 _PUBLIC_ void ndr_print_wbint_QuerySequenceNumber(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QuerySequenceNumber *r)
1690 {
1691         ndr_print_struct(ndr, name, "wbint_QuerySequenceNumber");
1692         ndr->depth++;
1693         if (flags & NDR_SET_VALUES) {
1694                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1695         }
1696         if (flags & NDR_IN) {
1697                 ndr_print_struct(ndr, "in", "wbint_QuerySequenceNumber");
1698                 ndr->depth++;
1699                 ndr->depth--;
1700         }
1701         if (flags & NDR_OUT) {
1702                 ndr_print_struct(ndr, "out", "wbint_QuerySequenceNumber");
1703                 ndr->depth++;
1704                 ndr_print_ptr(ndr, "sequence", r->out.sequence);
1705                 ndr->depth++;
1706                 ndr_print_uint32(ndr, "sequence", *r->out.sequence);
1707                 ndr->depth--;
1708                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1709                 ndr->depth--;
1710         }
1711         ndr->depth--;
1712 }
1713
1714 static enum ndr_err_code ndr_push_wbint_LookupGroupMembers(struct ndr_push *ndr, int flags, const struct wbint_LookupGroupMembers *r)
1715 {
1716         if (flags & NDR_IN) {
1717                 if (r->in.sid == NULL) {
1718                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1719                 }
1720                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1721                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->in.type));
1722         }
1723         if (flags & NDR_OUT) {
1724                 if (r->out.members == NULL) {
1725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1726                 }
1727                 NDR_CHECK(ndr_push_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.members));
1728                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1729         }
1730         return NDR_ERR_SUCCESS;
1731 }
1732
1733 static enum ndr_err_code ndr_pull_wbint_LookupGroupMembers(struct ndr_pull *ndr, int flags, struct wbint_LookupGroupMembers *r)
1734 {
1735         TALLOC_CTX *_mem_save_sid_0;
1736         TALLOC_CTX *_mem_save_members_0;
1737         if (flags & NDR_IN) {
1738                 ZERO_STRUCT(r->out);
1739
1740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1741                         NDR_PULL_ALLOC(ndr, r->in.sid);
1742                 }
1743                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
1745                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
1746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
1747                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->in.type));
1748                 NDR_PULL_ALLOC(ndr, r->out.members);
1749                 ZERO_STRUCTP(r->out.members);
1750         }
1751         if (flags & NDR_OUT) {
1752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1753                         NDR_PULL_ALLOC(ndr, r->out.members);
1754                 }
1755                 _mem_save_members_0 = NDR_PULL_GET_MEM_CTX(ndr);
1756                 NDR_PULL_SET_MEM_CTX(ndr, r->out.members, LIBNDR_FLAG_REF_ALLOC);
1757                 NDR_CHECK(ndr_pull_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.members));
1758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_members_0, LIBNDR_FLAG_REF_ALLOC);
1759                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1760         }
1761         return NDR_ERR_SUCCESS;
1762 }
1763
1764 _PUBLIC_ void ndr_print_wbint_LookupGroupMembers(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupGroupMembers *r)
1765 {
1766         ndr_print_struct(ndr, name, "wbint_LookupGroupMembers");
1767         ndr->depth++;
1768         if (flags & NDR_SET_VALUES) {
1769                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1770         }
1771         if (flags & NDR_IN) {
1772                 ndr_print_struct(ndr, "in", "wbint_LookupGroupMembers");
1773                 ndr->depth++;
1774                 ndr_print_ptr(ndr, "sid", r->in.sid);
1775                 ndr->depth++;
1776                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
1777                 ndr->depth--;
1778                 ndr_print_lsa_SidType(ndr, "type", r->in.type);
1779                 ndr->depth--;
1780         }
1781         if (flags & NDR_OUT) {
1782                 ndr_print_struct(ndr, "out", "wbint_LookupGroupMembers");
1783                 ndr->depth++;
1784                 ndr_print_ptr(ndr, "members", r->out.members);
1785                 ndr->depth++;
1786                 ndr_print_wbint_Principals(ndr, "members", r->out.members);
1787                 ndr->depth--;
1788                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1789                 ndr->depth--;
1790         }
1791         ndr->depth--;
1792 }
1793
1794 static enum ndr_err_code ndr_push_wbint_QueryUserList(struct ndr_push *ndr, int flags, const struct wbint_QueryUserList *r)
1795 {
1796         if (flags & NDR_IN) {
1797         }
1798         if (flags & NDR_OUT) {
1799                 if (r->out.users == NULL) {
1800                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1801                 }
1802                 NDR_CHECK(ndr_push_wbint_userinfos(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
1803                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1804         }
1805         return NDR_ERR_SUCCESS;
1806 }
1807
1808 static enum ndr_err_code ndr_pull_wbint_QueryUserList(struct ndr_pull *ndr, int flags, struct wbint_QueryUserList *r)
1809 {
1810         TALLOC_CTX *_mem_save_users_0;
1811         if (flags & NDR_IN) {
1812                 ZERO_STRUCT(r->out);
1813
1814                 NDR_PULL_ALLOC(ndr, r->out.users);
1815                 ZERO_STRUCTP(r->out.users);
1816         }
1817         if (flags & NDR_OUT) {
1818                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1819                         NDR_PULL_ALLOC(ndr, r->out.users);
1820                 }
1821                 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
1822                 NDR_PULL_SET_MEM_CTX(ndr, r->out.users, LIBNDR_FLAG_REF_ALLOC);
1823                 NDR_CHECK(ndr_pull_wbint_userinfos(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
1824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
1825                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1826         }
1827         return NDR_ERR_SUCCESS;
1828 }
1829
1830 _PUBLIC_ void ndr_print_wbint_QueryUserList(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QueryUserList *r)
1831 {
1832         ndr_print_struct(ndr, name, "wbint_QueryUserList");
1833         ndr->depth++;
1834         if (flags & NDR_SET_VALUES) {
1835                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1836         }
1837         if (flags & NDR_IN) {
1838                 ndr_print_struct(ndr, "in", "wbint_QueryUserList");
1839                 ndr->depth++;
1840                 ndr->depth--;
1841         }
1842         if (flags & NDR_OUT) {
1843                 ndr_print_struct(ndr, "out", "wbint_QueryUserList");
1844                 ndr->depth++;
1845                 ndr_print_ptr(ndr, "users", r->out.users);
1846                 ndr->depth++;
1847                 ndr_print_wbint_userinfos(ndr, "users", r->out.users);
1848                 ndr->depth--;
1849                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1850                 ndr->depth--;
1851         }
1852         ndr->depth--;
1853 }
1854
1855 static enum ndr_err_code ndr_push_wbint_QueryGroupList(struct ndr_push *ndr, int flags, const struct wbint_QueryGroupList *r)
1856 {
1857         if (flags & NDR_IN) {
1858         }
1859         if (flags & NDR_OUT) {
1860                 if (r->out.groups == NULL) {
1861                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1862                 }
1863                 NDR_CHECK(ndr_push_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.groups));
1864                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1865         }
1866         return NDR_ERR_SUCCESS;
1867 }
1868
1869 static enum ndr_err_code ndr_pull_wbint_QueryGroupList(struct ndr_pull *ndr, int flags, struct wbint_QueryGroupList *r)
1870 {
1871         TALLOC_CTX *_mem_save_groups_0;
1872         if (flags & NDR_IN) {
1873                 ZERO_STRUCT(r->out);
1874
1875                 NDR_PULL_ALLOC(ndr, r->out.groups);
1876                 ZERO_STRUCTP(r->out.groups);
1877         }
1878         if (flags & NDR_OUT) {
1879                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1880                         NDR_PULL_ALLOC(ndr, r->out.groups);
1881                 }
1882                 _mem_save_groups_0 = NDR_PULL_GET_MEM_CTX(ndr);
1883                 NDR_PULL_SET_MEM_CTX(ndr, r->out.groups, LIBNDR_FLAG_REF_ALLOC);
1884                 NDR_CHECK(ndr_pull_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.groups));
1885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_groups_0, LIBNDR_FLAG_REF_ALLOC);
1886                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1887         }
1888         return NDR_ERR_SUCCESS;
1889 }
1890
1891 _PUBLIC_ void ndr_print_wbint_QueryGroupList(struct ndr_print *ndr, const char *name, int flags, const struct wbint_QueryGroupList *r)
1892 {
1893         ndr_print_struct(ndr, name, "wbint_QueryGroupList");
1894         ndr->depth++;
1895         if (flags & NDR_SET_VALUES) {
1896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1897         }
1898         if (flags & NDR_IN) {
1899                 ndr_print_struct(ndr, "in", "wbint_QueryGroupList");
1900                 ndr->depth++;
1901                 ndr->depth--;
1902         }
1903         if (flags & NDR_OUT) {
1904                 ndr_print_struct(ndr, "out", "wbint_QueryGroupList");
1905                 ndr->depth++;
1906                 ndr_print_ptr(ndr, "groups", r->out.groups);
1907                 ndr->depth++;
1908                 ndr_print_wbint_Principals(ndr, "groups", r->out.groups);
1909                 ndr->depth--;
1910                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1911                 ndr->depth--;
1912         }
1913         ndr->depth--;
1914 }
1915
1916 static enum ndr_err_code ndr_push_wbint_DsGetDcName(struct ndr_push *ndr, int flags, const struct wbint_DsGetDcName *r)
1917 {
1918         if (flags & NDR_IN) {
1919                 if (r->in.domain_name == NULL) {
1920                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1921                 }
1922                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
1923                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1924                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF8)));
1925                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_guid));
1927                 if (r->in.domain_guid) {
1928                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.domain_guid));
1929                 }
1930                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.site_name));
1931                 if (r->in.site_name) {
1932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF8)));
1933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.site_name, CH_UTF8)));
1935                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.site_name, ndr_charset_length(r->in.site_name, CH_UTF8), sizeof(uint8_t), CH_UTF8));
1936                 }
1937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
1938         }
1939         if (flags & NDR_OUT) {
1940                 if (r->out.dc_info == NULL) {
1941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1942                 }
1943                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dc_info));
1944                 if (*r->out.dc_info) {
1945                         NDR_CHECK(ndr_push_netr_DsRGetDCNameInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.dc_info));
1946                 }
1947                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1948         }
1949         return NDR_ERR_SUCCESS;
1950 }
1951
1952 static enum ndr_err_code ndr_pull_wbint_DsGetDcName(struct ndr_pull *ndr, int flags, struct wbint_DsGetDcName *r)
1953 {
1954         uint32_t _ptr_domain_guid;
1955         uint32_t _ptr_site_name;
1956         uint32_t _ptr_dc_info;
1957         TALLOC_CTX *_mem_save_domain_guid_0;
1958         TALLOC_CTX *_mem_save_site_name_0;
1959         TALLOC_CTX *_mem_save_dc_info_0;
1960         TALLOC_CTX *_mem_save_dc_info_1;
1961         if (flags & NDR_IN) {
1962                 ZERO_STRUCT(r->out);
1963
1964                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
1965                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
1966                 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
1967                         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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));
1968                 }
1969                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t)));
1970                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint8_t), CH_UTF8));
1971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_guid));
1972                 if (_ptr_domain_guid) {
1973                         NDR_PULL_ALLOC(ndr, r->in.domain_guid);
1974                 } else {
1975                         r->in.domain_guid = NULL;
1976                 }
1977                 if (r->in.domain_guid) {
1978                         _mem_save_domain_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1979                         NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_guid, 0);
1980                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.domain_guid));
1981                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_guid_0, 0);
1982                 }
1983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
1984                 if (_ptr_site_name) {
1985                         NDR_PULL_ALLOC(ndr, r->in.site_name);
1986                 } else {
1987                         r->in.site_name = NULL;
1988                 }
1989                 if (r->in.site_name) {
1990                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1991                         NDR_PULL_SET_MEM_CTX(ndr, r->in.site_name, 0);
1992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.site_name));
1993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.site_name));
1994                         if (ndr_get_array_length(ndr, &r->in.site_name) > ndr_get_array_size(ndr, &r->in.site_name)) {
1995                                 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.site_name), ndr_get_array_length(ndr, &r->in.site_name));
1996                         }
1997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.site_name), sizeof(uint8_t)));
1998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.site_name, ndr_get_array_length(ndr, &r->in.site_name), sizeof(uint8_t), CH_UTF8));
1999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
2000                 }
2001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
2002                 NDR_PULL_ALLOC(ndr, r->out.dc_info);
2003                 ZERO_STRUCTP(r->out.dc_info);
2004         }
2005         if (flags & NDR_OUT) {
2006                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2007                         NDR_PULL_ALLOC(ndr, r->out.dc_info);
2008                 }
2009                 _mem_save_dc_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2010                 NDR_PULL_SET_MEM_CTX(ndr, r->out.dc_info, LIBNDR_FLAG_REF_ALLOC);
2011                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dc_info));
2012                 if (_ptr_dc_info) {
2013                         NDR_PULL_ALLOC(ndr, *r->out.dc_info);
2014                 } else {
2015                         *r->out.dc_info = NULL;
2016                 }
2017                 if (*r->out.dc_info) {
2018                         _mem_save_dc_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
2019                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.dc_info, 0);
2020                         NDR_CHECK(ndr_pull_netr_DsRGetDCNameInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.dc_info));
2021                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_info_1, 0);
2022                 }
2023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dc_info_0, LIBNDR_FLAG_REF_ALLOC);
2024                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2025         }
2026         return NDR_ERR_SUCCESS;
2027 }
2028
2029 _PUBLIC_ void ndr_print_wbint_DsGetDcName(struct ndr_print *ndr, const char *name, int flags, const struct wbint_DsGetDcName *r)
2030 {
2031         ndr_print_struct(ndr, name, "wbint_DsGetDcName");
2032         ndr->depth++;
2033         if (flags & NDR_SET_VALUES) {
2034                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2035         }
2036         if (flags & NDR_IN) {
2037                 ndr_print_struct(ndr, "in", "wbint_DsGetDcName");
2038                 ndr->depth++;
2039                 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
2040                 ndr->depth++;
2041                 ndr_print_string(ndr, "domain_name", r->in.domain_name);
2042                 ndr->depth--;
2043                 ndr_print_ptr(ndr, "domain_guid", r->in.domain_guid);
2044                 ndr->depth++;
2045                 if (r->in.domain_guid) {
2046                         ndr_print_GUID(ndr, "domain_guid", r->in.domain_guid);
2047                 }
2048                 ndr->depth--;
2049                 ndr_print_ptr(ndr, "site_name", r->in.site_name);
2050                 ndr->depth++;
2051                 if (r->in.site_name) {
2052                         ndr_print_string(ndr, "site_name", r->in.site_name);
2053                 }
2054                 ndr->depth--;
2055                 ndr_print_uint32(ndr, "flags", r->in.flags);
2056                 ndr->depth--;
2057         }
2058         if (flags & NDR_OUT) {
2059                 ndr_print_struct(ndr, "out", "wbint_DsGetDcName");
2060                 ndr->depth++;
2061                 ndr_print_ptr(ndr, "dc_info", r->out.dc_info);
2062                 ndr->depth++;
2063                 ndr_print_ptr(ndr, "dc_info", *r->out.dc_info);
2064                 ndr->depth++;
2065                 if (*r->out.dc_info) {
2066                         ndr_print_netr_DsRGetDCNameInfo(ndr, "dc_info", *r->out.dc_info);
2067                 }
2068                 ndr->depth--;
2069                 ndr->depth--;
2070                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2071                 ndr->depth--;
2072         }
2073         ndr->depth--;
2074 }
2075
2076 static enum ndr_err_code ndr_push_wbint_LookupRids(struct ndr_push *ndr, int flags, const struct wbint_LookupRids *r)
2077 {
2078         if (flags & NDR_IN) {
2079                 if (r->in.rids == NULL) {
2080                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2081                 }
2082                 NDR_CHECK(ndr_push_wbint_RidArray(ndr, NDR_SCALARS, r->in.rids));
2083         }
2084         if (flags & NDR_OUT) {
2085                 if (r->out.names == NULL) {
2086                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2087                 }
2088                 NDR_CHECK(ndr_push_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
2089                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2090         }
2091         return NDR_ERR_SUCCESS;
2092 }
2093
2094 static enum ndr_err_code ndr_pull_wbint_LookupRids(struct ndr_pull *ndr, int flags, struct wbint_LookupRids *r)
2095 {
2096         TALLOC_CTX *_mem_save_rids_0;
2097         TALLOC_CTX *_mem_save_names_0;
2098         if (flags & NDR_IN) {
2099                 ZERO_STRUCT(r->out);
2100
2101                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2102                         NDR_PULL_ALLOC(ndr, r->in.rids);
2103                 }
2104                 _mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);
2105                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, LIBNDR_FLAG_REF_ALLOC);
2106                 NDR_CHECK(ndr_pull_wbint_RidArray(ndr, NDR_SCALARS, r->in.rids));
2107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);
2108                 NDR_PULL_ALLOC(ndr, r->out.names);
2109                 ZERO_STRUCTP(r->out.names);
2110         }
2111         if (flags & NDR_OUT) {
2112                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2113                         NDR_PULL_ALLOC(ndr, r->out.names);
2114                 }
2115                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
2116                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
2117                 NDR_CHECK(ndr_pull_wbint_Principals(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
2118                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
2119                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2120         }
2121         return NDR_ERR_SUCCESS;
2122 }
2123
2124 _PUBLIC_ void ndr_print_wbint_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct wbint_LookupRids *r)
2125 {
2126         ndr_print_struct(ndr, name, "wbint_LookupRids");
2127         ndr->depth++;
2128         if (flags & NDR_SET_VALUES) {
2129                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2130         }
2131         if (flags & NDR_IN) {
2132                 ndr_print_struct(ndr, "in", "wbint_LookupRids");
2133                 ndr->depth++;
2134                 ndr_print_ptr(ndr, "rids", r->in.rids);
2135                 ndr->depth++;
2136                 ndr_print_wbint_RidArray(ndr, "rids", r->in.rids);
2137                 ndr->depth--;
2138                 ndr->depth--;
2139         }
2140         if (flags & NDR_OUT) {
2141                 ndr_print_struct(ndr, "out", "wbint_LookupRids");
2142                 ndr->depth++;
2143                 ndr_print_ptr(ndr, "names", r->out.names);
2144                 ndr->depth++;
2145                 ndr_print_wbint_Principals(ndr, "names", r->out.names);
2146                 ndr->depth--;
2147                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2148                 ndr->depth--;
2149         }
2150         ndr->depth--;
2151 }
2152
2153 static enum ndr_err_code ndr_push_wbint_CheckMachineAccount(struct ndr_push *ndr, int flags, const struct wbint_CheckMachineAccount *r)
2154 {
2155         if (flags & NDR_IN) {
2156         }
2157         if (flags & NDR_OUT) {
2158                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2159         }
2160         return NDR_ERR_SUCCESS;
2161 }
2162
2163 static enum ndr_err_code ndr_pull_wbint_CheckMachineAccount(struct ndr_pull *ndr, int flags, struct wbint_CheckMachineAccount *r)
2164 {
2165         if (flags & NDR_IN) {
2166         }
2167         if (flags & NDR_OUT) {
2168                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2169         }
2170         return NDR_ERR_SUCCESS;
2171 }
2172
2173 _PUBLIC_ void ndr_print_wbint_CheckMachineAccount(struct ndr_print *ndr, const char *name, int flags, const struct wbint_CheckMachineAccount *r)
2174 {
2175         ndr_print_struct(ndr, name, "wbint_CheckMachineAccount");
2176         ndr->depth++;
2177         if (flags & NDR_SET_VALUES) {
2178                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2179         }
2180         if (flags & NDR_IN) {
2181                 ndr_print_struct(ndr, "in", "wbint_CheckMachineAccount");
2182                 ndr->depth++;
2183                 ndr->depth--;
2184         }
2185         if (flags & NDR_OUT) {
2186                 ndr_print_struct(ndr, "out", "wbint_CheckMachineAccount");
2187                 ndr->depth++;
2188                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2189                 ndr->depth--;
2190         }
2191         ndr->depth--;
2192 }
2193
2194 static enum ndr_err_code ndr_push_wbint_ChangeMachineAccount(struct ndr_push *ndr, int flags, const struct wbint_ChangeMachineAccount *r)
2195 {
2196         if (flags & NDR_IN) {
2197         }
2198         if (flags & NDR_OUT) {
2199                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2200         }
2201         return NDR_ERR_SUCCESS;
2202 }
2203
2204 static enum ndr_err_code ndr_pull_wbint_ChangeMachineAccount(struct ndr_pull *ndr, int flags, struct wbint_ChangeMachineAccount *r)
2205 {
2206         if (flags & NDR_IN) {
2207         }
2208         if (flags & NDR_OUT) {
2209                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2210         }
2211         return NDR_ERR_SUCCESS;
2212 }
2213
2214 _PUBLIC_ void ndr_print_wbint_ChangeMachineAccount(struct ndr_print *ndr, const char *name, int flags, const struct wbint_ChangeMachineAccount *r)
2215 {
2216         ndr_print_struct(ndr, name, "wbint_ChangeMachineAccount");
2217         ndr->depth++;
2218         if (flags & NDR_SET_VALUES) {
2219                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2220         }
2221         if (flags & NDR_IN) {
2222                 ndr_print_struct(ndr, "in", "wbint_ChangeMachineAccount");
2223                 ndr->depth++;
2224                 ndr->depth--;
2225         }
2226         if (flags & NDR_OUT) {
2227                 ndr_print_struct(ndr, "out", "wbint_ChangeMachineAccount");
2228                 ndr->depth++;
2229                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2230                 ndr->depth--;
2231         }
2232         ndr->depth--;
2233 }
2234
2235 static enum ndr_err_code ndr_push_wbint_SetMapping(struct ndr_push *ndr, int flags, const struct wbint_SetMapping *r)
2236 {
2237         if (flags & NDR_IN) {
2238                 if (r->in.sid == NULL) {
2239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2240                 }
2241                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
2242                 NDR_CHECK(ndr_push_wbint_IdType(ndr, NDR_SCALARS, r->in.type));
2243                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.id));
2244         }
2245         if (flags & NDR_OUT) {
2246                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2247         }
2248         return NDR_ERR_SUCCESS;
2249 }
2250
2251 static enum ndr_err_code ndr_pull_wbint_SetMapping(struct ndr_pull *ndr, int flags, struct wbint_SetMapping *r)
2252 {
2253         TALLOC_CTX *_mem_save_sid_0;
2254         if (flags & NDR_IN) {
2255                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2256                         NDR_PULL_ALLOC(ndr, r->in.sid);
2257                 }
2258                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2259                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
2260                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
2261                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
2262                 NDR_CHECK(ndr_pull_wbint_IdType(ndr, NDR_SCALARS, &r->in.type));
2263                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.id));
2264         }
2265         if (flags & NDR_OUT) {
2266                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2267         }
2268         return NDR_ERR_SUCCESS;
2269 }
2270
2271 _PUBLIC_ void ndr_print_wbint_SetMapping(struct ndr_print *ndr, const char *name, int flags, const struct wbint_SetMapping *r)
2272 {
2273         ndr_print_struct(ndr, name, "wbint_SetMapping");
2274         ndr->depth++;
2275         if (flags & NDR_SET_VALUES) {
2276                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2277         }
2278         if (flags & NDR_IN) {
2279                 ndr_print_struct(ndr, "in", "wbint_SetMapping");
2280                 ndr->depth++;
2281                 ndr_print_ptr(ndr, "sid", r->in.sid);
2282                 ndr->depth++;
2283                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
2284                 ndr->depth--;
2285                 ndr_print_wbint_IdType(ndr, "type", r->in.type);
2286                 ndr_print_hyper(ndr, "id", r->in.id);
2287                 ndr->depth--;
2288         }
2289         if (flags & NDR_OUT) {
2290                 ndr_print_struct(ndr, "out", "wbint_SetMapping");
2291                 ndr->depth++;
2292                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2293                 ndr->depth--;
2294         }
2295         ndr->depth--;
2296 }
2297
2298 static enum ndr_err_code ndr_push_wbint_RemoveMapping(struct ndr_push *ndr, int flags, const struct wbint_RemoveMapping *r)
2299 {
2300         if (flags & NDR_IN) {
2301                 if (r->in.sid == NULL) {
2302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2303                 }
2304                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.sid));
2305                 NDR_CHECK(ndr_push_wbint_IdType(ndr, NDR_SCALARS, r->in.type));
2306                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.id));
2307         }
2308         if (flags & NDR_OUT) {
2309                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2310         }
2311         return NDR_ERR_SUCCESS;
2312 }
2313
2314 static enum ndr_err_code ndr_pull_wbint_RemoveMapping(struct ndr_pull *ndr, int flags, struct wbint_RemoveMapping *r)
2315 {
2316         TALLOC_CTX *_mem_save_sid_0;
2317         if (flags & NDR_IN) {
2318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2319                         NDR_PULL_ALLOC(ndr, r->in.sid);
2320                 }
2321                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
2323                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.sid));
2324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
2325                 NDR_CHECK(ndr_pull_wbint_IdType(ndr, NDR_SCALARS, &r->in.type));
2326                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.id));
2327         }
2328         if (flags & NDR_OUT) {
2329                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2330         }
2331         return NDR_ERR_SUCCESS;
2332 }
2333
2334 _PUBLIC_ void ndr_print_wbint_RemoveMapping(struct ndr_print *ndr, const char *name, int flags, const struct wbint_RemoveMapping *r)
2335 {
2336         ndr_print_struct(ndr, name, "wbint_RemoveMapping");
2337         ndr->depth++;
2338         if (flags & NDR_SET_VALUES) {
2339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2340         }
2341         if (flags & NDR_IN) {
2342                 ndr_print_struct(ndr, "in", "wbint_RemoveMapping");
2343                 ndr->depth++;
2344                 ndr_print_ptr(ndr, "sid", r->in.sid);
2345                 ndr->depth++;
2346                 ndr_print_dom_sid(ndr, "sid", r->in.sid);
2347                 ndr->depth--;
2348                 ndr_print_wbint_IdType(ndr, "type", r->in.type);
2349                 ndr_print_hyper(ndr, "id", r->in.id);
2350                 ndr->depth--;
2351         }
2352         if (flags & NDR_OUT) {
2353                 ndr_print_struct(ndr, "out", "wbint_RemoveMapping");
2354                 ndr->depth++;
2355                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2356                 ndr->depth--;
2357         }
2358         ndr->depth--;
2359 }
2360
2361 static enum ndr_err_code ndr_push_wbint_SetHWM(struct ndr_push *ndr, int flags, const struct wbint_SetHWM *r)
2362 {
2363         if (flags & NDR_IN) {
2364                 NDR_CHECK(ndr_push_wbint_IdType(ndr, NDR_SCALARS, r->in.type));
2365                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.id));
2366         }
2367         if (flags & NDR_OUT) {
2368                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2369         }
2370         return NDR_ERR_SUCCESS;
2371 }
2372
2373 static enum ndr_err_code ndr_pull_wbint_SetHWM(struct ndr_pull *ndr, int flags, struct wbint_SetHWM *r)
2374 {
2375         if (flags & NDR_IN) {
2376                 NDR_CHECK(ndr_pull_wbint_IdType(ndr, NDR_SCALARS, &r->in.type));
2377                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.id));
2378         }
2379         if (flags & NDR_OUT) {
2380                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2381         }
2382         return NDR_ERR_SUCCESS;
2383 }
2384
2385 _PUBLIC_ void ndr_print_wbint_SetHWM(struct ndr_print *ndr, const char *name, int flags, const struct wbint_SetHWM *r)
2386 {
2387         ndr_print_struct(ndr, name, "wbint_SetHWM");
2388         ndr->depth++;
2389         if (flags & NDR_SET_VALUES) {
2390                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2391         }
2392         if (flags & NDR_IN) {
2393                 ndr_print_struct(ndr, "in", "wbint_SetHWM");
2394                 ndr->depth++;
2395                 ndr_print_wbint_IdType(ndr, "type", r->in.type);
2396                 ndr_print_hyper(ndr, "id", r->in.id);
2397                 ndr->depth--;
2398         }
2399         if (flags & NDR_OUT) {
2400                 ndr_print_struct(ndr, "out", "wbint_SetHWM");
2401                 ndr->depth++;
2402                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
2403                 ndr->depth--;
2404         }
2405         ndr->depth--;
2406 }
2407
2408 static const struct ndr_interface_call wbint_calls[] = {
2409         {
2410                 "wbint_Ping",
2411                 sizeof(struct wbint_Ping),
2412                 (ndr_push_flags_fn_t) ndr_push_wbint_Ping,
2413                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Ping,
2414                 (ndr_print_function_t) ndr_print_wbint_Ping,
2415                 false,
2416         },
2417         {
2418                 "wbint_LookupSid",
2419                 sizeof(struct wbint_LookupSid),
2420                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupSid,
2421                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupSid,
2422                 (ndr_print_function_t) ndr_print_wbint_LookupSid,
2423                 false,
2424         },
2425         {
2426                 "wbint_LookupName",
2427                 sizeof(struct wbint_LookupName),
2428                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupName,
2429                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupName,
2430                 (ndr_print_function_t) ndr_print_wbint_LookupName,
2431                 false,
2432         },
2433         {
2434                 "wbint_Sid2Uid",
2435                 sizeof(struct wbint_Sid2Uid),
2436                 (ndr_push_flags_fn_t) ndr_push_wbint_Sid2Uid,
2437                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Sid2Uid,
2438                 (ndr_print_function_t) ndr_print_wbint_Sid2Uid,
2439                 false,
2440         },
2441         {
2442                 "wbint_Sid2Gid",
2443                 sizeof(struct wbint_Sid2Gid),
2444                 (ndr_push_flags_fn_t) ndr_push_wbint_Sid2Gid,
2445                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Sid2Gid,
2446                 (ndr_print_function_t) ndr_print_wbint_Sid2Gid,
2447                 false,
2448         },
2449         {
2450                 "wbint_Uid2Sid",
2451                 sizeof(struct wbint_Uid2Sid),
2452                 (ndr_push_flags_fn_t) ndr_push_wbint_Uid2Sid,
2453                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Uid2Sid,
2454                 (ndr_print_function_t) ndr_print_wbint_Uid2Sid,
2455                 false,
2456         },
2457         {
2458                 "wbint_Gid2Sid",
2459                 sizeof(struct wbint_Gid2Sid),
2460                 (ndr_push_flags_fn_t) ndr_push_wbint_Gid2Sid,
2461                 (ndr_pull_flags_fn_t) ndr_pull_wbint_Gid2Sid,
2462                 (ndr_print_function_t) ndr_print_wbint_Gid2Sid,
2463                 false,
2464         },
2465         {
2466                 "wbint_AllocateUid",
2467                 sizeof(struct wbint_AllocateUid),
2468                 (ndr_push_flags_fn_t) ndr_push_wbint_AllocateUid,
2469                 (ndr_pull_flags_fn_t) ndr_pull_wbint_AllocateUid,
2470                 (ndr_print_function_t) ndr_print_wbint_AllocateUid,
2471                 false,
2472         },
2473         {
2474                 "wbint_AllocateGid",
2475                 sizeof(struct wbint_AllocateGid),
2476                 (ndr_push_flags_fn_t) ndr_push_wbint_AllocateGid,
2477                 (ndr_pull_flags_fn_t) ndr_pull_wbint_AllocateGid,
2478                 (ndr_print_function_t) ndr_print_wbint_AllocateGid,
2479                 false,
2480         },
2481         {
2482                 "wbint_QueryUser",
2483                 sizeof(struct wbint_QueryUser),
2484                 (ndr_push_flags_fn_t) ndr_push_wbint_QueryUser,
2485                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QueryUser,
2486                 (ndr_print_function_t) ndr_print_wbint_QueryUser,
2487                 false,
2488         },
2489         {
2490                 "wbint_LookupUserAliases",
2491                 sizeof(struct wbint_LookupUserAliases),
2492                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupUserAliases,
2493                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupUserAliases,
2494                 (ndr_print_function_t) ndr_print_wbint_LookupUserAliases,
2495                 false,
2496         },
2497         {
2498                 "wbint_LookupUserGroups",
2499                 sizeof(struct wbint_LookupUserGroups),
2500                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupUserGroups,
2501                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupUserGroups,
2502                 (ndr_print_function_t) ndr_print_wbint_LookupUserGroups,
2503                 false,
2504         },
2505         {
2506                 "wbint_QuerySequenceNumber",
2507                 sizeof(struct wbint_QuerySequenceNumber),
2508                 (ndr_push_flags_fn_t) ndr_push_wbint_QuerySequenceNumber,
2509                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QuerySequenceNumber,
2510                 (ndr_print_function_t) ndr_print_wbint_QuerySequenceNumber,
2511                 false,
2512         },
2513         {
2514                 "wbint_LookupGroupMembers",
2515                 sizeof(struct wbint_LookupGroupMembers),
2516                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupGroupMembers,
2517                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupGroupMembers,
2518                 (ndr_print_function_t) ndr_print_wbint_LookupGroupMembers,
2519                 false,
2520         },
2521         {
2522                 "wbint_QueryUserList",
2523                 sizeof(struct wbint_QueryUserList),
2524                 (ndr_push_flags_fn_t) ndr_push_wbint_QueryUserList,
2525                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QueryUserList,
2526                 (ndr_print_function_t) ndr_print_wbint_QueryUserList,
2527                 false,
2528         },
2529         {
2530                 "wbint_QueryGroupList",
2531                 sizeof(struct wbint_QueryGroupList),
2532                 (ndr_push_flags_fn_t) ndr_push_wbint_QueryGroupList,
2533                 (ndr_pull_flags_fn_t) ndr_pull_wbint_QueryGroupList,
2534                 (ndr_print_function_t) ndr_print_wbint_QueryGroupList,
2535                 false,
2536         },
2537         {
2538                 "wbint_DsGetDcName",
2539                 sizeof(struct wbint_DsGetDcName),
2540                 (ndr_push_flags_fn_t) ndr_push_wbint_DsGetDcName,
2541                 (ndr_pull_flags_fn_t) ndr_pull_wbint_DsGetDcName,
2542                 (ndr_print_function_t) ndr_print_wbint_DsGetDcName,
2543                 false,
2544         },
2545         {
2546                 "wbint_LookupRids",
2547                 sizeof(struct wbint_LookupRids),
2548                 (ndr_push_flags_fn_t) ndr_push_wbint_LookupRids,
2549                 (ndr_pull_flags_fn_t) ndr_pull_wbint_LookupRids,
2550                 (ndr_print_function_t) ndr_print_wbint_LookupRids,
2551                 false,
2552         },
2553         {
2554                 "wbint_CheckMachineAccount",
2555                 sizeof(struct wbint_CheckMachineAccount),
2556                 (ndr_push_flags_fn_t) ndr_push_wbint_CheckMachineAccount,
2557                 (ndr_pull_flags_fn_t) ndr_pull_wbint_CheckMachineAccount,
2558                 (ndr_print_function_t) ndr_print_wbint_CheckMachineAccount,
2559                 false,
2560         },
2561         {
2562                 "wbint_ChangeMachineAccount",
2563                 sizeof(struct wbint_ChangeMachineAccount),
2564                 (ndr_push_flags_fn_t) ndr_push_wbint_ChangeMachineAccount,
2565                 (ndr_pull_flags_fn_t) ndr_pull_wbint_ChangeMachineAccount,
2566                 (ndr_print_function_t) ndr_print_wbint_ChangeMachineAccount,
2567                 false,
2568         },
2569         {
2570                 "wbint_SetMapping",
2571                 sizeof(struct wbint_SetMapping),
2572                 (ndr_push_flags_fn_t) ndr_push_wbint_SetMapping,
2573                 (ndr_pull_flags_fn_t) ndr_pull_wbint_SetMapping,
2574                 (ndr_print_function_t) ndr_print_wbint_SetMapping,
2575                 false,
2576         },
2577         {
2578                 "wbint_RemoveMapping",
2579                 sizeof(struct wbint_RemoveMapping),
2580                 (ndr_push_flags_fn_t) ndr_push_wbint_RemoveMapping,
2581                 (ndr_pull_flags_fn_t) ndr_pull_wbint_RemoveMapping,
2582                 (ndr_print_function_t) ndr_print_wbint_RemoveMapping,
2583                 false,
2584         },
2585         {
2586                 "wbint_SetHWM",
2587                 sizeof(struct wbint_SetHWM),
2588                 (ndr_push_flags_fn_t) ndr_push_wbint_SetHWM,
2589                 (ndr_pull_flags_fn_t) ndr_pull_wbint_SetHWM,
2590                 (ndr_print_function_t) ndr_print_wbint_SetHWM,
2591                 false,
2592         },
2593         { NULL, 0, NULL, NULL, NULL, false }
2594 };
2595
2596 static const char * const wbint_endpoint_strings[] = {
2597         "ncalrpc:", 
2598 };
2599
2600 static const struct ndr_interface_string_array wbint_endpoints = {
2601         .count  = 1,
2602         .names  = wbint_endpoint_strings
2603 };
2604
2605 static const char * const wbint_authservice_strings[] = {
2606         "host", 
2607 };
2608
2609 static const struct ndr_interface_string_array wbint_authservices = {
2610         .count  = 1,
2611         .names  = wbint_authservice_strings
2612 };
2613
2614
2615 const struct ndr_interface_table ndr_table_wbint = {
2616         .name           = "wbint",
2617         .syntax_id      = {
2618                 {0xbf09192c,0xed60,0x4928,{0x9d,0xff},{0xd0,0xd7,0xbc,0xb0,0x3e,0xd8}},
2619                 NDR_WBINT_VERSION
2620         },
2621         .helpstring     = NDR_WBINT_HELPSTRING,
2622         .num_calls      = 23,
2623         .calls          = wbint_calls,
2624         .endpoints      = &wbint_endpoints,
2625         .authservices   = &wbint_authservices
2626 };
2627