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 23207 : 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 23207 : uint32_t size_account_name_0 = 0;
28 23207 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
29 23207 : if (ndr_flags & NDR_SCALARS) {
30 23207 : NDR_CHECK(ndr_pull_align(ndr, 4));
31 23207 : NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->logon_time));
32 23207 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
33 23207 : size_account_name_0 = r->size;
34 23207 : NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->account_name, size_account_name_0, sizeof(uint8_t), CH_UTF16));
35 23207 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
36 : }
37 23207 : if (ndr_flags & NDR_BUFFERS) {
38 31 : }
39 23207 : 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 53352 : _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 53352 : libndr_flags _flags_save_STRUCT = ndr->flags;
57 53352 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
58 53352 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
59 53352 : if (ndr_flags & NDR_SCALARS) {
60 53352 : NDR_CHECK(ndr_push_align(ndr, 4));
61 53352 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->type));
62 : {
63 53352 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
64 53352 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
65 53352 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->signature));
66 53352 : ndr->flags = _flags_save_DATA_BLOB;
67 : }
68 53352 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
69 : }
70 53352 : if (ndr_flags & NDR_BUFFERS) {
71 104 : }
72 53352 : ndr->flags = _flags_save_STRUCT;
73 : }
74 53352 : return NDR_ERR_SUCCESS;
75 : }
76 :
77 102195 : _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 102195 : libndr_flags _flags_save_STRUCT = ndr->flags;
81 102195 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
82 102195 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
83 102195 : if (ndr_flags & NDR_SCALARS) {
84 102195 : NDR_CHECK(ndr_pull_align(ndr, 4));
85 102195 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->type));
86 : {
87 102195 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
88 102195 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
89 102195 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->signature));
90 102195 : ndr->flags = _flags_save_DATA_BLOB;
91 : }
92 102195 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
93 : }
94 102195 : if (ndr_flags & NDR_BUFFERS) {
95 80 : }
96 102195 : ndr->flags = _flags_save_STRUCT;
97 : }
98 102195 : 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 179222 : 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 179222 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
129 179222 : if (ndr_flags & NDR_SCALARS) {
130 89611 : NDR_CHECK(ndr_push_align(ndr, 5));
131 89611 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
132 89611 : NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->groups));
133 89611 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
134 : }
135 179222 : if (ndr_flags & NDR_BUFFERS) {
136 89611 : if (r->domain_sid) {
137 16890 : NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
138 : }
139 89611 : NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_BUFFERS, &r->groups));
140 : }
141 173482 : return NDR_ERR_SUCCESS;
142 : }
143 :
144 211340 : 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 211340 : TALLOC_CTX *_mem_save_domain_sid_0 = NULL;
148 211340 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
149 211340 : if (ndr_flags & NDR_SCALARS) {
150 105670 : NDR_CHECK(ndr_pull_align(ndr, 5));
151 105670 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_sid));
152 105670 : if (_ptr_domain_sid) {
153 34545 : NDR_PULL_ALLOC(ndr, r->domain_sid);
154 : } else {
155 71125 : r->domain_sid = NULL;
156 : }
157 105670 : NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS, &r->groups));
158 105670 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
159 : }
160 211340 : if (ndr_flags & NDR_BUFFERS) {
161 105670 : if (r->domain_sid) {
162 34545 : _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
163 34545 : NDR_PULL_SET_MEM_CTX(ndr, r->domain_sid, 0);
164 34545 : NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
165 34545 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, 0);
166 : }
167 105670 : NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_BUFFERS, &r->groups));
168 : }
169 206196 : 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 89531 : 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 89531 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
190 89531 : if (ndr_flags & NDR_SCALARS) {
191 89531 : NDR_CHECK(ndr_push_align(ndr, 5));
192 89531 : NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
193 89531 : NDR_CHECK(ndr_push_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_SCALARS, &r->resource_groups));
194 89531 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
195 : }
196 89531 : if (ndr_flags & NDR_BUFFERS) {
197 89531 : NDR_CHECK(ndr_push_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
198 89531 : NDR_CHECK(ndr_push_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_BUFFERS, &r->resource_groups));
199 : }
200 86661 : return NDR_ERR_SUCCESS;
201 : }
202 :
203 105528 : 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 105528 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
206 105528 : if (ndr_flags & NDR_SCALARS) {
207 105528 : NDR_CHECK(ndr_pull_align(ndr, 5));
208 105528 : NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
209 105528 : NDR_CHECK(ndr_pull_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_SCALARS, &r->resource_groups));
210 105528 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
211 : }
212 105528 : if (ndr_flags & NDR_BUFFERS) {
213 105528 : NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
214 105528 : NDR_CHECK(ndr_pull_PAC_DOMAIN_GROUP_MEMBERSHIP(ndr, NDR_BUFFERS, &r->resource_groups));
215 : }
216 102956 : 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 47 : 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 47 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
232 45 : return NDR_ERR_SUCCESS;
233 : }
234 :
235 29 : 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 29 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
239 29 : *r = v;
240 29 : 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 47 : _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 47 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
255 47 : if (ndr_flags & NDR_SCALARS) {
256 47 : NDR_CHECK(ndr_push_align(ndr, 4));
257 47 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
258 49 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_NTLM_FLAGS(ndr, NDR_SCALARS, r->flags));
259 47 : NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_password));
260 47 : NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_password));
261 47 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
262 : }
263 47 : if (ndr_flags & NDR_BUFFERS) {
264 2 : }
265 47 : return NDR_ERR_SUCCESS;
266 : }
267 :
268 29 : _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 29 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
271 29 : if (ndr_flags & NDR_SCALARS) {
272 29 : NDR_CHECK(ndr_pull_align(ndr, 4));
273 29 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
274 31 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_NTLM_FLAGS(ndr, NDR_SCALARS, &r->flags));
275 29 : NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_password));
276 29 : NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_password));
277 29 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
278 : }
279 29 : if (ndr_flags & NDR_BUFFERS) {
280 2 : }
281 29 : 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 94 : _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 94 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
302 94 : if (ndr_flags & NDR_SCALARS) {
303 47 : NDR_CHECK(ndr_push_align(ndr, 5));
304 47 : NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->package_name));
305 47 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->credential_size));
306 47 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->credential));
307 47 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
308 : }
309 94 : if (ndr_flags & NDR_BUFFERS) {
310 47 : NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->package_name));
311 47 : if (r->credential) {
312 47 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->credential_size));
313 47 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->credential, r->credential_size));
314 : }
315 : }
316 90 : return NDR_ERR_SUCCESS;
317 : }
318 :
319 58 : _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 58 : uint32_t size_credential_1 = 0;
323 58 : TALLOC_CTX *_mem_save_credential_0 = NULL;
324 58 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
325 58 : if (ndr_flags & NDR_SCALARS) {
326 29 : NDR_CHECK(ndr_pull_align(ndr, 5));
327 29 : NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->package_name));
328 29 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->credential_size));
329 29 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_credential));
330 29 : if (_ptr_credential) {
331 29 : NDR_PULL_ALLOC(ndr, r->credential);
332 : } else {
333 0 : r->credential = NULL;
334 : }
335 29 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
336 : }
337 58 : if (ndr_flags & NDR_BUFFERS) {
338 29 : NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->package_name));
339 29 : if (r->credential) {
340 29 : _mem_save_credential_0 = NDR_PULL_GET_MEM_CTX(ndr);
341 29 : NDR_PULL_SET_MEM_CTX(ndr, r->credential, 0);
342 29 : NDR_CHECK(ndr_pull_array_size(ndr, &r->credential));
343 29 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->credential, &size_credential_1));
344 29 : NDR_PULL_ALLOC_N(ndr, r->credential, size_credential_1);
345 29 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->credential, size_credential_1));
346 29 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_credential_0, 0);
347 : }
348 29 : if (r->credential) {
349 29 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->credential, r->credential_size));
350 : }
351 : }
352 54 : 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 47 : _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 47 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
374 47 : if (ndr_flags & NDR_SCALARS) {
375 47 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->credential_count));
376 47 : NDR_CHECK(ndr_push_align(ndr, 5));
377 47 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->credential_count));
378 94 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (r->credential_count); cntr_credentials_0++) {
379 47 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, NDR_SCALARS, &r->credentials[cntr_credentials_0]));
380 : }
381 47 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
382 : }
383 47 : if (ndr_flags & NDR_BUFFERS) {
384 94 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (r->credential_count); cntr_credentials_0++) {
385 47 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, NDR_BUFFERS, &r->credentials[cntr_credentials_0]));
386 : }
387 : }
388 45 : return NDR_ERR_SUCCESS;
389 : }
390 :
391 29 : _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 29 : uint32_t size_credentials_0 = 0;
394 2 : uint32_t cntr_credentials_0;
395 29 : TALLOC_CTX *_mem_save_credentials_0 = NULL;
396 29 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
397 29 : if (ndr_flags & NDR_SCALARS) {
398 29 : NDR_CHECK(ndr_pull_array_size(ndr, &r->credentials));
399 29 : NDR_CHECK(ndr_pull_align(ndr, 5));
400 29 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->credential_count));
401 29 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->credentials, &size_credentials_0));
402 29 : NDR_PULL_ALLOC_N(ndr, r->credentials, size_credentials_0);
403 29 : _mem_save_credentials_0 = NDR_PULL_GET_MEM_CTX(ndr);
404 29 : NDR_PULL_SET_MEM_CTX(ndr, r->credentials, 0);
405 58 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (size_credentials_0); cntr_credentials_0++) {
406 29 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, NDR_SCALARS, &r->credentials[cntr_credentials_0]));
407 : }
408 29 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_credentials_0, 0);
409 29 : if (r->credentials) {
410 29 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->credentials, r->credential_count));
411 : }
412 29 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
413 : }
414 29 : if (ndr_flags & NDR_BUFFERS) {
415 29 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->credentials, &size_credentials_0));
416 29 : _mem_save_credentials_0 = NDR_PULL_GET_MEM_CTX(ndr);
417 29 : NDR_PULL_SET_MEM_CTX(ndr, r->credentials, 0);
418 58 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (size_credentials_0); cntr_credentials_0++) {
419 29 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_SUPPLEMENTAL_SECPKG(ndr, NDR_BUFFERS, &r->credentials[cntr_credentials_0]));
420 : }
421 29 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_credentials_0, 0);
422 56 : for (cntr_credentials_0 = 0; cntr_credentials_0 < (size_credentials_0); cntr_credentials_0++) {
423 : }
424 : }
425 27 : 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 47 : _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 47 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
452 47 : if (ndr_flags & NDR_SCALARS) {
453 47 : NDR_CHECK(ndr_push_align(ndr, 5));
454 47 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
455 47 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
456 : }
457 47 : if (ndr_flags & NDR_BUFFERS) {
458 47 : if (r->data) {
459 47 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, r->data));
460 : }
461 : }
462 45 : return NDR_ERR_SUCCESS;
463 : }
464 :
465 29 : _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 29 : TALLOC_CTX *_mem_save_data_0 = NULL;
469 29 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
470 29 : if (ndr_flags & NDR_SCALARS) {
471 29 : NDR_CHECK(ndr_pull_align(ndr, 5));
472 29 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
473 29 : if (_ptr_data) {
474 29 : NDR_PULL_ALLOC(ndr, r->data);
475 : } else {
476 0 : r->data = NULL;
477 : }
478 29 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
479 : }
480 29 : if (ndr_flags & NDR_BUFFERS) {
481 29 : if (r->data) {
482 29 : _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
483 29 : NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
484 29 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, r->data));
485 29 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
486 : }
487 : }
488 27 : 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 47 : _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 47 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
513 47 : if (ndr_flags & NDR_SCALARS) {
514 47 : NDR_CHECK(ndr_push_align(ndr, 1));
515 : {
516 2 : struct ndr_push *_ndr_ctr;
517 47 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr, 0xFFFFFC01, -1));
518 47 : NDR_CHECK(ndr_push_PAC_CREDENTIAL_DATA_CTR(_ndr_ctr, NDR_SCALARS|NDR_BUFFERS, &r->ctr));
519 47 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr, 0xFFFFFC01, -1));
520 : }
521 47 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
522 : }
523 47 : if (ndr_flags & NDR_BUFFERS) {
524 2 : }
525 47 : return NDR_ERR_SUCCESS;
526 : }
527 :
528 29 : _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 29 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
531 29 : if (ndr_flags & NDR_SCALARS) {
532 29 : NDR_CHECK(ndr_pull_align(ndr, 1));
533 : {
534 2 : struct ndr_pull *_ndr_ctr;
535 29 : ssize_t sub_size = -1;
536 29 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr, 0xFFFFFC01, sub_size));
537 29 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_DATA_CTR(_ndr_ctr, NDR_SCALARS|NDR_BUFFERS, &r->ctr));
538 29 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr, 0xFFFFFC01, sub_size));
539 : }
540 29 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
541 : }
542 29 : if (ndr_flags & NDR_BUFFERS) {
543 2 : }
544 29 : 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 57 : _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 57 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
564 57 : if (ndr_flags & NDR_SCALARS) {
565 57 : NDR_CHECK(ndr_push_align(ndr, 4));
566 57 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
567 57 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->encryption_type));
568 : {
569 57 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
570 57 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
571 57 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->encrypted_data));
572 57 : ndr->flags = _flags_save_DATA_BLOB;
573 : }
574 57 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
575 : }
576 57 : if (ndr_flags & NDR_BUFFERS) {
577 12 : }
578 57 : return NDR_ERR_SUCCESS;
579 : }
580 :
581 66 : _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 66 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
584 66 : if (ndr_flags & NDR_SCALARS) {
585 66 : NDR_CHECK(ndr_pull_align(ndr, 4));
586 66 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
587 66 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->encryption_type));
588 : {
589 66 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
590 66 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
591 66 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->encrypted_data));
592 66 : ndr->flags = _flags_save_DATA_BLOB;
593 : }
594 66 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
595 : }
596 66 : if (ndr_flags & NDR_BUFFERS) {
597 4 : }
598 66 : 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 40979 : 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 40979 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
721 39785 : return NDR_ERR_SUCCESS;
722 : }
723 :
724 104965 : 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 104965 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
728 104965 : *r = v;
729 104965 : 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 81916 : 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 81916 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
744 81916 : if (ndr_flags & NDR_SCALARS) {
745 40958 : NDR_CHECK(ndr_push_align(ndr, 5));
746 40958 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->samaccountname)));
747 : {
748 40958 : libndr_flags _flags_save_string = ndr->flags;
749 40958 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
750 40958 : NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->samaccountname));
751 40958 : ndr->flags = _flags_save_string;
752 : }
753 40958 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_dom_sid(r->objectsid, ndr->flags)));
754 40958 : NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->objectsid));
755 40958 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
756 : }
757 81916 : if (ndr_flags & NDR_BUFFERS) {
758 : {
759 40958 : libndr_flags _flags_save_string = ndr->flags;
760 40958 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
761 40958 : if (r->samaccountname) {
762 40958 : NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->samaccountname));
763 : {
764 1173 : struct ndr_push *_ndr_samaccountname;
765 40958 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_samaccountname, 0, 2 * strlen_m(r->samaccountname)));
766 40958 : NDR_CHECK(ndr_push_string(_ndr_samaccountname, NDR_SCALARS, r->samaccountname));
767 40958 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_samaccountname, 0, 2 * strlen_m(r->samaccountname)));
768 : }
769 : }
770 40958 : ndr->flags = _flags_save_string;
771 : }
772 40958 : if (r->objectsid) {
773 40958 : NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->objectsid));
774 : {
775 1173 : struct ndr_push *_ndr_objectsid;
776 40958 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_objectsid, 0, ndr_size_dom_sid(r->objectsid, ndr->flags)));
777 40958 : NDR_CHECK(ndr_push_dom_sid(_ndr_objectsid, NDR_SCALARS, r->objectsid));
778 40958 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_objectsid, 0, ndr_size_dom_sid(r->objectsid, ndr->flags)));
779 : }
780 : }
781 : }
782 79570 : return NDR_ERR_SUCCESS;
783 : }
784 :
785 209904 : 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 209904 : TALLOC_CTX *_mem_save_samaccountname_0 = NULL;
789 5100 : uint16_t _ptr_objectsid;
790 209904 : TALLOC_CTX *_mem_save_objectsid_0 = NULL;
791 209904 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
792 209904 : if (ndr_flags & NDR_SCALARS) {
793 104952 : NDR_CHECK(ndr_pull_align(ndr, 5));
794 104952 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->samaccountname_size));
795 : {
796 104952 : libndr_flags _flags_save_string = ndr->flags;
797 104952 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
798 104952 : NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_samaccountname));
799 104952 : if (_ptr_samaccountname) {
800 104952 : NDR_PULL_ALLOC(ndr, r->samaccountname);
801 104952 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->samaccountname, _ptr_samaccountname));
802 : } else {
803 0 : r->samaccountname = NULL;
804 : }
805 104952 : ndr->flags = _flags_save_string;
806 : }
807 104952 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->objectsid_size));
808 104952 : NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_objectsid));
809 104952 : if (_ptr_objectsid) {
810 104952 : NDR_PULL_ALLOC(ndr, r->objectsid);
811 104952 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->objectsid, _ptr_objectsid));
812 : } else {
813 0 : r->objectsid = NULL;
814 : }
815 104952 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
816 : }
817 209904 : if (ndr_flags & NDR_BUFFERS) {
818 : {
819 104952 : libndr_flags _flags_save_string = ndr->flags;
820 104952 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
821 104952 : if (r->samaccountname) {
822 2550 : uint32_t _relative_save_offset;
823 104952 : _relative_save_offset = ndr->offset;
824 104952 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->samaccountname));
825 104952 : _mem_save_samaccountname_0 = NDR_PULL_GET_MEM_CTX(ndr);
826 104952 : NDR_PULL_SET_MEM_CTX(ndr, r->samaccountname, 0);
827 : {
828 2550 : struct ndr_pull *_ndr_samaccountname;
829 104952 : ssize_t sub_size = r->samaccountname_size;
830 104952 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_samaccountname, 0, sub_size));
831 104952 : NDR_CHECK(ndr_pull_string(_ndr_samaccountname, NDR_SCALARS, &r->samaccountname));
832 104952 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_samaccountname, 0, sub_size));
833 : }
834 104952 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_samaccountname_0, 0);
835 104952 : if (ndr->offset > ndr->relative_highest_offset) {
836 104952 : ndr->relative_highest_offset = ndr->offset;
837 : }
838 104952 : ndr->offset = _relative_save_offset;
839 : }
840 104952 : ndr->flags = _flags_save_string;
841 : }
842 104952 : if (r->objectsid) {
843 2550 : uint32_t _relative_save_offset;
844 104952 : _relative_save_offset = ndr->offset;
845 104952 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->objectsid));
846 104952 : _mem_save_objectsid_0 = NDR_PULL_GET_MEM_CTX(ndr);
847 104952 : NDR_PULL_SET_MEM_CTX(ndr, r->objectsid, 0);
848 : {
849 2550 : struct ndr_pull *_ndr_objectsid;
850 104952 : ssize_t sub_size = r->objectsid_size;
851 104952 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_objectsid, 0, sub_size));
852 104952 : NDR_CHECK(ndr_pull_dom_sid(_ndr_objectsid, NDR_SCALARS, r->objectsid));
853 104952 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_objectsid, 0, sub_size));
854 : }
855 104952 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objectsid_0, 0);
856 104952 : if (ndr->offset > ndr->relative_highest_offset) {
857 104952 : ndr->relative_highest_offset = ndr->offset;
858 : }
859 104952 : ndr->offset = _relative_save_offset;
860 : }
861 : }
862 204804 : 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 81958 : 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 81958 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
896 81958 : if (ndr_flags & NDR_SCALARS) {
897 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
898 40979 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
899 40979 : NDR_CHECK(ndr_push_union_align(ndr, 5));
900 40979 : switch (level) {
901 40958 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID: {
902 40958 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, NDR_SCALARS, &r->sam_name_and_sid));
903 39785 : break; }
904 :
905 0 : default: {
906 0 : break; }
907 :
908 : }
909 : }
910 81958 : if (ndr_flags & NDR_BUFFERS) {
911 40979 : if (!(ndr_flags & NDR_SCALARS)) {
912 : /* We didn't get it above, and the token is not needed after this. */
913 40979 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
914 : }
915 40979 : switch (level) {
916 40958 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID:
917 40958 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, NDR_BUFFERS, &r->sam_name_and_sid));
918 39785 : break;
919 :
920 0 : default:
921 0 : break;
922 :
923 : }
924 : }
925 79570 : return NDR_ERR_SUCCESS;
926 : }
927 :
928 209930 : 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 209930 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
932 209930 : if (ndr_flags & NDR_SCALARS) {
933 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
934 104965 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
935 104965 : NDR_CHECK(ndr_pull_union_align(ndr, 5));
936 104965 : switch (level) {
937 104952 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID: {
938 104952 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, NDR_SCALARS, &r->sam_name_and_sid));
939 102402 : break; }
940 :
941 0 : default: {
942 0 : break; }
943 :
944 : }
945 : }
946 209930 : if (ndr_flags & NDR_BUFFERS) {
947 104965 : if (!(ndr_flags & NDR_SCALARS)) {
948 : /* We didn't get it above, and the token is not needed after this. */
949 104965 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
950 : }
951 104965 : switch (level) {
952 104952 : case PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID:
953 104952 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO_SAM_NAME_AND_SID(ndr, NDR_BUFFERS, &r->sam_name_and_sid));
954 102402 : break;
955 :
956 0 : default:
957 0 : break;
958 :
959 : }
960 : }
961 204804 : 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 81958 : 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 81958 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
983 81958 : if (ndr_flags & NDR_SCALARS) {
984 40979 : NDR_CHECK(ndr_push_align(ndr, 5));
985 40979 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->upn_name)));
986 : {
987 40979 : libndr_flags _flags_save_string = ndr->flags;
988 40979 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
989 40979 : NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->upn_name));
990 40979 : ndr->flags = _flags_save_string;
991 : }
992 40979 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->dns_domain_name)));
993 : {
994 40979 : libndr_flags _flags_save_string = ndr->flags;
995 40979 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
996 40979 : NDR_CHECK(ndr_push_short_relative_ptr1(ndr, r->dns_domain_name));
997 40979 : ndr->flags = _flags_save_string;
998 : }
999 42173 : NDR_CHECK(ndr_push_PAC_UPN_DNS_FLAGS(ndr, NDR_SCALARS, r->flags));
1000 40979 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID));
1001 40979 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO_EX(ndr, NDR_SCALARS, &r->ex));
1002 40979 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1003 : }
1004 81958 : if (ndr_flags & NDR_BUFFERS) {
1005 : {
1006 40979 : libndr_flags _flags_save_string = ndr->flags;
1007 40979 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1008 40979 : if (r->upn_name) {
1009 40979 : NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->upn_name));
1010 : {
1011 1194 : struct ndr_push *_ndr_upn_name;
1012 40979 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_upn_name, 0, 2 * strlen_m(r->upn_name)));
1013 40979 : NDR_CHECK(ndr_push_string(_ndr_upn_name, NDR_SCALARS, r->upn_name));
1014 40979 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_upn_name, 0, 2 * strlen_m(r->upn_name)));
1015 : }
1016 : }
1017 40979 : ndr->flags = _flags_save_string;
1018 : }
1019 : {
1020 40979 : libndr_flags _flags_save_string = ndr->flags;
1021 40979 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1022 40979 : if (r->dns_domain_name) {
1023 40979 : NDR_CHECK(ndr_push_short_relative_ptr2(ndr, r->dns_domain_name));
1024 : {
1025 1194 : struct ndr_push *_ndr_dns_domain_name;
1026 40979 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_dns_domain_name, 0, 2 * strlen_m(r->dns_domain_name)));
1027 40979 : NDR_CHECK(ndr_push_string(_ndr_dns_domain_name, NDR_SCALARS, r->dns_domain_name));
1028 40979 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_dns_domain_name, 0, 2 * strlen_m(r->dns_domain_name)));
1029 : }
1030 : }
1031 40979 : ndr->flags = _flags_save_string;
1032 : }
1033 40979 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID));
1034 40979 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO_EX(ndr, NDR_BUFFERS, &r->ex));
1035 : }
1036 79570 : return NDR_ERR_SUCCESS;
1037 : }
1038 :
1039 209930 : 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 209930 : TALLOC_CTX *_mem_save_upn_name_0 = NULL;
1043 5126 : uint16_t _ptr_dns_domain_name;
1044 209930 : TALLOC_CTX *_mem_save_dns_domain_name_0 = NULL;
1045 209930 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1046 209930 : if (ndr_flags & NDR_SCALARS) {
1047 104965 : NDR_CHECK(ndr_pull_align(ndr, 5));
1048 104965 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->upn_name_size));
1049 : {
1050 104965 : libndr_flags _flags_save_string = ndr->flags;
1051 104965 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1052 104965 : NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_upn_name));
1053 104965 : if (_ptr_upn_name) {
1054 104965 : NDR_PULL_ALLOC(ndr, r->upn_name);
1055 104965 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->upn_name, _ptr_upn_name));
1056 : } else {
1057 0 : r->upn_name = NULL;
1058 : }
1059 104965 : ndr->flags = _flags_save_string;
1060 : }
1061 104965 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->dns_domain_name_size));
1062 : {
1063 104965 : libndr_flags _flags_save_string = ndr->flags;
1064 104965 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1065 104965 : NDR_CHECK(ndr_pull_relative_ptr_short(ndr, &_ptr_dns_domain_name));
1066 104965 : if (_ptr_dns_domain_name) {
1067 104965 : NDR_PULL_ALLOC(ndr, r->dns_domain_name);
1068 104965 : 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 104965 : ndr->flags = _flags_save_string;
1073 : }
1074 107528 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_FLAGS(ndr, NDR_SCALARS, &r->flags));
1075 104965 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID));
1076 104965 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO_EX(ndr, NDR_SCALARS, &r->ex));
1077 104965 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1078 : }
1079 209930 : if (ndr_flags & NDR_BUFFERS) {
1080 : {
1081 104965 : libndr_flags _flags_save_string = ndr->flags;
1082 104965 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1083 104965 : if (r->upn_name) {
1084 2563 : uint32_t _relative_save_offset;
1085 104965 : _relative_save_offset = ndr->offset;
1086 104965 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->upn_name));
1087 104965 : _mem_save_upn_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1088 104965 : NDR_PULL_SET_MEM_CTX(ndr, r->upn_name, 0);
1089 : {
1090 2563 : struct ndr_pull *_ndr_upn_name;
1091 104965 : ssize_t sub_size = r->upn_name_size;
1092 104965 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_upn_name, 0, sub_size));
1093 104965 : NDR_CHECK(ndr_pull_string(_ndr_upn_name, NDR_SCALARS, &r->upn_name));
1094 104965 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_upn_name, 0, sub_size));
1095 : }
1096 104965 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_upn_name_0, 0);
1097 104965 : if (ndr->offset > ndr->relative_highest_offset) {
1098 104965 : ndr->relative_highest_offset = ndr->offset;
1099 : }
1100 104965 : ndr->offset = _relative_save_offset;
1101 : }
1102 104965 : ndr->flags = _flags_save_string;
1103 : }
1104 : {
1105 104965 : libndr_flags _flags_save_string = ndr->flags;
1106 104965 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1107 104965 : if (r->dns_domain_name) {
1108 2563 : uint32_t _relative_save_offset;
1109 104965 : _relative_save_offset = ndr->offset;
1110 104965 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dns_domain_name));
1111 104965 : _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1112 104965 : NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
1113 : {
1114 2563 : struct ndr_pull *_ndr_dns_domain_name;
1115 104965 : ssize_t sub_size = r->dns_domain_name_size;
1116 104965 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_dns_domain_name, 0, sub_size));
1117 104965 : NDR_CHECK(ndr_pull_string(_ndr_dns_domain_name, NDR_SCALARS, &r->dns_domain_name));
1118 104965 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_dns_domain_name, 0, sub_size));
1119 : }
1120 104965 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
1121 104965 : if (ndr->offset > ndr->relative_highest_offset) {
1122 104965 : ndr->relative_highest_offset = ndr->offset;
1123 : }
1124 104965 : ndr->offset = _relative_save_offset;
1125 : }
1126 104965 : ndr->flags = _flags_save_string;
1127 : }
1128 104965 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ex, r->flags & PAC_UPN_DNS_FLAG_HAS_SAM_NAME_AND_SID));
1129 104965 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO_EX(ndr, NDR_BUFFERS, &r->ex));
1130 : }
1131 204804 : 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 35781 : 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 35781 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1172 34611 : return NDR_ERR_SUCCESS;
1173 : }
1174 :
1175 25143 : 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 25143 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1179 25143 : *r = v;
1180 25143 : 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 35781 : 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 35781 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1195 35781 : if (ndr_flags & NDR_SCALARS) {
1196 35781 : NDR_CHECK(ndr_push_align(ndr, 4));
1197 35781 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags_length));
1198 36951 : NDR_CHECK(ndr_push_PAC_ATTRIBUTE_INFO_FLAGS(ndr, NDR_SCALARS, r->flags));
1199 35781 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1200 : }
1201 35781 : if (ndr_flags & NDR_BUFFERS) {
1202 1170 : }
1203 35781 : return NDR_ERR_SUCCESS;
1204 : }
1205 :
1206 25143 : 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 25143 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1209 25143 : if (ndr_flags & NDR_SCALARS) {
1210 25143 : NDR_CHECK(ndr_pull_align(ndr, 4));
1211 25143 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags_length));
1212 25775 : NDR_CHECK(ndr_pull_PAC_ATTRIBUTE_INFO_FLAGS(ndr, NDR_SCALARS, &r->flags));
1213 25143 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1214 : }
1215 25143 : if (ndr_flags & NDR_BUFFERS) {
1216 632 : }
1217 25143 : 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 35775 : 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 35775 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1233 35775 : if (ndr_flags & NDR_SCALARS) {
1234 35775 : NDR_CHECK(ndr_push_align(ndr, 4));
1235 35775 : NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->sid));
1236 35775 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1237 : }
1238 35775 : if (ndr_flags & NDR_BUFFERS) {
1239 1170 : }
1240 35775 : return NDR_ERR_SUCCESS;
1241 : }
1242 :
1243 55136 : 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 55136 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1246 55136 : if (ndr_flags & NDR_SCALARS) {
1247 55136 : NDR_CHECK(ndr_pull_align(ndr, 4));
1248 55136 : NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->sid));
1249 55136 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1250 : }
1251 55136 : if (ndr_flags & NDR_BUFFERS) {
1252 1667 : }
1253 55136 : 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 89531 : _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 89531 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1268 89531 : if (ndr_flags & NDR_SCALARS) {
1269 89531 : NDR_CHECK(ndr_push_align(ndr, 5));
1270 89531 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
1271 89531 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1272 : }
1273 89531 : if (ndr_flags & NDR_BUFFERS) {
1274 89531 : if (r->info) {
1275 89531 : NDR_CHECK(ndr_push_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
1276 : }
1277 : }
1278 86661 : return NDR_ERR_SUCCESS;
1279 : }
1280 :
1281 105528 : _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 105528 : TALLOC_CTX *_mem_save_info_0 = NULL;
1285 105528 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1286 105528 : if (ndr_flags & NDR_SCALARS) {
1287 105528 : NDR_CHECK(ndr_pull_align(ndr, 5));
1288 105528 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
1289 105528 : if (_ptr_info) {
1290 105528 : NDR_PULL_ALLOC(ndr, r->info);
1291 : } else {
1292 0 : r->info = NULL;
1293 : }
1294 105528 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1295 : }
1296 105528 : if (ndr_flags & NDR_BUFFERS) {
1297 105528 : if (r->info) {
1298 105528 : _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1299 105528 : NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
1300 105528 : NDR_CHECK(ndr_pull_PAC_LOGON_INFO(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
1301 105528 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1302 : }
1303 : }
1304 102956 : 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 156893 : _PUBLIC_ enum ndr_err_code ndr_push_PAC_TYPE(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum PAC_TYPE r)
1629 : {
1630 156893 : NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1631 156740 : return NDR_ERR_SUCCESS;
1632 : }
1633 :
1634 271101 : _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 271101 : NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1638 271101 : *r = v;
1639 271101 : 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 140483 : 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 140483 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1668 140483 : if (ndr_flags & NDR_SCALARS) {
1669 140483 : NDR_CHECK(ndr_push_align(ndr, 4));
1670 : {
1671 140483 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1672 140483 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1673 140483 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
1674 140483 : ndr->flags = _flags_save_DATA_BLOB;
1675 : }
1676 140483 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1677 : }
1678 140483 : if (ndr_flags & NDR_BUFFERS) {
1679 82 : }
1680 140483 : return NDR_ERR_SUCCESS;
1681 : }
1682 :
1683 119853 : 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 119853 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1686 119853 : if (ndr_flags & NDR_SCALARS) {
1687 119853 : NDR_CHECK(ndr_pull_align(ndr, 4));
1688 : {
1689 119853 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1690 119853 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1691 119853 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
1692 119853 : ndr->flags = _flags_save_DATA_BLOB;
1693 : }
1694 119853 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1695 : }
1696 119853 : if (ndr_flags & NDR_BUFFERS) {
1697 99 : }
1698 119853 : 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 246022 : _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 246022 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1719 246022 : if (ndr_flags & NDR_SCALARS) {
1720 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
1721 246022 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
1722 246022 : NDR_CHECK(ndr_push_union_align(ndr, 5));
1723 246022 : switch (level) {
1724 89531 : case PAC_TYPE_LOGON_INFO: {
1725 : {
1726 2870 : struct ndr_push *_ndr_logon_info;
1727 89531 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_logon_info, 0xFFFFFC01, -1));
1728 89531 : NDR_CHECK(ndr_push_PAC_LOGON_INFO_CTR(_ndr_logon_info, NDR_SCALARS|NDR_BUFFERS, &r->logon_info));
1729 89531 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_logon_info, 0xFFFFFC01, -1));
1730 : }
1731 89531 : 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 40979 : case PAC_TYPE_UPN_DNS_INFO: {
1759 40979 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO(ndr, NDR_SCALARS, &r->upn_dns_info));
1760 39785 : 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 35781 : case PAC_TYPE_ATTRIBUTES_INFO: {
1767 35781 : NDR_CHECK(ndr_push_PAC_ATTRIBUTES_INFO(ndr, NDR_SCALARS, &r->attributes_info));
1768 34611 : break; }
1769 :
1770 35775 : case PAC_TYPE_REQUESTER_SID: {
1771 35775 : NDR_CHECK(ndr_push_PAC_REQUESTER_SID(ndr, NDR_SCALARS, &r->requester_sid));
1772 34605 : 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 246022 : if (ndr_flags & NDR_BUFFERS) {
1817 246022 : 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 246022 : switch (level) {
1822 86661 : case PAC_TYPE_LOGON_INFO:
1823 86661 : 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 40979 : case PAC_TYPE_UPN_DNS_INFO:
1841 40979 : NDR_CHECK(ndr_push_PAC_UPN_DNS_INFO(ndr, NDR_BUFFERS, &r->upn_dns_info));
1842 39785 : break;
1843 :
1844 1734 : case PAC_TYPE_TICKET_CHECKSUM:
1845 1734 : break;
1846 :
1847 34611 : case PAC_TYPE_ATTRIBUTES_INFO:
1848 34611 : break;
1849 :
1850 34605 : case PAC_TYPE_REQUESTER_SID:
1851 34605 : 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 239474 : return NDR_ERR_SUCCESS;
1871 : }
1872 :
1873 409279 : _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 409279 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1877 409279 : if (ndr_flags & NDR_SCALARS) {
1878 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
1879 409279 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
1880 409279 : NDR_CHECK(ndr_pull_union_align(ndr, 5));
1881 409279 : switch (level) {
1882 105528 : case PAC_TYPE_LOGON_INFO: {
1883 : {
1884 2572 : struct ndr_pull *_ndr_logon_info;
1885 105528 : ssize_t sub_size = -1;
1886 105528 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_logon_info, 0xFFFFFC01, sub_size));
1887 105528 : NDR_CHECK(ndr_pull_PAC_LOGON_INFO_CTR(_ndr_logon_info, NDR_SCALARS|NDR_BUFFERS, &r->logon_info));
1888 105528 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_logon_info, 0xFFFFFC01, sub_size));
1889 : }
1890 105528 : break; }
1891 :
1892 66 : case PAC_TYPE_CREDENTIAL_INFO: {
1893 66 : NDR_CHECK(ndr_pull_PAC_CREDENTIAL_INFO(ndr, NDR_SCALARS, &r->credential_info));
1894 62 : break; }
1895 :
1896 23207 : case PAC_TYPE_SRV_CHECKSUM: {
1897 23207 : NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->srv_cksum));
1898 23176 : break; }
1899 :
1900 23207 : case PAC_TYPE_KDC_CHECKSUM: {
1901 23207 : NDR_CHECK(ndr_pull_PAC_SIGNATURE_DATA(ndr, NDR_SCALARS, &r->kdc_cksum));
1902 23176 : break; }
1903 :
1904 23207 : case PAC_TYPE_LOGON_NAME: {
1905 23207 : NDR_CHECK(ndr_pull_PAC_LOGON_NAME(ndr, NDR_SCALARS, &r->logon_name));
1906 23176 : 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 104965 : case PAC_TYPE_UPN_DNS_INFO: {
1919 104965 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO(ndr, NDR_SCALARS, &r->upn_dns_info));
1920 102402 : 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 25143 : case PAC_TYPE_ATTRIBUTES_INFO: {
1927 25143 : NDR_CHECK(ndr_pull_PAC_ATTRIBUTES_INFO(ndr, NDR_SCALARS, &r->attributes_info));
1928 24511 : break; }
1929 :
1930 55136 : case PAC_TYPE_REQUESTER_SID: {
1931 55136 : NDR_CHECK(ndr_pull_PAC_REQUESTER_SID(ndr, NDR_SCALARS, &r->requester_sid));
1932 53469 : break; }
1933 :
1934 22677 : case PAC_TYPE_CLIENT_CLAIMS_INFO: {
1935 : {
1936 9 : struct ndr_pull *_ndr_client_claims_info;
1937 22677 : ssize_t sub_size = -1;
1938 22677 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_client_claims_info, 0, sub_size));
1939 22677 : NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_client_claims_info, NDR_SCALARS, &r->client_claims_info));
1940 22677 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_client_claims_info, 0, sub_size));
1941 : }
1942 22677 : 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 409279 : if (ndr_flags & NDR_BUFFERS) {
1981 409279 : 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 409279 : switch (level) {
1986 102956 : case PAC_TYPE_LOGON_INFO:
1987 102956 : break;
1988 :
1989 62 : case PAC_TYPE_CREDENTIAL_INFO:
1990 62 : break;
1991 :
1992 23176 : case PAC_TYPE_SRV_CHECKSUM:
1993 23176 : break;
1994 :
1995 23176 : case PAC_TYPE_KDC_CHECKSUM:
1996 23176 : break;
1997 :
1998 23176 : case PAC_TYPE_LOGON_NAME:
1999 23176 : break;
2000 :
2001 295 : case PAC_TYPE_CONSTRAINED_DELEGATION:
2002 295 : break;
2003 :
2004 104965 : case PAC_TYPE_UPN_DNS_INFO:
2005 104965 : NDR_CHECK(ndr_pull_PAC_UPN_DNS_INFO(ndr, NDR_BUFFERS, &r->upn_dns_info));
2006 102402 : break;
2007 :
2008 12782 : case PAC_TYPE_TICKET_CHECKSUM:
2009 12782 : break;
2010 :
2011 24511 : case PAC_TYPE_ATTRIBUTES_INFO:
2012 24511 : break;
2013 :
2014 53469 : case PAC_TYPE_REQUESTER_SID:
2015 53469 : break;
2016 :
2017 22668 : case PAC_TYPE_CLIENT_CLAIMS_INFO:
2018 22668 : 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 401735 : 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 23207 : _PUBLIC_ enum ndr_err_code ndr_pull_PAC_DATA(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct PAC_DATA *r)
2161 : {
2162 23207 : uint32_t size_buffers_0 = 0;
2163 31 : uint32_t cntr_buffers_0;
2164 23207 : TALLOC_CTX *_mem_save_buffers_0 = NULL;
2165 23207 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2166 23207 : if (ndr_flags & NDR_SCALARS) {
2167 23207 : NDR_CHECK(ndr_pull_align(ndr, 5));
2168 23207 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_buffers));
2169 23207 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2170 23207 : size_buffers_0 = r->num_buffers;
2171 23207 : NDR_PULL_ALLOC_N(ndr, r->buffers, size_buffers_0);
2172 23207 : _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2173 23207 : NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
2174 197274 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2175 174067 : NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
2176 : }
2177 23207 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
2178 23207 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2179 : }
2180 23207 : if (ndr_flags & NDR_BUFFERS) {
2181 23207 : size_buffers_0 = r->num_buffers;
2182 23207 : _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2183 23207 : NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
2184 197274 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2185 174067 : NDR_CHECK(ndr_pull_PAC_BUFFER(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
2186 : }
2187 23207 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
2188 197091 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2189 : }
2190 : }
2191 23176 : 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 260674 : _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 260674 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2219 260674 : if (ndr_flags & NDR_SCALARS) {
2220 130337 : NDR_CHECK(ndr_push_align(ndr, 5));
2221 130337 : NDR_CHECK(ndr_push_PAC_TYPE(ndr, NDR_SCALARS, r->type));
2222 130337 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ndr_size));
2223 : {
2224 130337 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2225 130337 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2226 130337 : NDR_CHECK(ndr_push_relative_ptr1(ndr, r->info));
2227 130337 : ndr->flags = _flags_save_DATA_BLOB_REM;
2228 : }
2229 130337 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2230 130337 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2231 : }
2232 260674 : if (ndr_flags & NDR_BUFFERS) {
2233 : {
2234 130337 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2235 130337 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2236 130337 : if (r->info) {
2237 130337 : NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->info));
2238 : {
2239 82 : struct ndr_push *_ndr_info;
2240 130337 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
2241 130337 : NDR_CHECK(ndr_push_DATA_BLOB_REM(_ndr_info, NDR_SCALARS, r->info));
2242 130337 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 0, NDR_ROUND(r->ndr_size, 8)));
2243 : }
2244 130337 : NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->info));
2245 : }
2246 130337 : ndr->flags = _flags_save_DATA_BLOB_REM;
2247 : }
2248 : }
2249 260510 : return NDR_ERR_SUCCESS;
2250 : }
2251 :
2252 194064 : _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 194064 : TALLOC_CTX *_mem_save_info_0 = NULL;
2256 194064 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2257 194064 : if (ndr_flags & NDR_SCALARS) {
2258 97032 : NDR_CHECK(ndr_pull_align(ndr, 5));
2259 97032 : NDR_CHECK(ndr_pull_PAC_TYPE(ndr, NDR_SCALARS, &r->type));
2260 97032 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ndr_size));
2261 : {
2262 97032 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2263 97032 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2264 97032 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
2265 97032 : if (_ptr_info) {
2266 97032 : NDR_PULL_ALLOC(ndr, r->info);
2267 97032 : NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->info, _ptr_info));
2268 : } else {
2269 0 : r->info = NULL;
2270 : }
2271 97032 : ndr->flags = _flags_save_DATA_BLOB_REM;
2272 : }
2273 97032 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
2274 97032 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2275 : }
2276 194064 : if (ndr_flags & NDR_BUFFERS) {
2277 : {
2278 97032 : libndr_flags _flags_save_DATA_BLOB_REM = ndr->flags;
2279 97032 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
2280 97032 : if (r->info) {
2281 90 : uint32_t _relative_save_offset;
2282 97032 : _relative_save_offset = ndr->offset;
2283 97032 : NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->info));
2284 97032 : _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2285 97032 : NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
2286 : {
2287 90 : struct ndr_pull *_ndr_info;
2288 97032 : ssize_t sub_size = NDR_ROUND(r->ndr_size, 8);
2289 97032 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 0, sub_size));
2290 97032 : NDR_CHECK(ndr_pull_DATA_BLOB_REM(_ndr_info, NDR_SCALARS, r->info));
2291 97032 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 0, sub_size));
2292 : }
2293 97032 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
2294 97032 : if (ndr->offset > ndr->relative_highest_offset) {
2295 84849 : ndr->relative_highest_offset = ndr->offset;
2296 : }
2297 97032 : ndr->offset = _relative_save_offset;
2298 : }
2299 97032 : ndr->flags = _flags_save_DATA_BLOB_REM;
2300 : }
2301 : }
2302 193884 : 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 17108 : _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 17108 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2336 17108 : if (ndr_flags & NDR_SCALARS) {
2337 17108 : NDR_CHECK(ndr_push_align(ndr, 5));
2338 17108 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_buffers));
2339 17108 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2340 147445 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (r->num_buffers); cntr_buffers_0++) {
2341 130337 : NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
2342 : }
2343 17108 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2344 : }
2345 17108 : if (ndr_flags & NDR_BUFFERS) {
2346 147445 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (r->num_buffers); cntr_buffers_0++) {
2347 130337 : NDR_CHECK(ndr_push_PAC_BUFFER_RAW(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
2348 : }
2349 : }
2350 17091 : return NDR_ERR_SUCCESS;
2351 : }
2352 :
2353 12976 : _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 12976 : uint32_t size_buffers_0 = 0;
2356 18 : uint32_t cntr_buffers_0;
2357 12976 : TALLOC_CTX *_mem_save_buffers_0 = NULL;
2358 12976 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2359 12976 : if (ndr_flags & NDR_SCALARS) {
2360 12976 : NDR_CHECK(ndr_pull_align(ndr, 5));
2361 12976 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_buffers));
2362 12976 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2363 12976 : size_buffers_0 = r->num_buffers;
2364 12976 : NDR_PULL_ALLOC_N(ndr, r->buffers, size_buffers_0);
2365 12976 : _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2366 12976 : NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
2367 110008 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2368 97032 : NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_SCALARS, &r->buffers[cntr_buffers_0]));
2369 : }
2370 12976 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
2371 12976 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2372 : }
2373 12976 : if (ndr_flags & NDR_BUFFERS) {
2374 12976 : size_buffers_0 = r->num_buffers;
2375 12976 : _mem_save_buffers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2376 12976 : NDR_PULL_SET_MEM_CTX(ndr, r->buffers, 0);
2377 110008 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2378 97032 : NDR_CHECK(ndr_pull_PAC_BUFFER_RAW(ndr, NDR_BUFFERS, &r->buffers[cntr_buffers_0]));
2379 : }
2380 12976 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffers_0, 0);
2381 109918 : for (cntr_buffers_0 = 0; cntr_buffers_0 < (size_buffers_0); cntr_buffers_0++) {
2382 : }
2383 : }
2384 12958 : 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 97031 : _PUBLIC_ enum ndr_err_code ndr_pull_netsamlogoncache_entry(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct netsamlogoncache_entry *r)
2492 : {
2493 97031 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2494 97031 : if (ndr_flags & NDR_SCALARS) {
2495 97031 : NDR_CHECK(ndr_pull_align(ndr, 5));
2496 97031 : NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
2497 97031 : NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_SCALARS, &r->info3));
2498 97031 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2499 : }
2500 97031 : if (ndr_flags & NDR_BUFFERS) {
2501 97031 : NDR_CHECK(ndr_pull_netr_SamInfo3(ndr, NDR_BUFFERS, &r->info3));
2502 : }
2503 97031 : 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 */
|
