Line data Source code
1 : /* parser auto-generated by pidl */
2 :
3 : #include "includes.h"
4 : #include "bin/default/librpc/gen_ndr/ndr_krb5pac.h"
5 :
6 : #include "librpc/gen_ndr/ndr_security.h"
7 : #include "librpc/gen_ndr/ndr_lsa.h"
8 : #include "librpc/gen_ndr/ndr_netlogon.h"
9 : #include "librpc/gen_ndr/ndr_samr.h"
10 9930 : static enum ndr_err_code ndr_push_PAC_LOGON_NAME(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_LOGON_NAME *r)
11 : {
12 9930 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13 9930 : if (ndr_flags & NDR_SCALARS) {
14 9930 : NDR_CHECK(ndr_push_align(ndr, 4));
15 9930 : NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->logon_time));
16 9930 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->account_name)));
17 9930 : NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->account_name, 2 * strlen_m(r->account_name), sizeof(uint8_t), CH_UTF16));
18 9930 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19 : }
20 9930 : if (ndr_flags & NDR_BUFFERS) {
21 42 : }
22 9930 : return NDR_ERR_SUCCESS;
23 : }
24 :
25 23193 : static enum ndr_err_code ndr_pull_PAC_LOGON_NAME(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_LOGON_NAME *r)
26 : {
27 23193 : uint32_t size_account_name_0 = 0;
28 23193 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
29 23193 : if (ndr_flags & NDR_SCALARS) {
30 23193 : NDR_CHECK(ndr_pull_align(ndr, 4));
31 23193 : NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->logon_time));
32 23193 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
33 23193 : size_account_name_0 = r->size;
34 23193 : NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, size_account_name_0, sizeof(uint8_t), CH_UTF16));
35 23193 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
36 : }
37 23193 : if (ndr_flags & NDR_BUFFERS) {
38 31 : }
39 23193 : return NDR_ERR_SUCCESS;
40 : }
41 :
42 15 : _PUBLIC_ void ndr_print_PAC_LOGON_NAME(struct ndr_print *ndr, const char *name, const struct PAC_LOGON_NAME *r)
43 : {
44 15 : ndr_print_struct(ndr, name, "PAC_LOGON_NAME");
45 15 : if (r == NULL) { ndr_print_null(ndr); return; }
46 15 : ndr->depth++;
47 15 : ndr_print_NTTIME(ndr, "logon_time", r->logon_time);
48 15 : ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->account_name):r->size);
49 15 : ndr_print_string(ndr, "account_name", r->account_name);
50 15 : ndr->depth--;
51 : }
52 :
53 53338 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_SIGNATURE_DATA(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_SIGNATURE_DATA *r)
54 : {
55 : {
56 53338 : libndr_flags _flags_save_STRUCT = ndr->flags;
57 53338 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
58 53338 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
59 53338 : if (ndr_flags & NDR_SCALARS) {
60 53338 : NDR_CHECK(ndr_push_align(ndr, 4));
61 53338 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->type));
62 : {
63 53338 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
64 53338 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
65 53338 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->signature));
66 53338 : ndr->flags = _flags_save_DATA_BLOB;
67 : }
68 53338 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
69 : }
70 53338 : if (ndr_flags & NDR_BUFFERS) {
71 104 : }
72 53338 : ndr->flags = _flags_save_STRUCT;
73 : }
74 53338 : return NDR_ERR_SUCCESS;
75 : }
76 :
77 102153 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_SIGNATURE_DATA(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_SIGNATURE_DATA *r)
78 : {
79 : {
80 102153 : libndr_flags _flags_save_STRUCT = ndr->flags;
81 102153 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
82 102153 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
83 102153 : if (ndr_flags & NDR_SCALARS) {
84 102153 : NDR_CHECK(ndr_pull_align(ndr, 4));
85 102153 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->type));
86 : {
87 102153 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
88 102153 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
89 102153 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->signature));
90 102153 : ndr->flags = _flags_save_DATA_BLOB;
91 : }
92 102153 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
93 : }
94 102153 : if (ndr_flags & NDR_BUFFERS) {
95 80 : }
96 102153 : ndr->flags = _flags_save_STRUCT;
97 : }
98 102153 : return NDR_ERR_SUCCESS;
99 : }
100 :
101 0 : static void ndr_print_flags_PAC_SIGNATURE_DATA(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_SIGNATURE_DATA *r)
102 : {
103 0 : ndr_print_PAC_SIGNATURE_DATA(ndr, name, r);
104 0 : }
105 :
106 34 : _PUBLIC_ void ndr_print_PAC_SIGNATURE_DATA(struct ndr_print *ndr, const char *name, const struct PAC_SIGNATURE_DATA *r)
107 : {
108 34 : ndr_print_struct(ndr, name, "PAC_SIGNATURE_DATA");
109 34 : if (r == NULL) { ndr_print_null(ndr); return; }
110 : {
111 34 : libndr_flags _flags_save_STRUCT = ndr->flags;
112 34 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
113 34 : ndr->depth++;
114 34 : ndr_print_uint32(ndr, "type", r->type);
115 : {
116 34 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
117 34 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
118 34 : ndr_print_DATA_BLOB(ndr, "signature", r->signature);
119 34 : ndr->flags = _flags_save_DATA_BLOB;
120 : }
121 34 : ndr->depth--;
122 34 : ndr->flags = _flags_save_STRUCT;
123 : }
124 : }
125 :
126 176744 : static enum ndr_err_code ndr_push_PAC_DOMAIN_GROUP_MEMBERSHIP(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_DOMAIN_GROUP_MEMBERSHIP *r)
127 : {
128 176744 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
129 176744 : if (ndr_flags & NDR_SCALARS) {
130 88372 : NDR_CHECK(ndr_push_align(ndr, 5));
131 88372 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
132 88372 : NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->groups));
133 88372 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
134 : }
135 176744 : if (ndr_flags & NDR_BUFFERS) {
136 88372 : if (r->domain_sid) {
137 16894 : NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
138 : }
139 88372 : NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_BUFFERS, &r->groups));
140 : }
141 171004 : return NDR_ERR_SUCCESS;
142 : }
143 :
144 209084 : static enum ndr_err_code ndr_pull_PAC_DOMAIN_GROUP_MEMBERSHIP(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_DOMAIN_GROUP_MEMBERSHIP *r)
145 : {
146 5144 : uint32_t _ptr_domain_sid;
147 209084 : TALLOC_CTX *_mem_save_domain_sid_0 = NULL;
148 209084 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
149 209084 : if (ndr_flags & NDR_SCALARS) {
150 104542 : NDR_CHECK(ndr_pull_align(ndr, 5));
151 104542 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_sid));
152 104542 : if (_ptr_domain_sid) {
153 34546 : NDR_PULL_ALLOC(ndr, r->domain_sid);
154 : } else {
155 69996 : r->domain_sid = NULL;
156 : }
157 104542 : NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->groups));
158 104542 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
159 : }
160 209084 : if (ndr_flags & NDR_BUFFERS) {
161 104542 : if (r->domain_sid) {
162 34546 : _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
163 34546 : NDR_PULL_SET_MEM_CTX(ndr, r->domain_sid, 0);
164 34546 : NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
165 34546 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, 0);
166 : }
167 104542 : NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_BUFFERS, &r->groups));
168 : }
169 203940 : return NDR_ERR_SUCCESS;
170 : }
171 :
172 15 : _PUBLIC_ void ndr_print_PAC_DOMAIN_GROUP_MEMBERSHIP(struct ndr_print *ndr, const char *name, const struct PAC_DOMAIN_GROUP_MEMBERSHIP *r)
173 : {
174 15 : ndr_print_struct(ndr, name, "PAC_DOMAIN_GROUP_MEMBERSHIP");
175 15 : if (r == NULL) { ndr_print_null(ndr); return; }
176 15 : ndr->depth++;
177 15 : ndr_print_ptr(ndr, "domain_sid", r->domain_sid);
178 15 : ndr->depth++;
179 15 : if (r->domain_sid) {
180 2 : ndr_print_dom_sid2(ndr, "domain_sid", r->domain_sid);
181 : }
182 15 : ndr->depth--;
183 15 : ndr_print_samr_RidWithAttributeArray(ndr, "groups", &r->groups);
184 15 : ndr->depth--;
185 : }
186 :
187 88292 : static enum ndr_err_code ndr_push_PAC_LOGON_INFO(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_LOGON_INFO *r)
188 : {
189 88292 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
190 88292 : if (ndr_flags & NDR_SCALARS) {
191 88292 : NDR_CHECK(ndr_push_align(ndr, 5));
192 88292 : NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
193 88292 : NDR_CHECK(ndr_push_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_SCALARS, &r->resource_groups));
194 88292 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
195 : }
196 88292 : if (ndr_flags & NDR_BUFFERS) {
197 88292 : NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
198 88292 : NDR_CHECK(ndr_push_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_BUFFERS, &r->resource_groups));
199 : }
200 85422 : return NDR_ERR_SUCCESS;
201 : }
202 :
203 104400 : static enum ndr_err_code ndr_pull_PAC_LOGON_INFO(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_LOGON_INFO *r)
204 : {
205 104400 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
206 104400 : if (ndr_flags & NDR_SCALARS) {
207 104400 : NDR_CHECK(ndr_pull_align(ndr, 5));
208 104400 : NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
209 104400 : NDR_CHECK(ndr_pull_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_SCALARS, &r->resource_groups));
210 104400 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
211 : }
212 104400 : if (ndr_flags & NDR_BUFFERS) {
213 104400 : NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
214 104400 : NDR_CHECK(ndr_pull_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_BUFFERS, &r->resource_groups));
215 : }
216 101828 : return NDR_ERR_SUCCESS;
217 : }
218 :
219 15 : _PUBLIC_ void ndr_print_PAC_LOGON_INFO(struct ndr_print *ndr, const char *name, const struct PAC_LOGON_INFO *r)
220 : {
221 15 : ndr_print_struct(ndr, name, "PAC_LOGON_INFO");
222 15 : if (r == NULL) { ndr_print_null(ndr); return; }
223 15 : ndr->depth++;
224 15 : ndr_print_netr_SamInfo3(ndr, "info3", &r->info3);
225 15 : ndr_print_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, "resource_groups", &r->resource_groups);
226 15 : ndr->depth--;
227 : }
228 :
229 43 : static enum ndr_err_code ndr_push_PAC_CREDENTIAL_NTLM_FLAGS(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t r)
230 : {
231 43 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
232 41 : return NDR_ERR_SUCCESS;
233 : }
234 :
235 25 : static enum ndr_err_code ndr_pull_PAC_CREDENTIAL_NTLM_FLAGS(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *r)
236 : {
237 2 : uint32_t v;
238 25 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
239 25 : *r = v;
240 25 : return NDR_ERR_SUCCESS;
241 : }
242 :
243 2 : _PUBLIC_ void ndr_print_PAC_CREDENTIAL_NTLM_FLAGS(struct ndr_print *ndr, const char *name, uint32_t r)
244 : {
245 2 : ndr_print_uint32(ndr, name, r);
246 2 : ndr->depth++;
247 2 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PAC_CREDENTIAL_NTLM_HAS_LM_HASH", PAC_CREDENTIAL_NTLM_HAS_LM_HASH, r);
248 2 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PAC_CREDENTIAL_NTLM_HAS_NT_HASH", PAC_CREDENTIAL_NTLM_HAS_NT_HASH, r);
249 2 : ndr->depth--;
250 2 : }
251 :
252 43 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_CREDENTIAL_NTLM_SECPKG(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_CREDENTIAL_NTLM_SECPKG *r)
253 : {
254 43 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
255 43 : if (ndr_flags & NDR_SCALARS) {
256 43 : NDR_CHECK(ndr_push_align(ndr, 4));
257 43 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
258 45 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_NTLM_FLAGS(ndr, NDR_SCALARS, r->flags));
259 43 : NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_password));
260 43 : NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_password));
261 43 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
262 : }
263 43 : if (ndr_flags & NDR_BUFFERS) {
264 2 : }
265 43 : return NDR_ERR_SUCCESS;
266 : }
267 :
268 25 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_CREDENTIAL_NTLM_SECPKG(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_CREDENTIAL_NTLM_SECPKG *r)
269 : {
270 25 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
271 25 : if (ndr_flags & NDR_SCALARS) {
272 25 : NDR_CHECK(ndr_pull_align(ndr, 4));
273 25 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
274 27 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_NTLM_FLAGS(ndr, NDR_SCALARS, &r->flags));
275 25 : NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_password));
276 25 : NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_password));
277 25 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
278 : }
279 25 : if (ndr_flags & NDR_BUFFERS) {
280 2 : }
281 25 : return NDR_ERR_SUCCESS;
282 : }
283 :
284 0 : static void ndr_print_flags_PAC_CREDENTIAL_NTLM_SECPKG(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_CREDENTIAL_NTLM_SECPKG *r)
285 : {
286 0 : ndr_print_PAC_CREDENTIAL_NTLM_SECPKG(ndr, name, r);
287 0 : }
288 :
289 2 : _PUBLIC_ void ndr_print_PAC_CREDENTIAL_NTLM_SECPKG(struct ndr_print *ndr, const char *name, const struct PAC_CREDENTIAL_NTLM_SECPKG *r)
290 : {
291 2 : ndr_print_struct(ndr, name, "PAC_CREDENTIAL_NTLM_SECPKG");
292 2 : if (r == NULL) { ndr_print_null(ndr); return; }
293 2 : ndr->depth++;
294 2 : ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->version);
295 2 : ndr_print_PAC_CREDENTIAL_NTLM_FLAGS(ndr, "flags", r->flags);
296 2 : ndr->depth--;
297 : }
298 :
299 86 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG *r)
300 : {
301 86 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
302 86 : if (ndr_flags & NDR_SCALARS) {
303 43 : NDR_CHECK(ndr_push_align(ndr, 5));
304 43 : NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->package_name));
305 43 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->credential_size));
306 43 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->credential));
307 43 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
308 : }
309 86 : if (ndr_flags & NDR_BUFFERS) {
310 43 : NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->package_name));
311 43 : if (r->credential) {
312 43 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->credential_size));
313 43 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->credential, r->credential_size));
314 : }
315 : }
316 82 : return NDR_ERR_SUCCESS;
317 : }
318 :
319 50 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG *r)
320 : {
321 4 : uint32_t _ptr_credential;
322 50 : uint32_t size_credential_1 = 0;
323 50 : TALLOC_CTX *_mem_save_credential_0 = NULL;
324 50 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
325 50 : if (ndr_flags & NDR_SCALARS) {
326 25 : NDR_CHECK(ndr_pull_align(ndr, 5));
327 25 : NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->package_name));
328 25 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->credential_size));
329 25 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_credential));
330 25 : if (_ptr_credential) {
331 25 : NDR_PULL_ALLOC(ndr, r->credential);
332 : } else {
333 0 : r->credential = NULL;
334 : }
335 25 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
336 : }
337 50 : if (ndr_flags & NDR_BUFFERS) {
338 25 : NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->package_name));
339 25 : if (r->credential) {
340 25 : _mem_save_credential_0 = NDR_PULL_GET_MEM_CTX(ndr);
341 25 : NDR_PULL_SET_MEM_CTX(ndr, r->credential, 0);
342 25 : NDR_CHECK(ndr_pull_array_size(ndr, &r->credential));
343 25 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->credential, &size_credential_1));
344 25 : NDR_PULL_ALLOC_N(ndr, r->credential, size_credential_1);
345 25 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->credential, size_credential_1));
346 25 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_credential_0, 0);
347 : }
348 25 : if (r->credential) {
349 25 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->credential, r->credential_size));
350 : }
351 : }
352 46 : return NDR_ERR_SUCCESS;
353 : }
354 :
355 0 : static void ndr_print_flags_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG *r)
356 : {
357 0 : ndr_print_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, name, r);
358 0 : }
359 :
360 2 : _PUBLIC_ void ndr_print_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(struct ndr_print *ndr, const char *name, const struct PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG *r)
361 : {
362 2 : ndr_print_struct(ndr, name, "PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG");
363 2 : if (r == NULL) { ndr_print_null(ndr); return; }
364 2 : ndr->depth++;
365 2 : ndr_print_lsa_String(ndr, "package_name", &r->package_name);
366 2 : ndr_print_uint32(ndr, "credential_size", r->credential_size);
367 2 : ndr->depth--;
368 : }
369 :
370 43 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_CREDENTIAL_DATA(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_CREDENTIAL_DATA *r)
371 : {
372 2 : uint32_t cntr_credentials_0;
373 43 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
374 43 : if (ndr_flags & NDR_SCALARS) {
375 43 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->credential_count));
376 43 : NDR_CHECK(ndr_push_align(ndr, 5));
377 43 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->credential_count));
378 86 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (r->credential_count); cntr_credentials_0++) {
379 43 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, NDR_SCALARS, &r->credentials[cntr_credentials_0]));
380 : }
381 43 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
382 : }
383 43 : if (ndr_flags & NDR_BUFFERS) {
384 86 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (r->credential_count); cntr_credentials_0++) {
385 43 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, NDR_BUFFERS, &r->credentials[cntr_credentials_0]));
386 : }
387 : }
388 41 : return NDR_ERR_SUCCESS;
389 : }
390 :
391 25 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_CREDENTIAL_DATA(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_CREDENTIAL_DATA *r)
392 : {
393 25 : uint32_t size_credentials_0 = 0;
394 2 : uint32_t cntr_credentials_0;
395 25 : TALLOC_CTX *_mem_save_credentials_0 = NULL;
396 25 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
397 25 : if (ndr_flags & NDR_SCALARS) {
398 25 : NDR_CHECK(ndr_pull_array_size(ndr, &r->credentials));
399 25 : NDR_CHECK(ndr_pull_align(ndr, 5));
400 25 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->credential_count));
401 25 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->credentials, &size_credentials_0));
402 25 : NDR_PULL_ALLOC_N(ndr, r->credentials, size_credentials_0);
403 25 : _mem_save_credentials_0 = NDR_PULL_GET_MEM_CTX(ndr);
404 25 : NDR_PULL_SET_MEM_CTX(ndr, r->credentials, 0);
405 50 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (size_credentials_0); cntr_credentials_0++) {
406 25 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, NDR_SCALARS, &r->credentials[cntr_credentials_0]));
407 : }
408 25 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_credentials_0, 0);
409 25 : if (r->credentials) {
410 25 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->credentials, r->credential_count));
411 : }
412 25 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
413 : }
414 25 : if (ndr_flags & NDR_BUFFERS) {
415 25 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->credentials, &size_credentials_0));
416 25 : _mem_save_credentials_0 = NDR_PULL_GET_MEM_CTX(ndr);
417 25 : NDR_PULL_SET_MEM_CTX(ndr, r->credentials, 0);
418 50 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (size_credentials_0); cntr_credentials_0++) {
419 25 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, NDR_BUFFERS, &r->credentials[cntr_credentials_0]));
420 : }
421 25 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_credentials_0, 0);
422 48 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (size_credentials_0); cntr_credentials_0++) {
423 : }
424 : }
425 23 : return NDR_ERR_SUCCESS;
426 : }
427 :
428 0 : static void ndr_print_flags_PAC_CREDENTIAL_DATA(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_CREDENTIAL_DATA *r)
429 : {
430 0 : ndr_print_PAC_CREDENTIAL_DATA(ndr, name, r);
431 0 : }
432 :
433 2 : _PUBLIC_ void ndr_print_PAC_CREDENTIAL_DATA(struct ndr_print *ndr, const char *name, const struct PAC_CREDENTIAL_DATA *r)
434 : {
435 2 : uint32_t cntr_credentials_0;
436 2 : ndr_print_struct(ndr, name, "PAC_CREDENTIAL_DATA");
437 2 : if (r == NULL) { ndr_print_null(ndr); return; }
438 2 : ndr->depth++;
439 2 : ndr_print_uint32(ndr, "credential_count", r->credential_count);
440 2 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "credentials", (uint32_t)(r->credential_count));
441 2 : ndr->depth++;
442 4 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (r->credential_count); cntr_credentials_0++) {
443 2 : ndr_print_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, "credentials", &r->credentials[cntr_credentials_0]);
444 : }
445 2 : ndr->depth--;
446 2 : ndr->depth--;
447 : }
448 :
449 43 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_CREDENTIAL_DATA_CTR(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_CREDENTIAL_DATA_CTR *r)
450 : {
451 43 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
452 43 : if (ndr_flags & NDR_SCALARS) {
453 43 : NDR_CHECK(ndr_push_align(ndr, 5));
454 43 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
455 43 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
456 : }
457 43 : if (ndr_flags & NDR_BUFFERS) {
458 43 : if (r->data) {
459 43 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, r->data));
460 : }
461 : }
462 41 : return NDR_ERR_SUCCESS;
463 : }
464 :
465 25 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_CREDENTIAL_DATA_CTR(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_CREDENTIAL_DATA_CTR *r)
466 : {
467 2 : uint32_t _ptr_data;
468 25 : TALLOC_CTX *_mem_save_data_0 = NULL;
469 25 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
470 25 : if (ndr_flags & NDR_SCALARS) {
471 25 : NDR_CHECK(ndr_pull_align(ndr, 5));
472 25 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
473 25 : if (_ptr_data) {
474 25 : NDR_PULL_ALLOC(ndr, r->data);
475 : } else {
476 0 : r->data = NULL;
477 : }
478 25 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
479 : }
480 25 : if (ndr_flags & NDR_BUFFERS) {
481 25 : if (r->data) {
482 25 : _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
483 25 : NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
484 25 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, r->data));
485 25 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
486 : }
487 : }
488 23 : return NDR_ERR_SUCCESS;
489 : }
490 :
491 0 : static void ndr_print_flags_PAC_CREDENTIAL_DATA_CTR(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_CREDENTIAL_DATA_CTR *r)
492 : {
493 0 : ndr_print_PAC_CREDENTIAL_DATA_CTR(ndr, name, r);
494 0 : }
495 :
496 2 : _PUBLIC_ void ndr_print_PAC_CREDENTIAL_DATA_CTR(struct ndr_print *ndr, const char *name, const struct PAC_CREDENTIAL_DATA_CTR *r)
497 : {
498 2 : ndr_print_struct(ndr, name, "PAC_CREDENTIAL_DATA_CTR");
499 2 : if (r == NULL) { ndr_print_null(ndr); return; }
500 2 : ndr->depth++;
501 2 : ndr_print_ptr(ndr, "data", r->data);
502 2 : ndr->depth++;
503 2 : if (r->data) {
504 2 : ndr_print_PAC_CREDENTIAL_DATA(ndr, "data", r->data);
505 : }
506 2 : ndr->depth--;
507 2 : ndr->depth--;
508 : }
509 :
510 43 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_CREDENTIAL_DATA_NDR(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_CREDENTIAL_DATA_NDR *r)
511 : {
512 43 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
513 43 : if (ndr_flags & NDR_SCALARS) {
514 43 : NDR_CHECK(ndr_push_align(ndr, 1));
515 : {
516 2 : struct ndr_push *_ndr_ctr;
517 43 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr, 0xFFFFFC01, -1));
518 43 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_DATA_CTR(_ndr_ctr, NDR_SCALARS|NDR_BUFFERS, &r->ctr));
519 43 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr, 0xFFFFFC01, -1));
520 : }
521 43 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
522 : }
523 43 : if (ndr_flags & NDR_BUFFERS) {
524 2 : }
525 43 : return NDR_ERR_SUCCESS;
526 : }
527 :
528 25 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_CREDENTIAL_DATA_NDR(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_CREDENTIAL_DATA_NDR *r)
529 : {
530 25 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
531 25 : if (ndr_flags & NDR_SCALARS) {
532 25 : NDR_CHECK(ndr_pull_align(ndr, 1));
533 : {
534 2 : struct ndr_pull *_ndr_ctr;
535 25 : ssize_t sub_size = -1;
536 25 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr, 0xFFFFFC01, sub_size));
537 25 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_DATA_CTR(_ndr_ctr, NDR_SCALARS|NDR_BUFFERS, &r->ctr));
538 25 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr, 0xFFFFFC01, sub_size));
539 : }
540 25 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
541 : }
542 25 : if (ndr_flags & NDR_BUFFERS) {
543 2 : }
544 25 : return NDR_ERR_SUCCESS;
545 : }
546 :
547 0 : static void ndr_print_flags_PAC_CREDENTIAL_DATA_NDR(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_CREDENTIAL_DATA_NDR *r)
548 : {
549 0 : ndr_print_PAC_CREDENTIAL_DATA_NDR(ndr, name, r);
550 0 : }
551 :
552 2 : _PUBLIC_ void ndr_print_PAC_CREDENTIAL_DATA_NDR(struct ndr_print *ndr, const char *name, const struct PAC_CREDENTIAL_DATA_NDR *r)
553 : {
554 2 : ndr_print_struct(ndr, name, "PAC_CREDENTIAL_DATA_NDR");
555 2 : if (r == NULL) { ndr_print_null(ndr); return; }
556 2 : ndr->depth++;
557 2 : ndr_print_PAC_CREDENTIAL_DATA_CTR(ndr, "ctr", &r->ctr);
558 2 : ndr->depth--;
559 : }
560 :
561 53 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_CREDENTIAL_INFO(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_CREDENTIAL_INFO *r)
562 : {
563 53 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
564 53 : if (ndr_flags & NDR_SCALARS) {
565 53 : NDR_CHECK(ndr_push_align(ndr, 4));
566 53 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
567 53 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->encryption_type));
568 : {
569 53 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
570 53 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
571 53 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->encrypted_data));
572 53 : ndr->flags = _flags_save_DATA_BLOB;
573 : }
574 53 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
575 : }
576 53 : if (ndr_flags & NDR_BUFFERS) {
577 12 : }
578 53 : return NDR_ERR_SUCCESS;
579 : }
580 :
581 58 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_CREDENTIAL_INFO(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_CREDENTIAL_INFO *r)
582 : {
583 58 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
584 58 : if (ndr_flags & NDR_SCALARS) {
585 58 : NDR_CHECK(ndr_pull_align(ndr, 4));
586 58 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
587 58 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->encryption_type));
588 : {
589 58 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
590 58 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
591 58 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->encrypted_data));
592 58 : ndr->flags = _flags_save_DATA_BLOB;
593 : }
594 58 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
595 : }
596 58 : if (ndr_flags & NDR_BUFFERS) {
597 4 : }
598 58 : return NDR_ERR_SUCCESS;
599 : }
600 :
601 0 : static void ndr_print_flags_PAC_CREDENTIAL_INFO(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_CREDENTIAL_INFO *r)
602 : {
603 0 : ndr_print_PAC_CREDENTIAL_INFO(ndr, name, r);
604 0 : }
605 :
606 4 : _PUBLIC_ void ndr_print_PAC_CREDENTIAL_INFO(struct ndr_print *ndr, const char *name, const struct PAC_CREDENTIAL_INFO *r)
607 : {
608 4 : ndr_print_struct(ndr, name, "PAC_CREDENTIAL_INFO");
609 4 : if (r == NULL) { ndr_print_null(ndr); return; }
610 4 : ndr->depth++;
611 4 : ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->version);
612 4 : ndr_print_uint32(ndr, "encryption_type", r->encryption_type);
613 : {
614 4 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
615 4 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
616 4 : ndr_print_DATA_BLOB(ndr, "encrypted_data", r->encrypted_data);
617 4 : ndr->flags = _flags_save_DATA_BLOB;
618 : }
619 4 : ndr->depth--;
620 : }
621 :
622 188 : static enum ndr_err_code ndr_push_PAC_CONSTRAINED_DELEGATION(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_CONSTRAINED_DELEGATION *r)
623 : {
624 0 : uint32_t cntr_transited_services_1;
625 188 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
626 188 : if (ndr_flags & NDR_SCALARS) {
627 188 : NDR_CHECK(ndr_push_align(ndr, 5));
628 188 : NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->proxy_target));
629 188 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_transited_services));
630 188 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->transited_services));
631 188 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
632 : }
633 188 : if (ndr_flags & NDR_BUFFERS) {
634 188 : NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->proxy_target));
635 188 : if (r->transited_services) {
636 188 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_transited_services));
637 457 : for (cntr_transited_services_1 = 0; cntr_transited_services_1 < (r->num_transited_services); cntr_transited_services_1++) {
638 269 : NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->transited_services[cntr_transited_services_1]));
639 : }
640 457 : for (cntr_transited_services_1 = 0; cntr_transited_services_1 < (r->num_transited_services); cntr_transited_services_1++) {
641 269 : NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->transited_services[cntr_transited_services_1]));
642 : }
643 : }
644 : }
645 188 : return NDR_ERR_SUCCESS;
646 : }
647 :
648 295 : static enum ndr_err_code ndr_pull_PAC_CONSTRAINED_DELEGATION(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_CONSTRAINED_DELEGATION *r)
649 : {
650 0 : uint32_t _ptr_transited_services;
651 295 : uint32_t size_transited_services_1 = 0;
652 0 : uint32_t cntr_transited_services_1;
653 295 : TALLOC_CTX *_mem_save_transited_services_0 = NULL;
654 295 : TALLOC_CTX *_mem_save_transited_services_1 = NULL;
655 295 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
656 295 : if (ndr_flags & NDR_SCALARS) {
657 295 : NDR_CHECK(ndr_pull_align(ndr, 5));
658 295 : NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->proxy_target));
659 295 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_transited_services));
660 295 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transited_services));
661 295 : if (_ptr_transited_services) {
662 295 : NDR_PULL_ALLOC(ndr, r->transited_services);
663 : } else {
664 0 : r->transited_services = NULL;
665 : }
666 295 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
667 : }
668 295 : if (ndr_flags & NDR_BUFFERS) {
669 295 : NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->proxy_target));
670 295 : if (r->transited_services) {
671 295 : _mem_save_transited_services_0 = NDR_PULL_GET_MEM_CTX(ndr);
672 295 : NDR_PULL_SET_MEM_CTX(ndr, r->transited_services, 0);
673 295 : NDR_CHECK(ndr_pull_array_size(ndr, &r->transited_services));
674 295 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->transited_services, &size_transited_services_1));
675 295 : NDR_PULL_ALLOC_N(ndr, r->transited_services, size_transited_services_1);
676 295 : _mem_save_transited_services_1 = NDR_PULL_GET_MEM_CTX(ndr);
677 295 : NDR_PULL_SET_MEM_CTX(ndr, r->transited_services, 0);
678 614 : for (cntr_transited_services_1 = 0; cntr_transited_services_1 < (size_transited_services_1); cntr_transited_services_1++) {
679 319 : NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->transited_services[cntr_transited_services_1]));
680 : }
681 614 : for (cntr_transited_services_1 = 0; cntr_transited_services_1 < (size_transited_services_1); cntr_transited_services_1++) {
682 319 : NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->transited_services[cntr_transited_services_1]));
683 : }
684 295 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transited_services_1, 0);
685 295 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transited_services_0, 0);
686 : }
687 295 : if (r->transited_services) {
688 295 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->transited_services, r->num_transited_services));
689 : }
690 614 : for (cntr_transited_services_1 = 0; cntr_transited_services_1 < (size_transited_services_1); cntr_transited_services_1++) {
691 0 : }
692 : }
693 295 : return NDR_ERR_SUCCESS;
694 : }
695 :
696 0 : _PUBLIC_ void ndr_print_PAC_CONSTRAINED_DELEGATION(struct ndr_print *ndr, const char *name, const struct PAC_CONSTRAINED_DELEGATION *r)
697 : {
698 0 : uint32_t cntr_transited_services_1;
699 0 : ndr_print_struct(ndr, name, "PAC_CONSTRAINED_DELEGATION");
700 0 : if (r == NULL) { ndr_print_null(ndr); return; }
701 0 : ndr->depth++;
702 0 : ndr_print_lsa_String(ndr, "proxy_target", &r->proxy_target);
703 0 : ndr_print_uint32(ndr, "num_transited_services", r->num_transited_services);
704 0 : ndr_print_ptr(ndr, "transited_services", r->transited_services);
705 0 : ndr->depth++;
706 0 : if (r->transited_services) {
707 0 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "transited_services", (uint32_t)(r->num_transited_services));
708 0 : ndr->depth++;
709 0 : for (cntr_transited_services_1 = 0; cntr_transited_services_1 < (r->num_transited_services); cntr_transited_services_1++) {
710 0 : ndr_print_lsa_String(ndr, "transited_services", &r->transited_services[cntr_transited_services_1]);
711 : }
712 0 : ndr->depth--;
713 : }
714 0 : ndr->depth--;
715 0 : ndr->depth--;
716 : }
717 :
718 40790 : static enum ndr_err_code ndr_push_PAC_UPN_DNS_FLAGS(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t r)
719 : {
720 40790 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
721 39596 : return NDR_ERR_SUCCESS;
722 : }
723 :
724 103837 : static enum ndr_err_code ndr_pull_PAC_UPN_DNS_FLAGS(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *r)
725 : {
726 2563 : uint32_t v;
727 103837 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
728 103837 : *r = v;
729 103837 : return NDR_ERR_SUCCESS;
730 : }
731 :
732 15 : _PUBLIC_ void ndr_print_PAC_UPN_DNS_FLAGS(struct ndr_print *ndr, const char *name, uint32_t r)
733 : {
734 15 : ndr_print_uint32(ndr, name, r);
735 15 : ndr->depth++;
736 15 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PAC_UPN_DNS_FLAG_CONSTRUCTED", PAC_UPN_DNS_FLAG_CONSTRUCTED, r);
737 15 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID", PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID, r);
738 15 : ndr->depth--;
739 15 : }
740 :
741 81538 : static enum ndr_err_code ndr_push_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_UPN_DNS_INFO_SAM_NAME_AND_SID *r)
742 : {
743 81538 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
744 81538 : if (ndr_flags & NDR_SCALARS) {
745 40769 : NDR_CHECK(ndr_push_align(ndr, 5));
746 40769 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->samaccountname)));
747 : {
748 40769 : libndr_flags _flags_save_string = ndr->flags;
749 40769 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
750 40769 : NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->samaccountname));
751 40769 : ndr->flags = _flags_save_string;
752 : }
753 40769 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_dom_sid(r->objectsid, ndr->flags)));
754 40769 : NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->objectsid));
755 40769 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
756 : }
757 81538 : if (ndr_flags & NDR_BUFFERS) {
758 : {
759 40769 : libndr_flags _flags_save_string = ndr->flags;
760 40769 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
761 40769 : if (r->samaccountname) {
762 40769 : NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->samaccountname));
763 : {
764 1173 : struct ndr_push *_ndr_samaccountname;
765 40769 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_samaccountname, 0, 2 * strlen_m(r->samaccountname)));
766 40769 : NDR_CHECK(ndr_push_string(_ndr_samaccountname, NDR_SCALARS, r->samaccountname));
767 40769 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_samaccountname, 0, 2 * strlen_m(r->samaccountname)));
768 : }
769 : }
770 40769 : ndr->flags = _flags_save_string;
771 : }
772 40769 : if (r->objectsid) {
773 40769 : NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->objectsid));
774 : {
775 1173 : struct ndr_push *_ndr_objectsid;
776 40769 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_objectsid, 0, ndr_size_dom_sid(r->objectsid, ndr->flags)));
777 40769 : NDR_CHECK(ndr_push_dom_sid(_ndr_objectsid, NDR_SCALARS, r->objectsid));
778 40769 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_objectsid, 0, ndr_size_dom_sid(r->objectsid, ndr->flags)));
779 : }
780 : }
781 : }
782 79192 : return NDR_ERR_SUCCESS;
783 : }
784 :
785 207648 : static enum ndr_err_code ndr_pull_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_UPN_DNS_INFO_SAM_NAME_AND_SID *r)
786 : {
787 5100 : uint16_t _ptr_samaccountname;
788 207648 : TALLOC_CTX *_mem_save_samaccountname_0 = NULL;
789 5100 : uint16_t _ptr_objectsid;
790 207648 : TALLOC_CTX *_mem_save_objectsid_0 = NULL;
791 207648 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
792 207648 : if (ndr_flags & NDR_SCALARS) {
793 103824 : NDR_CHECK(ndr_pull_align(ndr, 5));
794 103824 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->samaccountname_size));
795 : {
796 103824 : libndr_flags _flags_save_string = ndr->flags;
797 103824 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
798 103824 : NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_samaccountname));
799 103824 : if (_ptr_samaccountname) {
800 103824 : NDR_PULL_ALLOC(ndr, r->samaccountname);
801 103824 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->samaccountname, _ptr_samaccountname));
802 : } else {
803 0 : r->samaccountname = NULL;
804 : }
805 103824 : ndr->flags = _flags_save_string;
806 : }
807 103824 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->objectsid_size));
808 103824 : NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_objectsid));
809 103824 : if (_ptr_objectsid) {
810 103824 : NDR_PULL_ALLOC(ndr, r->objectsid);
811 103824 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->objectsid, _ptr_objectsid));
812 : } else {
813 0 : r->objectsid = NULL;
814 : }
815 103824 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
816 : }
817 207648 : if (ndr_flags & NDR_BUFFERS) {
818 : {
819 103824 : libndr_flags _flags_save_string = ndr->flags;
820 103824 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
821 103824 : if (r->samaccountname) {
822 2550 : uint32_t _relative_save_offset;
823 103824 : _relative_save_offset = ndr->offset;
824 103824 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->samaccountname));
825 103824 : _mem_save_samaccountname_0 = NDR_PULL_GET_MEM_CTX(ndr);
826 103824 : NDR_PULL_SET_MEM_CTX(ndr, r->samaccountname, 0);
827 : {
828 2550 : struct ndr_pull *_ndr_samaccountname;
829 103824 : ssize_t sub_size = r->samaccountname_size;
830 103824 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_samaccountname, 0, sub_size));
831 103824 : NDR_CHECK(ndr_pull_string(_ndr_samaccountname, NDR_SCALARS, &r->samaccountname));
832 103824 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_samaccountname, 0, sub_size));
833 : }
834 103824 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_samaccountname_0, 0);
835 103824 : if (ndr->offset > ndr->relative_highest_offset) {
836 103824 : ndr->relative_highest_offset = ndr->offset;
837 : }
838 103824 : ndr->offset = _relative_save_offset;
839 : }
840 103824 : ndr->flags = _flags_save_string;
841 : }
842 103824 : if (r->objectsid) {
843 2550 : uint32_t _relative_save_offset;
844 103824 : _relative_save_offset = ndr->offset;
845 103824 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->objectsid));
846 103824 : _mem_save_objectsid_0 = NDR_PULL_GET_MEM_CTX(ndr);
847 103824 : NDR_PULL_SET_MEM_CTX(ndr, r->objectsid, 0);
848 : {
849 2550 : struct ndr_pull *_ndr_objectsid;
850 103824 : ssize_t sub_size = r->objectsid_size;
851 103824 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_objectsid, 0, sub_size));
852 103824 : NDR_CHECK(ndr_pull_dom_sid(_ndr_objectsid, NDR_SCALARS, r->objectsid));
853 103824 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_objectsid, 0, sub_size));
854 : }
855 103824 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objectsid_0, 0);
856 103824 : if (ndr->offset > ndr->relative_highest_offset) {
857 103824 : ndr->relative_highest_offset = ndr->offset;
858 : }
859 103824 : ndr->offset = _relative_save_offset;
860 : }
861 : }
862 202548 : return NDR_ERR_SUCCESS;
863 : }
864 :
865 2 : _PUBLIC_ void ndr_print_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(struct ndr_print *ndr, const char *name, const struct PAC_UPN_DNS_INFO_SAM_NAME_AND_SID *r)
866 : {
867 2 : ndr_print_struct(ndr, name, "PAC_UPN_DNS_INFO_SAM_NAME_AND_SID");
868 2 : if (r == NULL) { ndr_print_null(ndr); return; }
869 2 : ndr->depth++;
870 2 : ndr_print_uint16(ndr, "samaccountname_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->samaccountname):r->samaccountname_size);
871 : {
872 2 : libndr_flags _flags_save_string = ndr->flags;
873 2 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
874 2 : ndr_print_ptr(ndr, "samaccountname", r->samaccountname);
875 2 : ndr->depth++;
876 2 : if (r->samaccountname) {
877 2 : ndr_print_string(ndr, "samaccountname", r->samaccountname);
878 : }
879 2 : ndr->depth--;
880 2 : ndr->flags = _flags_save_string;
881 : }
882 2 : ndr_print_uint16(ndr, "objectsid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid(r->objectsid, ndr->flags):r->objectsid_size);
883 2 : ndr_print_ptr(ndr, "objectsid", r->objectsid);
884 2 : ndr->depth++;
885 2 : if (r->objectsid) {
886 2 : ndr_print_dom_sid(ndr, "objectsid", r->objectsid);
887 : }
888 2 : ndr->depth--;
889 2 : ndr->depth--;
890 : }
891 :
892 81580 : static enum ndr_err_code ndr_push_PAC_UPN_DNS_INFO_EX(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union PAC_UPN_DNS_INFO_EX *r)
893 : {
894 2388 : uint32_t level;
895 81580 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
896 81580 : if (ndr_flags & NDR_SCALARS) {
897 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
898 40790 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
899 40790 : NDR_CHECK(ndr_push_union_align(ndr, 5));
900 40790 : switch (level) {
901 40769 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID: {
902 40769 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, NDR_SCALARS, &r->sam_name_and_sid));
903 39596 : break; }
904 :
905 0 : default: {
906 0 : break; }
907 :
908 : }
909 : }
910 81580 : if (ndr_flags & NDR_BUFFERS) {
911 40790 : if (!(ndr_flags & NDR_SCALARS)) {
912 : /* We didn't get it above, and the token is not needed after this. */
913 40790 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
914 : }
915 40790 : switch (level) {
916 40769 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID:
917 40769 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, NDR_BUFFERS, &r->sam_name_and_sid));
918 39596 : break;
919 :
920 0 : default:
921 0 : break;
922 :
923 : }
924 : }
925 79192 : return NDR_ERR_SUCCESS;
926 : }
927 :
928 207674 : static enum ndr_err_code ndr_pull_PAC_UPN_DNS_INFO_EX(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union PAC_UPN_DNS_INFO_EX *r)
929 : {
930 5126 : uint32_t level;
931 207674 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
932 207674 : if (ndr_flags & NDR_SCALARS) {
933 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
934 103837 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
935 103837 : NDR_CHECK(ndr_pull_union_align(ndr, 5));
936 103837 : switch (level) {
937 103824 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID: {
938 103824 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, NDR_SCALARS, &r->sam_name_and_sid));
939 101274 : break; }
940 :
941 0 : default: {
942 0 : break; }
943 :
944 : }
945 : }
946 207674 : if (ndr_flags & NDR_BUFFERS) {
947 103837 : if (!(ndr_flags & NDR_SCALARS)) {
948 : /* We didn't get it above, and the token is not needed after this. */
949 103837 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
950 : }
951 103837 : switch (level) {
952 103824 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID:
953 103824 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, NDR_BUFFERS, &r->sam_name_and_sid));
954 101274 : break;
955 :
956 0 : default:
957 0 : break;
958 :
959 : }
960 : }
961 202548 : return NDR_ERR_SUCCESS;
962 : }
963 :
964 15 : _PUBLIC_ void ndr_print_PAC_UPN_DNS_INFO_EX(struct ndr_print *ndr, const char *name, const union PAC_UPN_DNS_INFO_EX *r)
965 : {
966 15 : uint32_t level;
967 15 : level = ndr_print_steal_switch_value(ndr, r);
968 15 : ndr_print_union(ndr, name, level, "PAC_UPN_DNS_INFO_EX");
969 15 : switch (level) {
970 2 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID:
971 2 : ndr_print_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, "sam_name_and_sid", &r->sam_name_and_sid);
972 2 : break;
973 :
974 0 : default:
975 0 : break;
976 :
977 : }
978 15 : }
979 :
980 81580 : static enum ndr_err_code ndr_push_PAC_UPN_DNS_INFO(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_UPN_DNS_INFO *r)
981 : {
982 81580 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
983 81580 : if (ndr_flags & NDR_SCALARS) {
984 40790 : NDR_CHECK(ndr_push_align(ndr, 5));
985 40790 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->upn_name)));
986 : {
987 40790 : libndr_flags _flags_save_string = ndr->flags;
988 40790 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
989 40790 : NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->upn_name));
990 40790 : ndr->flags = _flags_save_string;
991 : }
992 40790 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->dns_domain_name)));
993 : {
994 40790 : libndr_flags _flags_save_string = ndr->flags;
995 40790 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
996 40790 : NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->dns_domain_name));
997 40790 : ndr->flags = _flags_save_string;
998 : }
999 41984 : NDR_CHECK(ndr_push_PAC_UPN_DNS_FLAGS(ndr, NDR_SCALARS, r->flags));
1000 40790 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID));
1001 40790 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO_EX(ndr, NDR_SCALARS, &r->ex));
1002 40790 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1003 : }
1004 81580 : if (ndr_flags & NDR_BUFFERS) {
1005 : {
1006 40790 : libndr_flags _flags_save_string = ndr->flags;
1007 40790 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1008 40790 : if (r->upn_name) {
1009 40790 : NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->upn_name));
1010 : {
1011 1194 : struct ndr_push *_ndr_upn_name;
1012 40790 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_upn_name, 0, 2 * strlen_m(r->upn_name)));
1013 40790 : NDR_CHECK(ndr_push_string(_ndr_upn_name, NDR_SCALARS, r->upn_name));
1014 40790 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_upn_name, 0, 2 * strlen_m(r->upn_name)));
1015 : }
1016 : }
1017 40790 : ndr->flags = _flags_save_string;
1018 : }
1019 : {
1020 40790 : libndr_flags _flags_save_string = ndr->flags;
1021 40790 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1022 40790 : if (r->dns_domain_name) {
1023 40790 : NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->dns_domain_name));
1024 : {
1025 1194 : struct ndr_push *_ndr_dns_domain_name;
1026 40790 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_dns_domain_name, 0, 2 * strlen_m(r->dns_domain_name)));
1027 40790 : NDR_CHECK(ndr_push_string(_ndr_dns_domain_name, NDR_SCALARS, r->dns_domain_name));
1028 40790 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_dns_domain_name, 0, 2 * strlen_m(r->dns_domain_name)));
1029 : }
1030 : }
1031 40790 : ndr->flags = _flags_save_string;
1032 : }
1033 40790 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID));
1034 40790 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO_EX(ndr, NDR_BUFFERS, &r->ex));
1035 : }
1036 79192 : return NDR_ERR_SUCCESS;
1037 : }
1038 :
1039 207674 : static enum ndr_err_code ndr_pull_PAC_UPN_DNS_INFO(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_UPN_DNS_INFO *r)
1040 : {
1041 5126 : uint16_t _ptr_upn_name;
1042 207674 : TALLOC_CTX *_mem_save_upn_name_0 = NULL;
1043 5126 : uint16_t _ptr_dns_domain_name;
1044 207674 : TALLOC_CTX *_mem_save_dns_domain_name_0 = NULL;
1045 207674 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1046 207674 : if (ndr_flags & NDR_SCALARS) {
1047 103837 : NDR_CHECK(ndr_pull_align(ndr, 5));
1048 103837 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->upn_name_size));
1049 : {
1050 103837 : libndr_flags _flags_save_string = ndr->flags;
1051 103837 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1052 103837 : NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_upn_name));
1053 103837 : if (_ptr_upn_name) {
1054 103837 : NDR_PULL_ALLOC(ndr, r->upn_name);
1055 103837 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->upn_name, _ptr_upn_name));
1056 : } else {
1057 0 : r->upn_name = NULL;
1058 : }
1059 103837 : ndr->flags = _flags_save_string;
1060 : }
1061 103837 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->dns_domain_name_size));
1062 : {
1063 103837 : libndr_flags _flags_save_string = ndr->flags;
1064 103837 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1065 103837 : NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_dns_domain_name));
1066 103837 : if (_ptr_dns_domain_name) {
1067 103837 : NDR_PULL_ALLOC(ndr, r->dns_domain_name);
1068 103837 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dns_domain_name, _ptr_dns_domain_name));
1069 : } else {
1070 0 : r->dns_domain_name = NULL;
1071 : }
1072 103837 : ndr->flags = _flags_save_string;
1073 : }
1074 106400 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_FLAGS(ndr, NDR_SCALARS, &r->flags));
1075 103837 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID));
1076 103837 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO_EX(ndr, NDR_SCALARS, &r->ex));
1077 103837 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1078 : }
1079 207674 : if (ndr_flags & NDR_BUFFERS) {
1080 : {
1081 103837 : libndr_flags _flags_save_string = ndr->flags;
1082 103837 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1083 103837 : if (r->upn_name) {
1084 2563 : uint32_t _relative_save_offset;
1085 103837 : _relative_save_offset = ndr->offset;
1086 103837 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->upn_name));
1087 103837 : _mem_save_upn_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1088 103837 : NDR_PULL_SET_MEM_CTX(ndr, r->upn_name, 0);
1089 : {
1090 2563 : struct ndr_pull *_ndr_upn_name;
1091 103837 : ssize_t sub_size = r->upn_name_size;
1092 103837 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_upn_name, 0, sub_size));
1093 103837 : NDR_CHECK(ndr_pull_string(_ndr_upn_name, NDR_SCALARS, &r->upn_name));
1094 103837 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_upn_name, 0, sub_size));
1095 : }
1096 103837 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_upn_name_0, 0);
1097 103837 : if (ndr->offset > ndr->relative_highest_offset) {
1098 103837 : ndr->relative_highest_offset = ndr->offset;
1099 : }
1100 103837 : ndr->offset = _relative_save_offset;
1101 : }
1102 103837 : ndr->flags = _flags_save_string;
1103 : }
1104 : {
1105 103837 : libndr_flags _flags_save_string = ndr->flags;
1106 103837 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1107 103837 : if (r->dns_domain_name) {
1108 2563 : uint32_t _relative_save_offset;
1109 103837 : _relative_save_offset = ndr->offset;
1110 103837 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dns_domain_name));
1111 103837 : _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1112 103837 : NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
1113 : {
1114 2563 : struct ndr_pull *_ndr_dns_domain_name;
1115 103837 : ssize_t sub_size = r->dns_domain_name_size;
1116 103837 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_dns_domain_name, 0, sub_size));
1117 103837 : NDR_CHECK(ndr_pull_string(_ndr_dns_domain_name, NDR_SCALARS, &r->dns_domain_name));
1118 103837 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_dns_domain_name, 0, sub_size));
1119 : }
1120 103837 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
1121 103837 : if (ndr->offset > ndr->relative_highest_offset) {
1122 103837 : ndr->relative_highest_offset = ndr->offset;
1123 : }
1124 103837 : ndr->offset = _relative_save_offset;
1125 : }
1126 103837 : ndr->flags = _flags_save_string;
1127 : }
1128 103837 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID));
1129 103837 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO_EX(ndr, NDR_BUFFERS, &r->ex));
1130 : }
1131 202548 : return NDR_ERR_SUCCESS;
1132 : }
1133 :
1134 15 : _PUBLIC_ void ndr_print_PAC_UPN_DNS_INFO(struct ndr_print *ndr, const char *name, const struct PAC_UPN_DNS_INFO *r)
1135 : {
1136 15 : ndr_print_struct(ndr, name, "PAC_UPN_DNS_INFO");
1137 15 : if (r == NULL) { ndr_print_null(ndr); return; }
1138 15 : ndr->depth++;
1139 15 : ndr_print_uint16(ndr, "upn_name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->upn_name):r->upn_name_size);
1140 : {
1141 15 : libndr_flags _flags_save_string = ndr->flags;
1142 15 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1143 15 : ndr_print_ptr(ndr, "upn_name", r->upn_name);
1144 15 : ndr->depth++;
1145 15 : if (r->upn_name) {
1146 15 : ndr_print_string(ndr, "upn_name", r->upn_name);
1147 : }
1148 15 : ndr->depth--;
1149 15 : ndr->flags = _flags_save_string;
1150 : }
1151 15 : ndr_print_uint16(ndr, "dns_domain_name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->dns_domain_name):r->dns_domain_name_size);
1152 : {
1153 15 : libndr_flags _flags_save_string = ndr->flags;
1154 15 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1155 15 : ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
1156 15 : ndr->depth++;
1157 15 : if (r->dns_domain_name) {
1158 15 : ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
1159 : }
1160 15 : ndr->depth--;
1161 15 : ndr->flags = _flags_save_string;
1162 : }
1163 15 : ndr_print_PAC_UPN_DNS_FLAGS(ndr, "flags", r->flags);
1164 15 : ndr_print_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID);
1165 15 : ndr_print_PAC_UPN_DNS_INFO_EX(ndr, "ex", &r->ex);
1166 15 : ndr->depth--;
1167 : }
1168 :
1169 35594 : static enum ndr_err_code ndr_push_PAC_ATTRIBUTE_INFO_FLAGS(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t r)
1170 : {
1171 35594 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1172 34424 : return NDR_ERR_SUCCESS;
1173 : }
1174 :
1175 25076 : static enum ndr_err_code ndr_pull_PAC_ATTRIBUTE_INFO_FLAGS(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *r)
1176 : {
1177 632 : uint32_t v;
1178 25076 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1179 25076 : *r = v;
1180 25076 : return NDR_ERR_SUCCESS;
1181 : }
1182 :
1183 0 : _PUBLIC_ void ndr_print_PAC_ATTRIBUTE_INFO_FLAGS(struct ndr_print *ndr, const char *name, uint32_t r)
1184 : {
1185 0 : ndr_print_uint32(ndr, name, r);
1186 0 : ndr->depth++;
1187 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PAC_ATTRIBUTE_FLAG_PAC_WAS_REQUESTED", PAC_ATTRIBUTE_FLAG_PAC_WAS_REQUESTED, r);
1188 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PAC_ATTRIBUTE_FLAG_PAC_WAS_GIVEN_IMPLICITLY", PAC_ATTRIBUTE_FLAG_PAC_WAS_GIVEN_IMPLICITLY, r);
1189 0 : ndr->depth--;
1190 0 : }
1191 :
1192 35594 : static enum ndr_err_code ndr_push_PAC_ATTRIBUTES_INFO(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_ATTRIBUTES_INFO *r)
1193 : {
1194 35594 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1195 35594 : if (ndr_flags & NDR_SCALARS) {
1196 35594 : NDR_CHECK(ndr_push_align(ndr, 4));
1197 35594 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags_length));
1198 36764 : NDR_CHECK(ndr_push_PAC_ATTRIBUTE_INFO_FLAGS(ndr, NDR_SCALARS, r->flags));
1199 35594 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1200 : }
1201 35594 : if (ndr_flags & NDR_BUFFERS) {
1202 1170 : }
1203 35594 : return NDR_ERR_SUCCESS;
1204 : }
1205 :
1206 25076 : static enum ndr_err_code ndr_pull_PAC_ATTRIBUTES_INFO(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_ATTRIBUTES_INFO *r)
1207 : {
1208 25076 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1209 25076 : if (ndr_flags & NDR_SCALARS) {
1210 25076 : NDR_CHECK(ndr_pull_align(ndr, 4));
1211 25076 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags_length));
1212 25708 : NDR_CHECK(ndr_pull_PAC_ATTRIBUTE_INFO_FLAGS(ndr, NDR_SCALARS, &r->flags));
1213 25076 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1214 : }
1215 25076 : if (ndr_flags & NDR_BUFFERS) {
1216 632 : }
1217 25076 : return NDR_ERR_SUCCESS;
1218 : }
1219 :
1220 0 : _PUBLIC_ void ndr_print_PAC_ATTRIBUTES_INFO(struct ndr_print *ndr, const char *name, const struct PAC_ATTRIBUTES_INFO *r)
1221 : {
1222 0 : ndr_print_struct(ndr, name, "PAC_ATTRIBUTES_INFO");
1223 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1224 0 : ndr->depth++;
1225 0 : ndr_print_uint32(ndr, "flags_length", r->flags_length);
1226 0 : ndr_print_PAC_ATTRIBUTE_INFO_FLAGS(ndr, "flags", r->flags);
1227 0 : ndr->depth--;
1228 : }
1229 :
1230 35588 : static enum ndr_err_code ndr_push_PAC_REQUESTER_SID(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_REQUESTER_SID *r)
1231 : {
1232 35588 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1233 35588 : if (ndr_flags & NDR_SCALARS) {
1234 35588 : NDR_CHECK(ndr_push_align(ndr, 4));
1235 35588 : NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sid));
1236 35588 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1237 : }
1238 35588 : if (ndr_flags & NDR_BUFFERS) {
1239 1170 : }
1240 35588 : return NDR_ERR_SUCCESS;
1241 : }
1242 :
1243 54078 : static enum ndr_err_code ndr_pull_PAC_REQUESTER_SID(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_REQUESTER_SID *r)
1244 : {
1245 54078 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1246 54078 : if (ndr_flags & NDR_SCALARS) {
1247 54078 : NDR_CHECK(ndr_pull_align(ndr, 4));
1248 54078 : NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sid));
1249 54078 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1250 : }
1251 54078 : if (ndr_flags & NDR_BUFFERS) {
1252 1667 : }
1253 54078 : return NDR_ERR_SUCCESS;
1254 : }
1255 :
1256 0 : _PUBLIC_ void ndr_print_PAC_REQUESTER_SID(struct ndr_print *ndr, const char *name, const struct PAC_REQUESTER_SID *r)
1257 : {
1258 0 : ndr_print_struct(ndr, name, "PAC_REQUESTER_SID");
1259 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1260 0 : ndr->depth++;
1261 0 : ndr_print_dom_sid(ndr, "sid", &r->sid);
1262 0 : ndr->depth--;
1263 : }
1264 :
1265 88292 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_LOGON_INFO_CTR(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_LOGON_INFO_CTR *r)
1266 : {
1267 88292 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1268 88292 : if (ndr_flags & NDR_SCALARS) {
1269 88292 : NDR_CHECK(ndr_push_align(ndr, 5));
1270 88292 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
1271 88292 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1272 : }
1273 88292 : if (ndr_flags & NDR_BUFFERS) {
1274 88292 : if (r->info) {
1275 88292 : NDR_CHECK(ndr_push_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
1276 : }
1277 : }
1278 85422 : return NDR_ERR_SUCCESS;
1279 : }
1280 :
1281 104400 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_LOGON_INFO_CTR(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_LOGON_INFO_CTR *r)
1282 : {
1283 2572 : uint32_t _ptr_info;
1284 104400 : TALLOC_CTX *_mem_save_info_0 = NULL;
1285 104400 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1286 104400 : if (ndr_flags & NDR_SCALARS) {
1287 104400 : NDR_CHECK(ndr_pull_align(ndr, 5));
1288 104400 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
1289 104400 : if (_ptr_info) {
1290 104400 : NDR_PULL_ALLOC(ndr, r->info);
1291 : } else {
1292 0 : r->info = NULL;
1293 : }
1294 104400 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1295 : }
1296 104400 : if (ndr_flags & NDR_BUFFERS) {
1297 104400 : if (r->info) {
1298 104400 : _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1299 104400 : NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
1300 104400 : NDR_CHECK(ndr_pull_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
1301 104400 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1302 : }
1303 : }
1304 101828 : return NDR_ERR_SUCCESS;
1305 : }
1306 :
1307 0 : static void ndr_print_flags_PAC_LOGON_INFO_CTR(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_LOGON_INFO_CTR *r)
1308 : {
1309 0 : ndr_print_PAC_LOGON_INFO_CTR(ndr, name, r);
1310 0 : }
1311 :
1312 15 : _PUBLIC_ void ndr_print_PAC_LOGON_INFO_CTR(struct ndr_print *ndr, const char *name, const struct PAC_LOGON_INFO_CTR *r)
1313 : {
1314 15 : ndr_print_struct(ndr, name, "PAC_LOGON_INFO_CTR");
1315 15 : if (r == NULL) { ndr_print_null(ndr); return; }
1316 15 : ndr->depth++;
1317 15 : ndr_print_ptr(ndr, "info", r->info);
1318 15 : ndr->depth++;
1319 15 : if (r->info) {
1320 15 : ndr_print_PAC_LOGON_INFO(ndr, "info", r->info);
1321 : }
1322 15 : ndr->depth--;
1323 15 : ndr->depth--;
1324 : }
1325 :
1326 188 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_CONSTRAINED_DELEGATION_CTR(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_CONSTRAINED_DELEGATION_CTR *r)
1327 : {
1328 188 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1329 188 : if (ndr_flags & NDR_SCALARS) {
1330 188 : NDR_CHECK(ndr_push_align(ndr, 5));
1331 188 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
1332 188 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1333 : }
1334 188 : if (ndr_flags & NDR_BUFFERS) {
1335 188 : if (r->info) {
1336 188 : NDR_CHECK(ndr_push_PAC_CONSTRAINED_DELEGATION(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
1337 : }
1338 : }
1339 188 : return NDR_ERR_SUCCESS;
1340 : }
1341 :
1342 295 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_CONSTRAINED_DELEGATION_CTR(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_CONSTRAINED_DELEGATION_CTR *r)
1343 : {
1344 0 : uint32_t _ptr_info;
1345 295 : TALLOC_CTX *_mem_save_info_0 = NULL;
1346 295 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1347 295 : if (ndr_flags & NDR_SCALARS) {
1348 295 : NDR_CHECK(ndr_pull_align(ndr, 5));
1349 295 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
1350 295 : if (_ptr_info) {
1351 295 : NDR_PULL_ALLOC(ndr, r->info);
1352 : } else {
1353 0 : r->info = NULL;
1354 : }
1355 295 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1356 : }
1357 295 : if (ndr_flags & NDR_BUFFERS) {
1358 295 : if (r->info) {
1359 295 : _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1360 295 : NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
1361 295 : NDR_CHECK(ndr_pull_PAC_CONSTRAINED_DELEGATION(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
1362 295 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1363 : }
1364 : }
1365 295 : return NDR_ERR_SUCCESS;
1366 : }
1367 :
1368 0 : static void ndr_print_flags_PAC_CONSTRAINED_DELEGATION_CTR(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_CONSTRAINED_DELEGATION_CTR *r)
1369 : {
1370 0 : ndr_print_PAC_CONSTRAINED_DELEGATION_CTR(ndr, name, r);
1371 0 : }
1372 :
1373 0 : _PUBLIC_ void ndr_print_PAC_CONSTRAINED_DELEGATION_CTR(struct ndr_print *ndr, const char *name, const struct PAC_CONSTRAINED_DELEGATION_CTR *r)
1374 : {
1375 0 : ndr_print_struct(ndr, name, "PAC_CONSTRAINED_DELEGATION_CTR");
1376 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1377 0 : ndr->depth++;
1378 0 : ndr_print_ptr(ndr, "info", r->info);
1379 0 : ndr->depth++;
1380 0 : if (r->info) {
1381 0 : ndr_print_PAC_CONSTRAINED_DELEGATION(ndr, "info", r->info);
1382 : }
1383 0 : ndr->depth--;
1384 0 : ndr->depth--;
1385 : }
1386 :
1387 361 : static enum ndr_err_code ndr_push_PAC_DEVICE_INFO(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_DEVICE_INFO *r)
1388 : {
1389 0 : uint32_t cntr_sids_1;
1390 0 : uint32_t cntr_domain_groups_1;
1391 361 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1392 361 : if (ndr_flags & NDR_SCALARS) {
1393 361 : NDR_CHECK(ndr_push_align(ndr, 5));
1394 361 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
1395 361 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));
1396 361 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
1397 361 : NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->groups));
1398 361 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_count));
1399 361 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
1400 361 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->domain_group_count));
1401 361 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_groups));
1402 361 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1403 : }
1404 361 : if (ndr_flags & NDR_BUFFERS) {
1405 361 : if (r->domain_sid) {
1406 361 : NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
1407 : }
1408 361 : NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_BUFFERS, &r->groups));
1409 361 : if (r->sids) {
1410 359 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->sid_count));
1411 1039 : for (cntr_sids_1 = 0; cntr_sids_1 < (r->sid_count); cntr_sids_1++) {
1412 680 : NDR_CHECK(ndr_push_netr_SidAttr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1413 : }
1414 1039 : for (cntr_sids_1 = 0; cntr_sids_1 < (r->sid_count); cntr_sids_1++) {
1415 680 : NDR_CHECK(ndr_push_netr_SidAttr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1416 : }
1417 : }
1418 361 : if (r->domain_groups) {
1419 60 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->domain_group_count));
1420 140 : for (cntr_domain_groups_1 = 0; cntr_domain_groups_1 < (r->domain_group_count); cntr_domain_groups_1++) {
1421 80 : NDR_CHECK(ndr_push_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_SCALARS, &r->domain_groups[cntr_domain_groups_1]));
1422 : }
1423 140 : for (cntr_domain_groups_1 = 0; cntr_domain_groups_1 < (r->domain_group_count); cntr_domain_groups_1++) {
1424 80 : NDR_CHECK(ndr_push_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_BUFFERS, &r->domain_groups[cntr_domain_groups_1]));
1425 : }
1426 : }
1427 : }
1428 361 : return NDR_ERR_SUCCESS;
1429 : }
1430 :
1431 136 : static enum ndr_err_code ndr_pull_PAC_DEVICE_INFO(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_DEVICE_INFO *r)
1432 : {
1433 0 : uint32_t _ptr_domain_sid;
1434 136 : TALLOC_CTX *_mem_save_domain_sid_0 = NULL;
1435 0 : uint32_t _ptr_sids;
1436 136 : uint32_t size_sids_1 = 0;
1437 0 : uint32_t cntr_sids_1;
1438 136 : TALLOC_CTX *_mem_save_sids_0 = NULL;
1439 136 : TALLOC_CTX *_mem_save_sids_1 = NULL;
1440 0 : uint32_t _ptr_domain_groups;
1441 136 : uint32_t size_domain_groups_1 = 0;
1442 0 : uint32_t cntr_domain_groups_1;
1443 136 : TALLOC_CTX *_mem_save_domain_groups_0 = NULL;
1444 136 : TALLOC_CTX *_mem_save_domain_groups_1 = NULL;
1445 136 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1446 136 : if (ndr_flags & NDR_SCALARS) {
1447 136 : NDR_CHECK(ndr_pull_align(ndr, 5));
1448 136 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
1449 136 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));
1450 136 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_sid));
1451 136 : if (_ptr_domain_sid) {
1452 136 : NDR_PULL_ALLOC(ndr, r->domain_sid);
1453 : } else {
1454 0 : r->domain_sid = NULL;
1455 : }
1456 136 : NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->groups));
1457 136 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_count));
1458 136 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
1459 136 : if (_ptr_sids) {
1460 132 : NDR_PULL_ALLOC(ndr, r->sids);
1461 : } else {
1462 4 : r->sids = NULL;
1463 : }
1464 136 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->domain_group_count));
1465 136 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_groups));
1466 136 : if (_ptr_domain_groups) {
1467 104 : NDR_PULL_ALLOC(ndr, r->domain_groups);
1468 : } else {
1469 32 : r->domain_groups = NULL;
1470 : }
1471 136 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1472 : }
1473 136 : if (ndr_flags & NDR_BUFFERS) {
1474 136 : if (r->domain_sid) {
1475 136 : _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1476 136 : NDR_PULL_SET_MEM_CTX(ndr, r->domain_sid, 0);
1477 136 : NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
1478 136 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, 0);
1479 : }
1480 136 : NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_BUFFERS, &r->groups));
1481 136 : if (r->sids) {
1482 132 : _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1483 132 : NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1484 132 : NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
1485 132 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->sids, &size_sids_1));
1486 132 : NDR_PULL_ALLOC_N(ndr, r->sids, size_sids_1);
1487 132 : _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1488 132 : NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1489 326 : for (cntr_sids_1 = 0; cntr_sids_1 < (size_sids_1); cntr_sids_1++) {
1490 194 : NDR_CHECK(ndr_pull_netr_SidAttr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1491 : }
1492 326 : for (cntr_sids_1 = 0; cntr_sids_1 < (size_sids_1); cntr_sids_1++) {
1493 194 : NDR_CHECK(ndr_pull_netr_SidAttr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1494 : }
1495 132 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
1496 132 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
1497 : }
1498 136 : if (r->domain_groups) {
1499 104 : _mem_save_domain_groups_0 = NDR_PULL_GET_MEM_CTX(ndr);
1500 104 : NDR_PULL_SET_MEM_CTX(ndr, r->domain_groups, 0);
1501 104 : NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_groups));
1502 104 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->domain_groups, &size_domain_groups_1));
1503 104 : NDR_PULL_ALLOC_N(ndr, r->domain_groups, size_domain_groups_1);
1504 104 : _mem_save_domain_groups_1 = NDR_PULL_GET_MEM_CTX(ndr);
1505 104 : NDR_PULL_SET_MEM_CTX(ndr, r->domain_groups, 0);
1506 246 : for (cntr_domain_groups_1 = 0; cntr_domain_groups_1 < (size_domain_groups_1); cntr_domain_groups_1++) {
1507 142 : NDR_CHECK(ndr_pull_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_SCALARS, &r->domain_groups[cntr_domain_groups_1]));
1508 : }
1509 246 : for (cntr_domain_groups_1 = 0; cntr_domain_groups_1 < (size_domain_groups_1); cntr_domain_groups_1++) {
1510 142 : NDR_CHECK(ndr_pull_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_BUFFERS, &r->domain_groups[cntr_domain_groups_1]));
1511 : }
1512 104 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_groups_1, 0);
1513 104 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_groups_0, 0);
1514 : }
1515 136 : if (r->sids) {
1516 132 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->sid_count));
1517 : }
1518 330 : for (cntr_sids_1 = 0; cntr_sids_1 < (size_sids_1); cntr_sids_1++) {
1519 0 : }
1520 136 : if (r->domain_groups) {
1521 104 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domain_groups, r->domain_group_count));
1522 : }
1523 278 : for (cntr_domain_groups_1 = 0; cntr_domain_groups_1 < (size_domain_groups_1); cntr_domain_groups_1++) {
1524 0 : }
1525 : }
1526 136 : return NDR_ERR_SUCCESS;
1527 : }
1528 :
1529 0 : _PUBLIC_ void ndr_print_PAC_DEVICE_INFO(struct ndr_print *ndr, const char *name, const struct PAC_DEVICE_INFO *r)
1530 : {
1531 0 : uint32_t cntr_sids_1;
1532 0 : uint32_t cntr_domain_groups_1;
1533 0 : ndr_print_struct(ndr, name, "PAC_DEVICE_INFO");
1534 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1535 0 : ndr->depth++;
1536 0 : ndr_print_uint32(ndr, "rid", r->rid);
1537 0 : ndr_print_uint32(ndr, "primary_gid", r->primary_gid);
1538 0 : ndr_print_ptr(ndr, "domain_sid", r->domain_sid);
1539 0 : ndr->depth++;
1540 0 : if (r->domain_sid) {
1541 0 : ndr_print_dom_sid2(ndr, "domain_sid", r->domain_sid);
1542 : }
1543 0 : ndr->depth--;
1544 0 : ndr_print_samr_RidWithAttributeArray(ndr, "groups", &r->groups);
1545 0 : ndr_print_uint32(ndr, "sid_count", r->sid_count);
1546 0 : ndr_print_ptr(ndr, "sids", r->sids);
1547 0 : ndr->depth++;
1548 0 : if (r->sids) {
1549 0 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "sids", (uint32_t)(r->sid_count));
1550 0 : ndr->depth++;
1551 0 : for (cntr_sids_1 = 0; cntr_sids_1 < (r->sid_count); cntr_sids_1++) {
1552 0 : ndr_print_netr_SidAttr(ndr, "sids", &r->sids[cntr_sids_1]);
1553 : }
1554 0 : ndr->depth--;
1555 : }
1556 0 : ndr->depth--;
1557 0 : ndr_print_uint32(ndr, "domain_group_count", r->domain_group_count);
1558 0 : ndr_print_ptr(ndr, "domain_groups", r->domain_groups);
1559 0 : ndr->depth++;
1560 0 : if (r->domain_groups) {
1561 0 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "domain_groups", (uint32_t)(r->domain_group_count));
1562 0 : ndr->depth++;
1563 0 : for (cntr_domain_groups_1 = 0; cntr_domain_groups_1 < (r->domain_group_count); cntr_domain_groups_1++) {
1564 0 : ndr_print_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, "domain_groups", &r->domain_groups[cntr_domain_groups_1]);
1565 : }
1566 0 : ndr->depth--;
1567 : }
1568 0 : ndr->depth--;
1569 0 : ndr->depth--;
1570 : }
1571 :
1572 361 : static enum ndr_err_code ndr_push_PAC_DEVICE_INFO_CTR(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_DEVICE_INFO_CTR *r)
1573 : {
1574 361 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1575 361 : if (ndr_flags & NDR_SCALARS) {
1576 361 : NDR_CHECK(ndr_push_align(ndr, 5));
1577 361 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
1578 361 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1579 : }
1580 361 : if (ndr_flags & NDR_BUFFERS) {
1581 361 : if (r->info) {
1582 361 : NDR_CHECK(ndr_push_PAC_DEVICE_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
1583 : }
1584 : }
1585 361 : return NDR_ERR_SUCCESS;
1586 : }
1587 :
1588 136 : static enum ndr_err_code ndr_pull_PAC_DEVICE_INFO_CTR(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_DEVICE_INFO_CTR *r)
1589 : {
1590 0 : uint32_t _ptr_info;
1591 136 : TALLOC_CTX *_mem_save_info_0 = NULL;
1592 136 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1593 136 : if (ndr_flags & NDR_SCALARS) {
1594 136 : NDR_CHECK(ndr_pull_align(ndr, 5));
1595 136 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
1596 136 : if (_ptr_info) {
1597 136 : NDR_PULL_ALLOC(ndr, r->info);
1598 : } else {
1599 0 : r->info = NULL;
1600 : }
1601 136 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1602 : }
1603 136 : if (ndr_flags & NDR_BUFFERS) {
1604 136 : if (r->info) {
1605 136 : _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1606 136 : NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
1607 136 : NDR_CHECK(ndr_pull_PAC_DEVICE_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
1608 136 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1609 : }
1610 : }
1611 136 : return NDR_ERR_SUCCESS;
1612 : }
1613 :
1614 0 : _PUBLIC_ void ndr_print_PAC_DEVICE_INFO_CTR(struct ndr_print *ndr, const char *name, const struct PAC_DEVICE_INFO_CTR *r)
1615 : {
1616 0 : ndr_print_struct(ndr, name, "PAC_DEVICE_INFO_CTR");
1617 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1618 0 : ndr->depth++;
1619 0 : ndr_print_ptr(ndr, "info", r->info);
1620 0 : ndr->depth++;
1621 0 : if (r->info) {
1622 0 : ndr_print_PAC_DEVICE_INFO(ndr, "info", r->info);
1623 : }
1624 0 : ndr->depth--;
1625 0 : ndr->depth--;
1626 : }
1627 :
1628 156837 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_TYPE(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum PAC_TYPE r)
1629 : {
1630 156837 : NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1631 156684 : return NDR_ERR_SUCCESS;
1632 : }
1633 :
1634 270933 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_TYPE(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum PAC_TYPE *r)
1635 : {
1636 275 : uint32_t v;
1637 270933 : NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1638 270933 : *r = v;
1639 270933 : return NDR_ERR_SUCCESS;
1640 : }
1641 :
1642 139 : _PUBLIC_ void ndr_print_PAC_TYPE(struct ndr_print *ndr, const char *name, enum PAC_TYPE r)
1643 : {
1644 139 : const char *val = NULL;
1645 :
1646 139 : switch (r) {
1647 25 : case PAC_TYPE_LOGON_INFO: val = "PAC_TYPE_LOGON_INFO"; break;
1648 8 : case PAC_TYPE_CREDENTIAL_INFO: val = "PAC_TYPE_CREDENTIAL_INFO"; break;
1649 25 : case PAC_TYPE_SRV_CHECKSUM: val = "PAC_TYPE_SRV_CHECKSUM"; break;
1650 25 : case PAC_TYPE_KDC_CHECKSUM: val = "PAC_TYPE_KDC_CHECKSUM"; break;
1651 25 : case PAC_TYPE_LOGON_NAME: val = "PAC_TYPE_LOGON_NAME"; break;
1652 0 : case PAC_TYPE_CONSTRAINED_DELEGATION: val = "PAC_TYPE_CONSTRAINED_DELEGATION"; break;
1653 25 : case PAC_TYPE_UPN_DNS_INFO: val = "PAC_TYPE_UPN_DNS_INFO"; break;
1654 0 : case PAC_TYPE_CLIENT_CLAIMS_INFO: val = "PAC_TYPE_CLIENT_CLAIMS_INFO"; break;
1655 0 : case PAC_TYPE_DEVICE_INFO: val = "PAC_TYPE_DEVICE_INFO"; break;
1656 0 : case PAC_TYPE_DEVICE_CLAIMS_INFO: val = "PAC_TYPE_DEVICE_CLAIMS_INFO"; break;
1657 4 : case PAC_TYPE_TICKET_CHECKSUM: val = "PAC_TYPE_TICKET_CHECKSUM"; break;
1658 0 : case PAC_TYPE_ATTRIBUTES_INFO: val = "PAC_TYPE_ATTRIBUTES_INFO"; break;
1659 0 : case PAC_TYPE_REQUESTER_SID: val = "PAC_TYPE_REQUESTER_SID"; break;
1660 0 : case PAC_TYPE_FULL_CHECKSUM: val = "PAC_TYPE_FULL_CHECKSUM"; break;
1661 : }
1662 139 : ndr_print_enum(ndr, name, "ENUM", val, r);
1663 139 : }
1664 :
1665 140427 : static enum ndr_err_code ndr_push_DATA_BLOB_REM(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct DATA_BLOB_REM *r)
1666 : {
1667 140427 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1668 140427 : if (ndr_flags & NDR_SCALARS) {
1669 140427 : NDR_CHECK(ndr_push_align(ndr, 4));
1670 : {
1671 140427 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1672 140427 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1673 140427 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
1674 140427 : ndr->flags = _flags_save_DATA_BLOB;
1675 : }
1676 140427 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1677 : }
1678 140427 : if (ndr_flags & NDR_BUFFERS) {
1679 82 : }
1680 140427 : return NDR_ERR_SUCCESS;
1681 : }
1682 :
1683 119783 : static enum ndr_err_code ndr_pull_DATA_BLOB_REM(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct DATA_BLOB_REM *r)
1684 : {
1685 119783 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1686 119783 : if (ndr_flags & NDR_SCALARS) {
1687 119783 : NDR_CHECK(ndr_pull_align(ndr, 4));
1688 : {
1689 119783 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1690 119783 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1691 119783 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
1692 119783 : ndr->flags = _flags_save_DATA_BLOB;
1693 : }
1694 119783 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1695 : }
1696 119783 : if (ndr_flags & NDR_BUFFERS) {
1697 99 : }
1698 119783 : return NDR_ERR_SUCCESS;
1699 : }
1700 :
1701 54 : _PUBLIC_ void ndr_print_DATA_BLOB_REM(struct ndr_print *ndr, const char *name, const struct DATA_BLOB_REM *r)
1702 : {
1703 54 : ndr_print_struct(ndr, name, "DATA_BLOB_REM");
1704 54 : if (r == NULL) { ndr_print_null(ndr); return; }
1705 54 : ndr->depth++;
1706 : {
1707 54 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1708 54 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1709 54 : ndr_print_DATA_BLOB(ndr, "remaining", r->remaining);
1710 54 : ndr->flags = _flags_save_DATA_BLOB;
1711 : }
1712 54 : ndr->depth--;
1713 : }
1714 :
1715 244220 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_INFO(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union PAC_INFO *r)
1716 : {
1717 6548 : uint32_t level;
1718 244220 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1719 244220 : if (ndr_flags & NDR_SCALARS) {
1720 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
1721 244220 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
1722 244220 : NDR_CHECK(ndr_push_union_align(ndr, 5));
1723 244220 : switch (level) {
1724 88292 : case PAC_TYPE_LOGON_INFO: {
1725 : {
1726 2870 : struct ndr_push *_ndr_logon_info;
1727 88292 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_logon_info, 0xFFFFFC01, -1));
1728 88292 : NDR_CHECK(ndr_push_PAC_LOGON_INFO_CTR(_ndr_logon_info, NDR_SCALARS|NDR_BUFFERS, &r->logon_info));
1729 88292 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_logon_info, 0xFFFFFC01, -1));
1730 : }
1731 88292 : break; }
1732 :
1733 12 : case PAC_TYPE_CREDENTIAL_INFO: {
1734 12 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_INFO(ndr, NDR_SCALARS, &r->credential_info));
1735 0 : break; }
1736 :
1737 9900 : case PAC_TYPE_SRV_CHECKSUM: {
1738 9900 : NDR_CHECK(ndr_push_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->srv_cksum));
1739 9858 : break; }
1740 :
1741 9879 : case PAC_TYPE_KDC_CHECKSUM: {
1742 9879 : NDR_CHECK(ndr_push_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->kdc_cksum));
1743 9837 : break; }
1744 :
1745 9930 : case PAC_TYPE_LOGON_NAME: {
1746 9930 : NDR_CHECK(ndr_push_PAC_LOGON_NAME(ndr, NDR_SCALARS, &r->logon_name));
1747 9888 : break; }
1748 :
1749 188 : case PAC_TYPE_CONSTRAINED_DELEGATION: {
1750 : {
1751 0 : struct ndr_push *_ndr_constrained_delegation;
1752 188 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_constrained_delegation, 0xFFFFFC01, -1));
1753 188 : NDR_CHECK(ndr_push_PAC_CONSTRAINED_DELEGATION_CTR(_ndr_constrained_delegation, NDR_SCALARS|NDR_BUFFERS, &r->constrained_delegation));
1754 188 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_constrained_delegation, 0xFFFFFC01, -1));
1755 : }
1756 188 : break; }
1757 :
1758 40790 : case PAC_TYPE_UPN_DNS_INFO: {
1759 40790 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO(ndr, NDR_SCALARS, &r->upn_dns_info));
1760 39596 : break; }
1761 :
1762 1740 : case PAC_TYPE_TICKET_CHECKSUM: {
1763 1740 : NDR_CHECK(ndr_push_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->ticket_checksum));
1764 1734 : break; }
1765 :
1766 35594 : case PAC_TYPE_ATTRIBUTES_INFO: {
1767 35594 : NDR_CHECK(ndr_push_PAC_ATTRIBUTES_INFO(ndr, NDR_SCALARS, &r->attributes_info));
1768 34424 : break; }
1769 :
1770 35588 : case PAC_TYPE_REQUESTER_SID: {
1771 35588 : NDR_CHECK(ndr_push_PAC_REQUESTER_SID(ndr, NDR_SCALARS, &r->requester_sid));
1772 34418 : break; }
1773 :
1774 9786 : case PAC_TYPE_CLIENT_CLAIMS_INFO: {
1775 : {
1776 0 : struct ndr_push *_ndr_client_claims_info;
1777 9786 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_client_claims_info, 0, -1));
1778 9786 : NDR_CHECK(ndr_push_DATA_BLOB_REM(_ndr_client_claims_info, NDR_SCALARS, &r->client_claims_info));
1779 9786 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_client_claims_info, 0, -1));
1780 : }
1781 9786 : break; }
1782 :
1783 361 : case PAC_TYPE_DEVICE_INFO: {
1784 : {
1785 0 : struct ndr_push *_ndr_device_info;
1786 361 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_device_info, 0xFFFFFC01, -1));
1787 361 : NDR_CHECK(ndr_push_PAC_DEVICE_INFO_CTR(_ndr_device_info, NDR_SCALARS|NDR_BUFFERS, &r->device_info));
1788 361 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_device_info, 0xFFFFFC01, -1));
1789 : }
1790 361 : break; }
1791 :
1792 288 : case PAC_TYPE_DEVICE_CLAIMS_INFO: {
1793 : {
1794 0 : struct ndr_push *_ndr_device_claims_info;
1795 288 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_device_claims_info, 0, -1));
1796 288 : NDR_CHECK(ndr_push_DATA_BLOB_REM(_ndr_device_claims_info, NDR_SCALARS, &r->device_claims_info));
1797 288 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_device_claims_info, 0, -1));
1798 : }
1799 288 : break; }
1800 :
1801 1800 : case PAC_TYPE_FULL_CHECKSUM: {
1802 1800 : NDR_CHECK(ndr_push_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->full_checksum));
1803 1800 : break; }
1804 :
1805 72 : default: {
1806 : {
1807 0 : struct ndr_push *_ndr_unknown;
1808 72 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_unknown, 0, -1));
1809 72 : NDR_CHECK(ndr_push_DATA_BLOB_REM(_ndr_unknown, NDR_SCALARS, &r->unknown));
1810 72 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_unknown, 0, -1));
1811 : }
1812 72 : break; }
1813 :
1814 : }
1815 : }
1816 244220 : if (ndr_flags & NDR_BUFFERS) {
1817 244220 : if (!(ndr_flags & NDR_SCALARS)) {
1818 : /* We didn't get it above, and the token is not needed after this. */
1819 0 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
1820 : }
1821 244220 : switch (level) {
1822 85422 : case PAC_TYPE_LOGON_INFO:
1823 85422 : break;
1824 :
1825 0 : case PAC_TYPE_CREDENTIAL_INFO:
1826 0 : break;
1827 :
1828 9858 : case PAC_TYPE_SRV_CHECKSUM:
1829 9858 : break;
1830 :
1831 9837 : case PAC_TYPE_KDC_CHECKSUM:
1832 9837 : break;
1833 :
1834 9888 : case PAC_TYPE_LOGON_NAME:
1835 9888 : break;
1836 :
1837 188 : case PAC_TYPE_CONSTRAINED_DELEGATION:
1838 188 : break;
1839 :
1840 40790 : case PAC_TYPE_UPN_DNS_INFO:
1841 40790 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO(ndr, NDR_BUFFERS, &r->upn_dns_info));
1842 39596 : break;
1843 :
1844 1734 : case PAC_TYPE_TICKET_CHECKSUM:
1845 1734 : break;
1846 :
1847 34424 : case PAC_TYPE_ATTRIBUTES_INFO:
1848 34424 : break;
1849 :
1850 34418 : case PAC_TYPE_REQUESTER_SID:
1851 34418 : break;
1852 :
1853 9786 : case PAC_TYPE_CLIENT_CLAIMS_INFO:
1854 9786 : break;
1855 :
1856 361 : case PAC_TYPE_DEVICE_INFO:
1857 361 : break;
1858 :
1859 288 : case PAC_TYPE_DEVICE_CLAIMS_INFO:
1860 288 : break;
1861 :
1862 1800 : case PAC_TYPE_FULL_CHECKSUM:
1863 1800 : break;
1864 :
1865 72 : default:
1866 72 : break;
1867 :
1868 : }
1869 : }
1870 237672 : return NDR_ERR_SUCCESS;
1871 : }
1872 :
1873 405834 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_INFO(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union PAC_INFO *r)
1874 : {
1875 7544 : uint32_t level;
1876 405834 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1877 405834 : if (ndr_flags & NDR_SCALARS) {
1878 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
1879 405834 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
1880 405834 : NDR_CHECK(ndr_pull_union_align(ndr, 5));
1881 405834 : switch (level) {
1882 104400 : case PAC_TYPE_LOGON_INFO: {
1883 : {
1884 2572 : struct ndr_pull *_ndr_logon_info;
1885 104400 : ssize_t sub_size = -1;
1886 104400 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_logon_info, 0xFFFFFC01, sub_size));
1887 104400 : NDR_CHECK(ndr_pull_PAC_LOGON_INFO_CTR(_ndr_logon_info, NDR_SCALARS|NDR_BUFFERS, &r->logon_info));
1888 104400 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_logon_info, 0xFFFFFC01, sub_size));
1889 : }
1890 104400 : break; }
1891 :
1892 58 : case PAC_TYPE_CREDENTIAL_INFO: {
1893 58 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_INFO(ndr, NDR_SCALARS, &r->credential_info));
1894 54 : break; }
1895 :
1896 23193 : case PAC_TYPE_SRV_CHECKSUM: {
1897 23193 : NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->srv_cksum));
1898 23162 : break; }
1899 :
1900 23193 : case PAC_TYPE_KDC_CHECKSUM: {
1901 23193 : NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->kdc_cksum));
1902 23162 : break; }
1903 :
1904 23193 : case PAC_TYPE_LOGON_NAME: {
1905 23193 : NDR_CHECK(ndr_pull_PAC_LOGON_NAME(ndr, NDR_SCALARS, &r->logon_name));
1906 23162 : break; }
1907 :
1908 295 : case PAC_TYPE_CONSTRAINED_DELEGATION: {
1909 : {
1910 0 : struct ndr_pull *_ndr_constrained_delegation;
1911 295 : ssize_t sub_size = -1;
1912 295 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_constrained_delegation, 0xFFFFFC01, sub_size));
1913 295 : NDR_CHECK(ndr_pull_PAC_CONSTRAINED_DELEGATION_CTR(_ndr_constrained_delegation, NDR_SCALARS|NDR_BUFFERS, &r->constrained_delegation));
1914 295 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_constrained_delegation, 0xFFFFFC01, sub_size));
1915 : }
1916 295 : break; }
1917 :
1918 103837 : case PAC_TYPE_UPN_DNS_INFO: {
1919 103837 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO(ndr, NDR_SCALARS, &r->upn_dns_info));
1920 101274 : break; }
1921 :
1922 12786 : case PAC_TYPE_TICKET_CHECKSUM: {
1923 12786 : NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->ticket_checksum));
1924 12782 : break; }
1925 :
1926 25076 : case PAC_TYPE_ATTRIBUTES_INFO: {
1927 25076 : NDR_CHECK(ndr_pull_PAC_ATTRIBUTES_INFO(ndr, NDR_SCALARS, &r->attributes_info));
1928 24444 : break; }
1929 :
1930 54078 : case PAC_TYPE_REQUESTER_SID: {
1931 54078 : NDR_CHECK(ndr_pull_PAC_REQUESTER_SID(ndr, NDR_SCALARS, &r->requester_sid));
1932 52411 : break; }
1933 :
1934 22663 : case PAC_TYPE_CLIENT_CLAIMS_INFO: {
1935 : {
1936 9 : struct ndr_pull *_ndr_client_claims_info;
1937 22663 : ssize_t sub_size = -1;
1938 22663 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_client_claims_info, 0, sub_size));
1939 22663 : NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_client_claims_info, NDR_SCALARS, &r->client_claims_info));
1940 22663 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_client_claims_info, 0, sub_size));
1941 : }
1942 22663 : break; }
1943 :
1944 136 : case PAC_TYPE_DEVICE_INFO: {
1945 : {
1946 0 : struct ndr_pull *_ndr_device_info;
1947 136 : ssize_t sub_size = -1;
1948 136 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_device_info, 0xFFFFFC01, sub_size));
1949 136 : NDR_CHECK(ndr_pull_PAC_DEVICE_INFO_CTR(_ndr_device_info, NDR_SCALARS|NDR_BUFFERS, &r->device_info));
1950 136 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_device_info, 0xFFFFFC01, sub_size));
1951 : }
1952 136 : break; }
1953 :
1954 132 : case PAC_TYPE_DEVICE_CLAIMS_INFO: {
1955 : {
1956 0 : struct ndr_pull *_ndr_device_claims_info;
1957 132 : ssize_t sub_size = -1;
1958 132 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_device_claims_info, 0, sub_size));
1959 132 : NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_device_claims_info, NDR_SCALARS, &r->device_claims_info));
1960 132 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_device_claims_info, 0, sub_size));
1961 : }
1962 132 : break; }
1963 :
1964 12782 : case PAC_TYPE_FULL_CHECKSUM: {
1965 12782 : NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->full_checksum));
1966 12782 : break; }
1967 :
1968 12 : default: {
1969 : {
1970 0 : struct ndr_pull *_ndr_unknown;
1971 12 : ssize_t sub_size = -1;
1972 12 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_unknown, 0, sub_size));
1973 12 : NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_unknown, NDR_SCALARS, &r->unknown));
1974 12 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_unknown, 0, sub_size));
1975 : }
1976 12 : break; }
1977 :
1978 : }
1979 : }
1980 405834 : if (ndr_flags & NDR_BUFFERS) {
1981 405834 : if (!(ndr_flags & NDR_SCALARS)) {
1982 : /* We didn't get it above, and the token is not needed after this. */
1983 0 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
1984 : }
1985 405834 : switch (level) {
1986 101828 : case PAC_TYPE_LOGON_INFO:
1987 101828 : break;
1988 :
1989 54 : case PAC_TYPE_CREDENTIAL_INFO:
1990 54 : break;
1991 :
1992 23162 : case PAC_TYPE_SRV_CHECKSUM:
1993 23162 : break;
1994 :
1995 23162 : case PAC_TYPE_KDC_CHECKSUM:
1996 23162 : break;
1997 :
1998 23162 : case PAC_TYPE_LOGON_NAME:
1999 23162 : break;
2000 :
2001 295 : case PAC_TYPE_CONSTRAINED_DELEGATION:
2002 295 : break;
2003 :
2004 103837 : case PAC_TYPE_UPN_DNS_INFO:
2005 103837 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO(ndr, NDR_BUFFERS, &r->upn_dns_info));
2006 101274 : break;
2007 :
2008 12782 : case PAC_TYPE_TICKET_CHECKSUM:
2009 12782 : break;
2010 :
2011 24444 : case PAC_TYPE_ATTRIBUTES_INFO:
2012 24444 : break;
2013 :
2014 52411 : case PAC_TYPE_REQUESTER_SID:
2015 52411 : break;
2016 :
2017 22654 : case PAC_TYPE_CLIENT_CLAIMS_INFO:
2018 22654 : break;
2019 :
2020 136 : case PAC_TYPE_DEVICE_INFO:
2021 136 : break;
2022 :
2023 132 : case PAC_TYPE_DEVICE_CLAIMS_INFO:
2024 132 : break;
2025 :
2026 12782 : case PAC_TYPE_FULL_CHECKSUM:
2027 12782 : break;
2028 :
2029 12 : default:
2030 12 : break;
2031 :
2032 : }
2033 : }
2034 398290 : return NDR_ERR_SUCCESS;
2035 : }
2036 :
2037 83 : _PUBLIC_ void ndr_print_PAC_INFO(struct ndr_print *ndr, const char *name, const union PAC_INFO *r)
2038 : {
2039 83 : uint32_t level;
2040 83 : level = ndr_print_steal_switch_value(ndr, r);
2041 83 : ndr_print_union(ndr, name, level, "PAC_INFO");
2042 83 : switch (level) {
2043 15 : case PAC_TYPE_LOGON_INFO:
2044 15 : ndr_print_PAC_LOGON_INFO_CTR(ndr, "logon_info", &r->logon_info);
2045 15 : break;
2046 :
2047 4 : case PAC_TYPE_CREDENTIAL_INFO:
2048 4 : ndr_print_PAC_CREDENTIAL_INFO(ndr, "credential_info", &r->credential_info);
2049 4 : break;
2050 :
2051 15 : case PAC_TYPE_SRV_CHECKSUM:
2052 15 : ndr_print_PAC_SIGNATURE_DATA(ndr, "srv_cksum", &r->srv_cksum);
2053 15 : break;
2054 :
2055 15 : case PAC_TYPE_KDC_CHECKSUM:
2056 15 : ndr_print_PAC_SIGNATURE_DATA(ndr, "kdc_cksum", &r->kdc_cksum);
2057 15 : break;
2058 :
2059 15 : case PAC_TYPE_LOGON_NAME:
2060 15 : ndr_print_PAC_LOGON_NAME(ndr, "logon_name", &r->logon_name);
2061 15 : break;
2062 :
2063 0 : case PAC_TYPE_CONSTRAINED_DELEGATION:
2064 0 : ndr_print_PAC_CONSTRAINED_DELEGATION_CTR(ndr, "constrained_delegation", &r->constrained_delegation);
2065 0 : break;
2066 :
2067 15 : case PAC_TYPE_UPN_DNS_INFO:
2068 15 : ndr_print_PAC_UPN_DNS_INFO(ndr, "upn_dns_info", &r->upn_dns_info);
2069 15 : break;
2070 :
2071 4 : case PAC_TYPE_TICKET_CHECKSUM:
2072 4 : ndr_print_PAC_SIGNATURE_DATA(ndr, "ticket_checksum", &r->ticket_checksum);
2073 4 : break;
2074 :
2075 0 : case PAC_TYPE_ATTRIBUTES_INFO:
2076 0 : ndr_print_PAC_ATTRIBUTES_INFO(ndr, "attributes_info", &r->attributes_info);
2077 0 : break;
2078 :
2079 0 : case PAC_TYPE_REQUESTER_SID:
2080 0 : ndr_print_PAC_REQUESTER_SID(ndr, "requester_sid", &r->requester_sid);
2081 0 : break;
2082 :
2083 0 : case PAC_TYPE_CLIENT_CLAIMS_INFO:
2084 0 : ndr_print_DATA_BLOB_REM(ndr, "client_claims_info", &r->client_claims_info);
2085 0 : break;
2086 :
2087 0 : case PAC_TYPE_DEVICE_INFO:
2088 0 : ndr_print_PAC_DEVICE_INFO_CTR(ndr, "device_info", &r->device_info);
2089 0 : break;
2090 :
2091 0 : case PAC_TYPE_DEVICE_CLAIMS_INFO:
2092 0 : ndr_print_DATA_BLOB_REM(ndr, "device_claims_info", &r->device_claims_info);
2093 0 : break;
2094 :
2095 0 : case PAC_TYPE_FULL_CHECKSUM:
2096 0 : ndr_print_PAC_SIGNATURE_DATA(ndr, "full_checksum", &r->full_checksum);
2097 0 : break;
2098 :
2099 0 : default:
2100 0 : ndr_print_DATA_BLOB_REM(ndr, "unknown", &r->unknown);
2101 0 : break;
2102 :
2103 : }
2104 83 : }
2105 :
2106 53111 : _PUBLIC_ size_t ndr_size_PAC_INFO(const union PAC_INFO *r, uint32_t level, libndr_flags flags)
2107 : {
2108 53111 : return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_PAC_INFO);
2109 : }
2110 :
2111 2 : static void ndr_print_flags_PAC_BUFFER(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_BUFFER *r)
2112 : {
2113 2 : ndr_print_PAC_BUFFER(ndr, name, r);
2114 2 : }
2115 :
2116 85 : _PUBLIC_ void ndr_print_PAC_BUFFER(struct ndr_print *ndr, const char *name, const struct PAC_BUFFER *r)
2117 : {
2118 85 : ndr_print_struct(ndr, name, "PAC_BUFFER");
2119 85 : if (r == NULL) { ndr_print_null(ndr); return; }
2120 85 : ndr->depth++;
2121 85 : ndr_print_PAC_TYPE(ndr, "type", r->type);
2122 85 : ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_PAC_INFO(r->info, r->type, LIBNDR_FLAG_ALIGN8):r->_ndr_size);
2123 : {
2124 85 : libndr_flags _flags_save_PAC_INFO = ndr->flags;
2125 85 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2126 85 : ndr_print_ptr(ndr, "info", r->info);
2127 85 : ndr->depth++;
2128 85 : if (r->info) {
2129 83 : ndr_print_set_switch_value(ndr, r->info, r->type);
2130 83 : ndr_print_PAC_INFO(ndr, "info", r->info);
2131 : }
2132 85 : ndr->depth--;
2133 85 : ndr->flags = _flags_save_PAC_INFO;
2134 : }
2135 85 : ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
2136 85 : ndr->depth--;
2137 : }
2138 :
2139 3310 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_DATA(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_DATA *r)
2140 : {
2141 14 : uint32_t cntr_buffers_0;
2142 3310 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2143 3310 : if (ndr_flags & NDR_SCALARS) {
2144 3310 : NDR_CHECK(ndr_push_align(ndr, 5));
2145 3310 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_buffers));
2146 3310 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2147 29865 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (r->num_buffers); cntr_buffers_0++) {
2148 26555 : NDR_CHECK(ndr_push_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
2149 : }
2150 3310 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2151 : }
2152 3310 : if (ndr_flags & NDR_BUFFERS) {
2153 29865 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (r->num_buffers); cntr_buffers_0++) {
2154 26555 : NDR_CHECK(ndr_push_PAC_BUFFER(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
2155 : }
2156 : }
2157 3296 : return NDR_ERR_SUCCESS;
2158 : }
2159 :
2160 23193 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_DATA *r)
2161 : {
2162 23193 : uint32_t size_buffers_0 = 0;
2163 31 : uint32_t cntr_buffers_0;
2164 23193 : TALLOC_CTX *_mem_save_buffers_0 = NULL;
2165 23193 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2166 23193 : if (ndr_flags & NDR_SCALARS) {
2167 23193 : NDR_CHECK(ndr_pull_align(ndr, 5));
2168 23193 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_buffers));
2169 23193 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2170 23193 : size_buffers_0 = r->num_buffers;
2171 23193 : NDR_PULL_ALLOC_N(ndr, r->buffers, size_buffers_0);
2172 23193 : _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2173 23193 : NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
2174 197148 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2175 173955 : NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
2176 : }
2177 23193 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
2178 23193 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2179 : }
2180 23193 : if (ndr_flags & NDR_BUFFERS) {
2181 23193 : size_buffers_0 = r->num_buffers;
2182 23193 : _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2183 23193 : NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
2184 197148 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2185 173955 : NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
2186 : }
2187 23193 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
2188 196965 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2189 : }
2190 : }
2191 23162 : return NDR_ERR_SUCCESS;
2192 : }
2193 :
2194 5 : static void ndr_print_flags_PAC_DATA(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_DATA *r)
2195 : {
2196 5 : ndr_print_PAC_DATA(ndr, name, r);
2197 5 : }
2198 :
2199 15 : _PUBLIC_ void ndr_print_PAC_DATA(struct ndr_print *ndr, const char *name, const struct PAC_DATA *r)
2200 : {
2201 15 : uint32_t cntr_buffers_0;
2202 15 : ndr_print_struct(ndr, name, "PAC_DATA");
2203 15 : if (r == NULL) { ndr_print_null(ndr); return; }
2204 15 : ndr->depth++;
2205 15 : ndr_print_uint32(ndr, "num_buffers", r->num_buffers);
2206 15 : ndr_print_uint32(ndr, "version", r->version);
2207 15 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "buffers", (uint32_t)(r->num_buffers));
2208 15 : ndr->depth++;
2209 98 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (r->num_buffers); cntr_buffers_0++) {
2210 83 : ndr_print_PAC_BUFFER(ndr, "buffers", &r->buffers[cntr_buffers_0]);
2211 : }
2212 15 : ndr->depth--;
2213 15 : ndr->depth--;
2214 : }
2215 :
2216 260562 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_BUFFER_RAW(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_BUFFER_RAW *r)
2217 : {
2218 260562 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2219 260562 : if (ndr_flags & NDR_SCALARS) {
2220 130281 : NDR_CHECK(ndr_push_align(ndr, 5));
2221 130281 : NDR_CHECK(ndr_push_PAC_TYPE(ndr, NDR_SCALARS, r->type));
2222 130281 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ndr_size));
2223 : {
2224 130281 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2225 130281 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2226 130281 : NDR_CHECK(ndr_push_relative_ptr1(ndr, r->info));
2227 130281 : ndr->flags = _flags_save_DATA_BLOB_REM;
2228 : }
2229 130281 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2230 130281 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2231 : }
2232 260562 : if (ndr_flags & NDR_BUFFERS) {
2233 : {
2234 130281 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2235 130281 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2236 130281 : if (r->info) {
2237 130281 : NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->info));
2238 : {
2239 82 : struct ndr_push *_ndr_info;
2240 130281 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
2241 130281 : NDR_CHECK(ndr_push_DATA_BLOB_REM(_ndr_info, NDR_SCALARS, r->info));
2242 130281 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
2243 : }
2244 130281 : NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->info));
2245 : }
2246 130281 : ndr->flags = _flags_save_DATA_BLOB_REM;
2247 : }
2248 : }
2249 260398 : return NDR_ERR_SUCCESS;
2250 : }
2251 :
2252 193952 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_BUFFER_RAW(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_BUFFER_RAW *r)
2253 : {
2254 180 : uint32_t _ptr_info;
2255 193952 : TALLOC_CTX *_mem_save_info_0 = NULL;
2256 193952 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2257 193952 : if (ndr_flags & NDR_SCALARS) {
2258 96976 : NDR_CHECK(ndr_pull_align(ndr, 5));
2259 96976 : NDR_CHECK(ndr_pull_PAC_TYPE(ndr, NDR_SCALARS, &r->type));
2260 96976 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ndr_size));
2261 : {
2262 96976 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2263 96976 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2264 96976 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
2265 96976 : if (_ptr_info) {
2266 96976 : NDR_PULL_ALLOC(ndr, r->info);
2267 96976 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->info, _ptr_info));
2268 : } else {
2269 0 : r->info = NULL;
2270 : }
2271 96976 : ndr->flags = _flags_save_DATA_BLOB_REM;
2272 : }
2273 96976 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
2274 96976 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2275 : }
2276 193952 : if (ndr_flags & NDR_BUFFERS) {
2277 : {
2278 96976 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2279 96976 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2280 96976 : if (r->info) {
2281 90 : uint32_t _relative_save_offset;
2282 96976 : _relative_save_offset = ndr->offset;
2283 96976 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->info));
2284 96976 : _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2285 96976 : NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
2286 : {
2287 90 : struct ndr_pull *_ndr_info;
2288 96976 : ssize_t sub_size = NDR_ROUND(r->ndr_size, 8);
2289 96976 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 0, sub_size));
2290 96976 : NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_info, NDR_SCALARS, r->info));
2291 96976 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 0, sub_size));
2292 : }
2293 96976 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
2294 96976 : if (ndr->offset > ndr->relative_highest_offset) {
2295 84800 : ndr->relative_highest_offset = ndr->offset;
2296 : }
2297 96976 : ndr->offset = _relative_save_offset;
2298 : }
2299 96976 : ndr->flags = _flags_save_DATA_BLOB_REM;
2300 : }
2301 : }
2302 193772 : return NDR_ERR_SUCCESS;
2303 : }
2304 :
2305 0 : static void ndr_print_flags_PAC_BUFFER_RAW(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_BUFFER_RAW *r)
2306 : {
2307 0 : ndr_print_PAC_BUFFER_RAW(ndr, name, r);
2308 0 : }
2309 :
2310 54 : _PUBLIC_ void ndr_print_PAC_BUFFER_RAW(struct ndr_print *ndr, const char *name, const struct PAC_BUFFER_RAW *r)
2311 : {
2312 54 : ndr_print_struct(ndr, name, "PAC_BUFFER_RAW");
2313 54 : if (r == NULL) { ndr_print_null(ndr); return; }
2314 54 : ndr->depth++;
2315 54 : ndr_print_PAC_TYPE(ndr, "type", r->type);
2316 54 : ndr_print_uint32(ndr, "ndr_size", r->ndr_size);
2317 : {
2318 54 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2319 54 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2320 54 : ndr_print_ptr(ndr, "info", r->info);
2321 54 : ndr->depth++;
2322 54 : if (r->info) {
2323 54 : ndr_print_DATA_BLOB_REM(ndr, "info", r->info);
2324 : }
2325 54 : ndr->depth--;
2326 54 : ndr->flags = _flags_save_DATA_BLOB_REM;
2327 : }
2328 54 : ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
2329 54 : ndr->depth--;
2330 : }
2331 :
2332 17101 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_DATA_RAW(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_DATA_RAW *r)
2333 : {
2334 17 : uint32_t cntr_buffers_0;
2335 17101 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2336 17101 : if (ndr_flags & NDR_SCALARS) {
2337 17101 : NDR_CHECK(ndr_push_align(ndr, 5));
2338 17101 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_buffers));
2339 17101 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2340 147382 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (r->num_buffers); cntr_buffers_0++) {
2341 130281 : NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
2342 : }
2343 17101 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2344 : }
2345 17101 : if (ndr_flags & NDR_BUFFERS) {
2346 147382 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (r->num_buffers); cntr_buffers_0++) {
2347 130281 : NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
2348 : }
2349 : }
2350 17084 : return NDR_ERR_SUCCESS;
2351 : }
2352 :
2353 12969 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA_RAW(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_DATA_RAW *r)
2354 : {
2355 12969 : uint32_t size_buffers_0 = 0;
2356 18 : uint32_t cntr_buffers_0;
2357 12969 : TALLOC_CTX *_mem_save_buffers_0 = NULL;
2358 12969 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2359 12969 : if (ndr_flags & NDR_SCALARS) {
2360 12969 : NDR_CHECK(ndr_pull_align(ndr, 5));
2361 12969 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_buffers));
2362 12969 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2363 12969 : size_buffers_0 = r->num_buffers;
2364 12969 : NDR_PULL_ALLOC_N(ndr, r->buffers, size_buffers_0);
2365 12969 : _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2366 12969 : NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
2367 109945 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2368 96976 : NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
2369 : }
2370 12969 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
2371 12969 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2372 : }
2373 12969 : if (ndr_flags & NDR_BUFFERS) {
2374 12969 : size_buffers_0 = r->num_buffers;
2375 12969 : _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2376 12969 : NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
2377 109945 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2378 96976 : NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
2379 : }
2380 12969 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
2381 109855 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2382 : }
2383 : }
2384 12951 : return NDR_ERR_SUCCESS;
2385 : }
2386 :
2387 0 : static void ndr_print_flags_PAC_DATA_RAW(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_DATA_RAW *r)
2388 : {
2389 0 : ndr_print_PAC_DATA_RAW(ndr, name, r);
2390 0 : }
2391 :
2392 10 : _PUBLIC_ void ndr_print_PAC_DATA_RAW(struct ndr_print *ndr, const char *name, const struct PAC_DATA_RAW *r)
2393 : {
2394 10 : uint32_t cntr_buffers_0;
2395 10 : ndr_print_struct(ndr, name, "PAC_DATA_RAW");
2396 10 : if (r == NULL) { ndr_print_null(ndr); return; }
2397 10 : ndr->depth++;
2398 10 : ndr_print_uint32(ndr, "num_buffers", r->num_buffers);
2399 10 : ndr_print_uint32(ndr, "version", r->version);
2400 10 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "buffers", (uint32_t)(r->num_buffers));
2401 10 : ndr->depth++;
2402 64 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (r->num_buffers); cntr_buffers_0++) {
2403 54 : ndr_print_PAC_BUFFER_RAW(ndr, "buffers", &r->buffers[cntr_buffers_0]);
2404 : }
2405 10 : ndr->depth--;
2406 10 : ndr->depth--;
2407 : }
2408 :
2409 150 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_Validate(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct PAC_Validate *r)
2410 : {
2411 150 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2412 150 : if (ndr_flags & NDR_SCALARS) {
2413 150 : NDR_CHECK(ndr_push_align(ndr, 4));
2414 150 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, NETLOGON_GENERIC_KRB5_PAC_VALIDATE));
2415 150 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ChecksumLength));
2416 150 : NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->SignatureType));
2417 150 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SignatureLength));
2418 : {
2419 150 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
2420 150 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2421 150 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->ChecksumAndSignature));
2422 150 : ndr->flags = _flags_save_DATA_BLOB;
2423 : }
2424 150 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2425 : }
2426 150 : if (ndr_flags & NDR_BUFFERS) {
2427 0 : }
2428 150 : return NDR_ERR_SUCCESS;
2429 : }
2430 :
2431 250 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_Validate(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_Validate *r)
2432 : {
2433 250 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2434 250 : if (ndr_flags & NDR_SCALARS) {
2435 250 : NDR_CHECK(ndr_pull_align(ndr, 4));
2436 250 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MessageType));
2437 250 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ChecksumLength));
2438 250 : NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->SignatureType));
2439 250 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SignatureLength));
2440 : {
2441 250 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
2442 250 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2443 250 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->ChecksumAndSignature));
2444 250 : ndr->flags = _flags_save_DATA_BLOB;
2445 : }
2446 250 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2447 : }
2448 250 : if (ndr_flags & NDR_BUFFERS) {
2449 0 : }
2450 250 : return NDR_ERR_SUCCESS;
2451 : }
2452 :
2453 0 : static void ndr_print_flags_PAC_Validate(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct PAC_Validate *r)
2454 : {
2455 0 : ndr_print_PAC_Validate(ndr, name, r);
2456 0 : }
2457 :
2458 0 : _PUBLIC_ void ndr_print_PAC_Validate(struct ndr_print *ndr, const char *name, const struct PAC_Validate *r)
2459 : {
2460 0 : ndr_print_struct(ndr, name, "PAC_Validate");
2461 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2462 0 : ndr->depth++;
2463 0 : ndr_print_uint32(ndr, "MessageType", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?NETLOGON_GENERIC_KRB5_PAC_VALIDATE:r->MessageType);
2464 0 : ndr_print_uint32(ndr, "ChecksumLength", r->ChecksumLength);
2465 0 : ndr_print_int32(ndr, "SignatureType", r->SignatureType);
2466 0 : ndr_print_uint32(ndr, "SignatureLength", r->SignatureLength);
2467 : {
2468 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
2469 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2470 0 : ndr_print_DATA_BLOB(ndr, "ChecksumAndSignature", r->ChecksumAndSignature);
2471 0 : ndr->flags = _flags_save_DATA_BLOB;
2472 : }
2473 0 : ndr->depth--;
2474 : }
2475 :
2476 868 : _PUBLIC_ enum ndr_err_code ndr_push_netsamlogoncache_entry(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct netsamlogoncache_entry *r)
2477 : {
2478 868 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2479 868 : if (ndr_flags & NDR_SCALARS) {
2480 868 : NDR_CHECK(ndr_push_align(ndr, 5));
2481 868 : NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->timestamp));
2482 868 : NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
2483 868 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2484 : }
2485 868 : if (ndr_flags & NDR_BUFFERS) {
2486 868 : NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
2487 : }
2488 868 : return NDR_ERR_SUCCESS;
2489 : }
2490 :
2491 89902 : _PUBLIC_ enum ndr_err_code ndr_pull_netsamlogoncache_entry(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct netsamlogoncache_entry *r)
2492 : {
2493 89902 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2494 89902 : if (ndr_flags & NDR_SCALARS) {
2495 89902 : NDR_CHECK(ndr_pull_align(ndr, 5));
2496 89902 : NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
2497 89902 : NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
2498 89902 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2499 : }
2500 89902 : if (ndr_flags & NDR_BUFFERS) {
2501 89902 : NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
2502 : }
2503 89902 : return NDR_ERR_SUCCESS;
2504 : }
2505 :
2506 0 : static void ndr_print_flags_netsamlogoncache_entry(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct netsamlogoncache_entry *r)
2507 : {
2508 0 : ndr_print_netsamlogoncache_entry(ndr, name, r);
2509 0 : }
2510 :
2511 0 : _PUBLIC_ void ndr_print_netsamlogoncache_entry(struct ndr_print *ndr, const char *name, const struct netsamlogoncache_entry *r)
2512 : {
2513 0 : ndr_print_struct(ndr, name, "netsamlogoncache_entry");
2514 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2515 0 : ndr->depth++;
2516 0 : ndr_print_time_t(ndr, "timestamp", r->timestamp);
2517 0 : ndr_print_netr_SamInfo3(ndr, "info3", &r->info3);
2518 0 : ndr->depth--;
2519 : }
2520 :
2521 : #ifndef SKIP_NDR_TABLE_krb5pac
2522 : static const struct ndr_interface_public_struct krb5pac_public_structs[] = {
2523 : {
2524 : .name = "PAC_SIGNATURE_DATA",
2525 : .struct_size = sizeof(struct PAC_SIGNATURE_DATA ),
2526 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_SIGNATURE_DATA,
2527 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_SIGNATURE_DATA,
2528 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_SIGNATURE_DATA,
2529 : },
2530 : {
2531 : .name = "PAC_CREDENTIAL_NTLM_SECPKG",
2532 : .struct_size = sizeof(struct PAC_CREDENTIAL_NTLM_SECPKG ),
2533 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_CREDENTIAL_NTLM_SECPKG,
2534 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_CREDENTIAL_NTLM_SECPKG,
2535 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_CREDENTIAL_NTLM_SECPKG,
2536 : },
2537 : {
2538 : .name = "PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG",
2539 : .struct_size = sizeof(struct PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG ),
2540 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG,
2541 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG,
2542 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG,
2543 : },
2544 : {
2545 : .name = "PAC_CREDENTIAL_DATA",
2546 : .struct_size = sizeof(struct PAC_CREDENTIAL_DATA ),
2547 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_CREDENTIAL_DATA,
2548 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_CREDENTIAL_DATA,
2549 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_CREDENTIAL_DATA,
2550 : },
2551 : {
2552 : .name = "PAC_CREDENTIAL_DATA_CTR",
2553 : .struct_size = sizeof(struct PAC_CREDENTIAL_DATA_CTR ),
2554 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_CREDENTIAL_DATA_CTR,
2555 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_CREDENTIAL_DATA_CTR,
2556 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_CREDENTIAL_DATA_CTR,
2557 : },
2558 : {
2559 : .name = "PAC_CREDENTIAL_DATA_NDR",
2560 : .struct_size = sizeof(struct PAC_CREDENTIAL_DATA_NDR ),
2561 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_CREDENTIAL_DATA_NDR,
2562 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_CREDENTIAL_DATA_NDR,
2563 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_CREDENTIAL_DATA_NDR,
2564 : },
2565 : {
2566 : .name = "PAC_CREDENTIAL_INFO",
2567 : .struct_size = sizeof(struct PAC_CREDENTIAL_INFO ),
2568 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_CREDENTIAL_INFO,
2569 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_CREDENTIAL_INFO,
2570 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_CREDENTIAL_INFO,
2571 : },
2572 : {
2573 : .name = "PAC_LOGON_INFO_CTR",
2574 : .struct_size = sizeof(struct PAC_LOGON_INFO_CTR ),
2575 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_LOGON_INFO_CTR,
2576 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_LOGON_INFO_CTR,
2577 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_LOGON_INFO_CTR,
2578 : },
2579 : {
2580 : .name = "PAC_CONSTRAINED_DELEGATION_CTR",
2581 : .struct_size = sizeof(struct PAC_CONSTRAINED_DELEGATION_CTR ),
2582 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_CONSTRAINED_DELEGATION_CTR,
2583 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_CONSTRAINED_DELEGATION_CTR,
2584 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_CONSTRAINED_DELEGATION_CTR,
2585 : },
2586 : {
2587 : .name = "PAC_BUFFER",
2588 : .struct_size = sizeof(struct PAC_BUFFER ),
2589 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_BUFFER,
2590 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_BUFFER,
2591 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_BUFFER,
2592 : },
2593 : {
2594 : .name = "PAC_DATA",
2595 : .struct_size = sizeof(struct PAC_DATA ),
2596 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_DATA,
2597 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_DATA,
2598 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_DATA,
2599 : },
2600 : {
2601 : .name = "PAC_BUFFER_RAW",
2602 : .struct_size = sizeof(struct PAC_BUFFER_RAW ),
2603 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_BUFFER_RAW,
2604 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_BUFFER_RAW,
2605 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_BUFFER_RAW,
2606 : },
2607 : {
2608 : .name = "PAC_DATA_RAW",
2609 : .struct_size = sizeof(struct PAC_DATA_RAW ),
2610 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_DATA_RAW,
2611 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_DATA_RAW,
2612 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_DATA_RAW,
2613 : },
2614 : {
2615 : .name = "PAC_Validate",
2616 : .struct_size = sizeof(struct PAC_Validate ),
2617 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_PAC_Validate,
2618 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_PAC_Validate,
2619 : .ndr_print = (ndr_print_function_t) ndr_print_flags_PAC_Validate,
2620 : },
2621 : {
2622 : .name = "netsamlogoncache_entry",
2623 : .struct_size = sizeof(struct netsamlogoncache_entry ),
2624 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_netsamlogoncache_entry,
2625 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_netsamlogoncache_entry,
2626 : .ndr_print = (ndr_print_function_t) ndr_print_flags_netsamlogoncache_entry,
2627 : },
2628 : { .name = NULL }
2629 : };
2630 :
2631 : static const struct ndr_interface_call krb5pac_calls[] = {
2632 : { .name = NULL }
2633 : };
2634 :
2635 : static const char * const krb5pac_endpoint_strings[] = {
2636 : "ncacn_np:[\\pipe\\krb5pac]",
2637 : };
2638 :
2639 : static const struct ndr_interface_string_array krb5pac_endpoints = {
2640 : .count = 1,
2641 : .names = krb5pac_endpoint_strings
2642 : };
2643 :
2644 : static const char * const krb5pac_authservice_strings[] = {
2645 : "host",
2646 : };
2647 :
2648 : static const struct ndr_interface_string_array krb5pac_authservices = {
2649 : .count = 1,
2650 : .names = krb5pac_authservice_strings
2651 : };
2652 :
2653 :
2654 : const struct ndr_interface_table ndr_table_krb5pac = {
2655 : .name = "krb5pac",
2656 : .syntax_id = {
2657 : {0x12345778,0x1234,0xabcd,{0x00,0x00},{0x00,0x00,0x00,0x00}},
2658 : NDR_KRB5PAC_VERSION
2659 : },
2660 : .helpstring = NDR_KRB5PAC_HELPSTRING,
2661 : .num_calls = 0,
2662 : .calls = krb5pac_calls,
2663 : .num_public_structs = 15,
2664 : .public_structs = krb5pac_public_structs,
2665 : .endpoints = &krb5pac_endpoints,
2666 : .authservices = &krb5pac_authservices
2667 : };
2668 :
2669 : #endif /* SKIP_NDR_TABLE_krb5pac */
|
