Line data Source code
1 : /* Generated from /builds/samba-team/lts-community/samba/third_party/heimdal/lib/asn1/krb5.asn1 */
2 : /* Do not edit */
3 :
4 : #if defined(_WIN32) && !defined(ASN1_LIB)
5 : # error "ASN1_LIB must be defined"
6 : #endif
7 : #include <stdio.h>
8 : #include <stdlib.h>
9 : #include <time.h>
10 : #include <string.h>
11 : #include <errno.h>
12 : #include <limits.h>
13 : #include <krb5-types.h>
14 : #include "krb5_asn1.h"
15 : #include "krb5_asn1-priv.h"
16 : #include <asn1_err.h>
17 : #include <der.h>
18 : #include <asn1-template.h>
19 :
20 : #include <parse_units.h>
21 :
22 : extern const struct asn1_template asn1_NAME_TYPE[];
23 : extern const struct asn1_template asn1_NAME_TYPE[];
24 : extern const struct asn1_template asn1_MESSAGE_TYPE[];
25 : extern const struct asn1_template asn1_MESSAGE_TYPE[];
26 : extern const struct asn1_template asn1_PADATA_TYPE[];
27 : extern const struct asn1_template asn1_PADATA_TYPE[];
28 : extern const struct asn1_template asn1_AUTHDATA_TYPE[];
29 : extern const struct asn1_template asn1_AUTHDATA_TYPE[];
30 : extern const struct asn1_template asn1_CKSUMTYPE[];
31 : extern const struct asn1_template asn1_CKSUMTYPE[];
32 : extern const struct asn1_template asn1_ENCTYPE[];
33 : extern const struct asn1_template asn1_ENCTYPE[];
34 : extern const struct asn1_template asn1_Krb5UInt32[];
35 : extern const struct asn1_template asn1_Krb5UInt32[];
36 : extern const struct asn1_template asn1_Krb5Int32[];
37 : extern const struct asn1_template asn1_Krb5Int32[];
38 : extern const struct asn1_template asn1_KerberosString[];
39 : extern const struct asn1_template asn1_KerberosString[];
40 : extern const struct asn1_template asn1_Realm[];
41 : extern const struct asn1_template asn1_Realm[];
42 : extern const struct asn1_template asn1_PrincipalName[];
43 : extern const struct asn1_template asn1_HostAddress[];
44 : extern const struct asn1_template asn1_HostAddresses[];
45 : extern const struct asn1_template asn1_KerberosTime[];
46 : extern const struct asn1_template asn1_KerberosTime[];
47 : extern const struct asn1_template asn1_AuthorizationDataElement[];
48 : extern const struct asn1_template asn1_AuthorizationData[];
49 : extern const struct asn1_template asn1_APOptions[];
50 : extern const struct asn1_template asn1_APOptions[];
51 : extern const struct asn1_template asn1_TicketFlags[];
52 : extern const struct asn1_template asn1_TicketFlags[];
53 : extern const struct asn1_template asn1_KDCOptions[];
54 : extern const struct asn1_template asn1_KDCOptions[];
55 : extern const struct asn1_template asn1_LR_TYPE[];
56 : extern const struct asn1_template asn1_LR_TYPE[];
57 : extern const struct asn1_template asn1_LastReq[];
58 : extern const struct asn1_template asn1_EncryptedData[];
59 : extern const struct asn1_template asn1_EncryptionKey[];
60 : extern const struct asn1_template asn1_TransitedEncoding[];
61 : extern const struct asn1_template asn1_Ticket[];
62 : extern const struct asn1_template asn1_EncTicketPart[];
63 : extern const struct asn1_template asn1_Checksum[];
64 : extern const struct asn1_template asn1_PrincipalNameAttrSrc[];
65 : extern const struct asn1_template asn1_PrincipalNameAttrs[];
66 : extern const struct asn1_template asn1_CompositePrincipal[];
67 : extern const struct asn1_template asn1_Principal[];
68 : extern const struct asn1_template asn1_Principals[];
69 : extern const struct asn1_template asn1_Authenticator[];
70 : extern const struct asn1_template asn1_PA_DATA[];
71 : extern const struct asn1_template asn1_ETYPE_INFO_ENTRY[];
72 : extern const struct asn1_template asn1_ETYPE_INFO[];
73 : extern const struct asn1_template asn1_ETYPE_INFO2_ENTRY[];
74 : extern const struct asn1_template asn1_ETYPE_INFO2[];
75 : extern const struct asn1_template asn1_METHOD_DATA[];
76 : extern const struct asn1_template asn1_TypedData[];
77 : extern const struct asn1_template asn1_TYPED_DATA[];
78 : extern const struct asn1_template asn1_KDC_REQ_BODY[];
79 : extern const struct asn1_template asn1_KDC_REQ[];
80 : extern const struct asn1_template asn1_AS_REQ[];
81 : extern const struct asn1_template asn1_AS_REQ[];
82 : extern const struct asn1_template asn1_TGS_REQ[];
83 : extern const struct asn1_template asn1_TGS_REQ[];
84 : extern const struct asn1_template asn1_PA_ENC_TS_ENC[];
85 : extern const struct asn1_template asn1_PA_PAC_REQUEST[];
86 : extern const struct asn1_template asn1_PAC_OPTIONS_FLAGS[];
87 : extern const struct asn1_template asn1_PAC_OPTIONS_FLAGS[];
88 : extern const struct asn1_template asn1_PA_PAC_OPTIONS[];
89 : extern const struct asn1_template asn1_KERB_AD_RESTRICTION_ENTRY[];
90 : extern const struct asn1_template asn1_PA_KERB_KEY_LIST_REQ[];
91 : extern const struct asn1_template asn1_PA_KERB_KEY_LIST_REP[];
92 : extern const struct asn1_template asn1_PROV_SRV_LOCATION[];
93 : extern const struct asn1_template asn1_PROV_SRV_LOCATION[];
94 : extern const struct asn1_template asn1_KDC_REP[];
95 : extern const struct asn1_template asn1_AS_REP[];
96 : extern const struct asn1_template asn1_AS_REP[];
97 : extern const struct asn1_template asn1_TGS_REP[];
98 : extern const struct asn1_template asn1_TGS_REP[];
99 : extern const struct asn1_template asn1_EncKDCRepPart[];
100 : extern const struct asn1_template asn1_EncASRepPart[];
101 : extern const struct asn1_template asn1_EncASRepPart[];
102 : extern const struct asn1_template asn1_EncTGSRepPart[];
103 : extern const struct asn1_template asn1_EncTGSRepPart[];
104 : extern const struct asn1_template asn1_AP_REQ[];
105 : extern const struct asn1_template asn1_AP_REP[];
106 : extern const struct asn1_template asn1_EncAPRepPart[];
107 : extern const struct asn1_template asn1_KRB_SAFE_BODY[];
108 : extern const struct asn1_template asn1_KRB_SAFE[];
109 : extern const struct asn1_template asn1_KRB_PRIV[];
110 : extern const struct asn1_template asn1_EncKrbPrivPart[];
111 : extern const struct asn1_template asn1_KRB_CRED[];
112 : extern const struct asn1_template asn1_KrbCredInfo[];
113 : extern const struct asn1_template asn1_EncKrbCredPart[];
114 : extern const struct asn1_template asn1_KRB_ERROR[];
115 : extern const struct asn1_template asn1_ChangePasswdDataMS[];
116 : extern const struct asn1_template asn1_EtypeList[];
117 : extern const struct asn1_template asn1_AD_IF_RELEVANT[];
118 : extern const struct asn1_template asn1_AD_IF_RELEVANT[];
119 : extern const struct asn1_template asn1_AD_KDCIssued[];
120 : extern const struct asn1_template asn1_AD_AND_OR[];
121 : extern const struct asn1_template asn1_AD_MANDATORY_FOR_KDC[];
122 : extern const struct asn1_template asn1_AD_MANDATORY_FOR_KDC[];
123 : extern const struct asn1_template asn1_PA_SAM_TYPE[];
124 : extern const struct asn1_template asn1_PA_SAM_TYPE[];
125 : extern const struct asn1_template asn1_PA_SAM_REDIRECT[];
126 : extern const struct asn1_template asn1_PA_SAM_REDIRECT[];
127 : extern const struct asn1_template asn1_SAMFlags[];
128 : extern const struct asn1_template asn1_SAMFlags[];
129 : extern const struct asn1_template asn1_PA_SAM_CHALLENGE_2_BODY[];
130 : extern const struct asn1_template asn1_PA_SAM_CHALLENGE_2[];
131 : extern const struct asn1_template asn1_PA_SAM_RESPONSE_2[];
132 : extern const struct asn1_template asn1_PA_ENC_SAM_RESPONSE_ENC[];
133 : extern const struct asn1_template asn1_PA_S4U2Self[];
134 : extern const struct asn1_template asn1_PA_S4U_X509_USER[];
135 : extern const struct asn1_template asn1_S4UUserID[];
136 : extern const struct asn1_template asn1_AD_LoginAlias[];
137 : extern const struct asn1_template asn1_PA_SvrReferralData[];
138 : extern const struct asn1_template asn1_PA_SERVER_REFERRAL_DATA[];
139 : extern const struct asn1_template asn1_PA_SERVER_REFERRAL_DATA[];
140 : extern const struct asn1_template asn1_PA_ServerReferralData[];
141 : extern const struct asn1_template asn1_FastOptions[];
142 : extern const struct asn1_template asn1_FastOptions[];
143 : extern const struct asn1_template asn1_KrbFastReq[];
144 : extern const struct asn1_template asn1_KrbFastArmor[];
145 : extern const struct asn1_template asn1_KrbFastArmoredReq[];
146 : extern const struct asn1_template asn1_PA_FX_FAST_REQUEST[];
147 : extern const struct asn1_template asn1_KrbFastFinished[];
148 : extern const struct asn1_template asn1_KrbFastResponse[];
149 : extern const struct asn1_template asn1_KrbFastArmoredRep[];
150 : extern const struct asn1_template asn1_PA_FX_FAST_REPLY[];
151 : extern const struct asn1_template asn1_KDCFastFlags[];
152 : extern const struct asn1_template asn1_KDCFastFlags[];
153 : extern const struct asn1_template asn1_KDCFastState[];
154 : extern const struct asn1_template asn1_KDCFastCookie[];
155 : extern const struct asn1_template asn1_KDC_PROXY_MESSAGE[];
156 : extern const struct asn1_template asn1_KERB_TIMES[];
157 : extern const struct asn1_template asn1_KERB_CRED[];
158 : extern const struct asn1_template asn1_KERB_TGS_REQ_IN[];
159 : extern const struct asn1_template asn1_KERB_TGS_REQ_OUT[];
160 : extern const struct asn1_template asn1_KERB_TGS_REP_IN[];
161 : extern const struct asn1_template asn1_KERB_TGS_REP_OUT[];
162 : extern const struct asn1_template asn1_KERB_ARMOR_SERVICE_REPLY[];
163 : /* template_members: NAME_TYPE exp exp */
164 : const struct asn1_template asn1_NAME_TYPE_enum_names[] = {
165 : /* 0 */ { 0, 0, ((void *)(uintptr_t)19) },
166 : /* 1 */ { A1_OP_NAME, 0, "KRB5_NT_UNKNOWN" },
167 : /* 2 */ { A1_OP_NAME, 1, "KRB5_NT_PRINCIPAL" },
168 : /* 3 */ { A1_OP_NAME, 2, "KRB5_NT_SRV_INST" },
169 : /* 4 */ { A1_OP_NAME, 3, "KRB5_NT_SRV_HST" },
170 : /* 5 */ { A1_OP_NAME, 4, "KRB5_NT_SRV_XHST" },
171 : /* 6 */ { A1_OP_NAME, 5, "KRB5_NT_UID" },
172 : /* 7 */ { A1_OP_NAME, 6, "KRB5_NT_X500_PRINCIPAL" },
173 : /* 8 */ { A1_OP_NAME, 7, "KRB5_NT_SMTP_NAME" },
174 : /* 9 */ { A1_OP_NAME, 10, "KRB5_NT_ENTERPRISE_PRINCIPAL" },
175 : /* 10 */ { A1_OP_NAME, 11, "KRB5_NT_WELLKNOWN" },
176 : /* 11 */ { A1_OP_NAME, 12, "KRB5_NT_SRV_HST_DOMAIN" },
177 : /* 12 */ { A1_OP_NAME, -130, "KRB5_NT_ENT_PRINCIPAL_AND_ID" },
178 : /* 13 */ { A1_OP_NAME, -128, "KRB5_NT_MS_PRINCIPAL" },
179 : /* 14 */ { A1_OP_NAME, -129, "KRB5_NT_MS_PRINCIPAL_AND_ID" },
180 : /* 15 */ { A1_OP_NAME, -1200, "KRB5_NT_NTLM" },
181 : /* 16 */ { A1_OP_NAME, -1201, "KRB5_NT_X509_GENERAL_NAME" },
182 : /* 17 */ { A1_OP_NAME, -1202, "KRB5_NT_GSS_HOSTBASED_SERVICE" },
183 : /* 18 */ { A1_OP_NAME, -1203, "KRB5_NT_CACHE_UUID" },
184 : /* 19 */ { A1_OP_NAME, -195894762, "KRB5_NT_SRV_HST_NEEDS_CANON" }
185 : };
186 : /* generate_template_type: NAME_TYPE_tag__0 */
187 : const struct asn1_template asn1_NAME_TYPE_tag__0[] = {
188 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
189 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_NAME_TYPE_enum_names }
190 : };
191 : /* generate_template_type: NAME_TYPE */
192 : const struct asn1_template asn1_NAME_TYPE[] = {
193 : /* 0 */ { 0, sizeof(NAME_TYPE), ((void *)(uintptr_t)1) },
194 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_NAME_TYPE_tag__0 }
195 : };
196 :
197 : int ASN1CALL
198 0 : decode_NAME_TYPE(const unsigned char *p, size_t len, NAME_TYPE *data, size_t *size)
199 : {
200 0 : memset(data, 0, sizeof(*data));
201 0 : return _asn1_decode_top(asn1_NAME_TYPE, 0|0, p, len, data, size);
202 : }
203 :
204 :
205 : int ASN1CALL
206 0 : encode_NAME_TYPE(unsigned char *p, size_t len, const NAME_TYPE *data, size_t *size)
207 : {
208 0 : return _asn1_encode(asn1_NAME_TYPE, p, len, data, size);
209 : }
210 :
211 :
212 : size_t ASN1CALL
213 0 : length_NAME_TYPE(const NAME_TYPE *data)
214 : {
215 0 : return _asn1_length(asn1_NAME_TYPE, data);
216 : }
217 :
218 :
219 : void ASN1CALL
220 0 : free_NAME_TYPE(NAME_TYPE *data)
221 : {
222 0 : _asn1_free_top(asn1_NAME_TYPE, data);
223 0 : }
224 :
225 :
226 : int ASN1CALL
227 0 : copy_NAME_TYPE(const NAME_TYPE *from, NAME_TYPE *to)
228 : {
229 0 : return _asn1_copy_top(asn1_NAME_TYPE, from, to);
230 : }
231 :
232 :
233 : char * ASN1CALL
234 0 : print_NAME_TYPE(const NAME_TYPE *data, int flags)
235 : {
236 0 : return _asn1_print_top(asn1_NAME_TYPE, flags, data);
237 : }
238 :
239 : /* template_members: MESSAGE_TYPE exp exp */
240 : const struct asn1_template asn1_MESSAGE_TYPE_enum_names[] = {
241 : /* 0 */ { 0, 0, ((void *)(uintptr_t)10) },
242 : /* 1 */ { A1_OP_NAME, 10, "krb-as-req" },
243 : /* 2 */ { A1_OP_NAME, 11, "krb-as-rep" },
244 : /* 3 */ { A1_OP_NAME, 12, "krb-tgs-req" },
245 : /* 4 */ { A1_OP_NAME, 13, "krb-tgs-rep" },
246 : /* 5 */ { A1_OP_NAME, 14, "krb-ap-req" },
247 : /* 6 */ { A1_OP_NAME, 15, "krb-ap-rep" },
248 : /* 7 */ { A1_OP_NAME, 20, "krb-safe" },
249 : /* 8 */ { A1_OP_NAME, 21, "krb-priv" },
250 : /* 9 */ { A1_OP_NAME, 22, "krb-cred" },
251 : /* 10 */ { A1_OP_NAME, 30, "krb-error" }
252 : };
253 : /* generate_template_type: MESSAGE_TYPE_tag__1 */
254 : const struct asn1_template asn1_MESSAGE_TYPE_tag__1[] = {
255 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
256 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_MESSAGE_TYPE_enum_names }
257 : };
258 : /* generate_template_type: MESSAGE_TYPE */
259 : const struct asn1_template asn1_MESSAGE_TYPE[] = {
260 : /* 0 */ { 0, sizeof(MESSAGE_TYPE), ((void *)(uintptr_t)1) },
261 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_MESSAGE_TYPE_tag__1 }
262 : };
263 :
264 : int ASN1CALL
265 0 : decode_MESSAGE_TYPE(const unsigned char *p, size_t len, MESSAGE_TYPE *data, size_t *size)
266 : {
267 0 : memset(data, 0, sizeof(*data));
268 0 : return _asn1_decode_top(asn1_MESSAGE_TYPE, 0|0, p, len, data, size);
269 : }
270 :
271 :
272 : int ASN1CALL
273 0 : encode_MESSAGE_TYPE(unsigned char *p, size_t len, const MESSAGE_TYPE *data, size_t *size)
274 : {
275 0 : return _asn1_encode(asn1_MESSAGE_TYPE, p, len, data, size);
276 : }
277 :
278 :
279 : size_t ASN1CALL
280 0 : length_MESSAGE_TYPE(const MESSAGE_TYPE *data)
281 : {
282 0 : return _asn1_length(asn1_MESSAGE_TYPE, data);
283 : }
284 :
285 :
286 : void ASN1CALL
287 0 : free_MESSAGE_TYPE(MESSAGE_TYPE *data)
288 : {
289 0 : _asn1_free_top(asn1_MESSAGE_TYPE, data);
290 0 : }
291 :
292 :
293 : int ASN1CALL
294 0 : copy_MESSAGE_TYPE(const MESSAGE_TYPE *from, MESSAGE_TYPE *to)
295 : {
296 0 : return _asn1_copy_top(asn1_MESSAGE_TYPE, from, to);
297 : }
298 :
299 :
300 : char * ASN1CALL
301 0 : print_MESSAGE_TYPE(const MESSAGE_TYPE *data, int flags)
302 : {
303 0 : return _asn1_print_top(asn1_MESSAGE_TYPE, flags, data);
304 : }
305 :
306 : /* template_members: PADATA_TYPE exp exp */
307 : const struct asn1_template asn1_PADATA_TYPE_enum_names[] = {
308 : /* 0 */ { 0, 0, ((void *)(uintptr_t)64) },
309 : /* 1 */ { A1_OP_NAME, 0, "KRB5-PADATA-NONE" },
310 : /* 2 */ { A1_OP_NAME, 1, "KRB5-PADATA-TGS-REQ" },
311 : /* 3 */ { A1_OP_NAME, 1, "KRB5-PADATA-AP-REQ" },
312 : /* 4 */ { A1_OP_NAME, 2, "KRB5-PADATA-ENC-TIMESTAMP" },
313 : /* 5 */ { A1_OP_NAME, 3, "KRB5-PADATA-PW-SALT" },
314 : /* 6 */ { A1_OP_NAME, 5, "KRB5-PADATA-ENC-UNIX-TIME" },
315 : /* 7 */ { A1_OP_NAME, 6, "KRB5-PADATA-SANDIA-SECUREID" },
316 : /* 8 */ { A1_OP_NAME, 7, "KRB5-PADATA-SESAME" },
317 : /* 9 */ { A1_OP_NAME, 8, "KRB5-PADATA-OSF-DCE" },
318 : /* 10 */ { A1_OP_NAME, 9, "KRB5-PADATA-CYBERSAFE-SECUREID" },
319 : /* 11 */ { A1_OP_NAME, 10, "KRB5-PADATA-AFS3-SALT" },
320 : /* 12 */ { A1_OP_NAME, 11, "KRB5-PADATA-ETYPE-INFO" },
321 : /* 13 */ { A1_OP_NAME, 12, "KRB5-PADATA-SAM-CHALLENGE" },
322 : /* 14 */ { A1_OP_NAME, 13, "KRB5-PADATA-SAM-RESPONSE" },
323 : /* 15 */ { A1_OP_NAME, 14, "KRB5-PADATA-PK-AS-REQ-19" },
324 : /* 16 */ { A1_OP_NAME, 15, "KRB5-PADATA-PK-AS-REP-19" },
325 : /* 17 */ { A1_OP_NAME, 15, "KRB5-PADATA-PK-AS-REQ-WIN" },
326 : /* 18 */ { A1_OP_NAME, 16, "KRB5-PADATA-PK-AS-REQ" },
327 : /* 19 */ { A1_OP_NAME, 17, "KRB5-PADATA-PK-AS-REP" },
328 : /* 20 */ { A1_OP_NAME, 18, "KRB5-PADATA-PA-PK-OCSP-RESPONSE" },
329 : /* 21 */ { A1_OP_NAME, 19, "KRB5-PADATA-ETYPE-INFO2" },
330 : /* 22 */ { A1_OP_NAME, 20, "KRB5-PADATA-USE-SPECIFIED-KVNO" },
331 : /* 23 */ { A1_OP_NAME, 20, "KRB5-PADATA-SVR-REFERRAL-INFO" },
332 : /* 24 */ { A1_OP_NAME, 21, "KRB5-PADATA-SAM-REDIRECT" },
333 : /* 25 */ { A1_OP_NAME, 22, "KRB5-PADATA-GET-FROM-TYPED-DATA" },
334 : /* 26 */ { A1_OP_NAME, 23, "KRB5-PADATA-SAM-ETYPE-INFO" },
335 : /* 27 */ { A1_OP_NAME, 25, "KRB5-PADATA-SERVER-REFERRAL" },
336 : /* 28 */ { A1_OP_NAME, 24, "KRB5-PADATA-ALT-PRINC" },
337 : /* 29 */ { A1_OP_NAME, 30, "KRB5-PADATA-SAM-CHALLENGE2" },
338 : /* 30 */ { A1_OP_NAME, 31, "KRB5-PADATA-SAM-RESPONSE2" },
339 : /* 31 */ { A1_OP_NAME, 41, "KRB5-PA-EXTRA-TGT" },
340 : /* 32 */ { A1_OP_NAME, 71, "KRB5-PADATA-FX-FAST-ARMOR" },
341 : /* 33 */ { A1_OP_NAME, 102, "KRB5-PADATA-TD-KRB-PRINCIPAL" },
342 : /* 34 */ { A1_OP_NAME, 104, "KRB5-PADATA-PK-TD-TRUSTED-CERTIFIERS" },
343 : /* 35 */ { A1_OP_NAME, 105, "KRB5-PADATA-PK-TD-CERTIFICATE-INDEX" },
344 : /* 36 */ { A1_OP_NAME, 106, "KRB5-PADATA-TD-APP-DEFINED-ERROR" },
345 : /* 37 */ { A1_OP_NAME, 107, "KRB5-PADATA-TD-REQ-NONCE" },
346 : /* 38 */ { A1_OP_NAME, 108, "KRB5-PADATA-TD-REQ-SEQ" },
347 : /* 39 */ { A1_OP_NAME, 128, "KRB5-PADATA-PA-PAC-REQUEST" },
348 : /* 40 */ { A1_OP_NAME, 129, "KRB5-PADATA-FOR-USER" },
349 : /* 41 */ { A1_OP_NAME, 130, "KRB5-PADATA-FOR-X509-USER" },
350 : /* 42 */ { A1_OP_NAME, 131, "KRB5-PADATA-FOR-CHECK-DUPS" },
351 : /* 43 */ { A1_OP_NAME, 132, "KRB5-PADATA-AS-CHECKSUM" },
352 : /* 44 */ { A1_OP_NAME, 132, "KRB5-PADATA-PK-AS-09-BINDING" },
353 : /* 45 */ { A1_OP_NAME, 133, "KRB5-PADATA-FX-COOKIE" },
354 : /* 46 */ { A1_OP_NAME, 134, "KRB5-PADATA-AUTHENTICATION-SET" },
355 : /* 47 */ { A1_OP_NAME, 135, "KRB5-PADATA-AUTH-SET-SELECTED" },
356 : /* 48 */ { A1_OP_NAME, 136, "KRB5-PADATA-FX-FAST" },
357 : /* 49 */ { A1_OP_NAME, 137, "KRB5-PADATA-FX-ERROR" },
358 : /* 50 */ { A1_OP_NAME, 138, "KRB5-PADATA-ENCRYPTED-CHALLENGE" },
359 : /* 51 */ { A1_OP_NAME, 141, "KRB5-PADATA-OTP-CHALLENGE" },
360 : /* 52 */ { A1_OP_NAME, 142, "KRB5-PADATA-OTP-REQUEST" },
361 : /* 53 */ { A1_OP_NAME, 143, "KBB5-PADATA-OTP-CONFIRM" },
362 : /* 54 */ { A1_OP_NAME, 144, "KRB5-PADATA-OTP-PIN-CHANGE" },
363 : /* 55 */ { A1_OP_NAME, 145, "KRB5-PADATA-EPAK-AS-REQ" },
364 : /* 56 */ { A1_OP_NAME, 146, "KRB5-PADATA-EPAK-AS-REP" },
365 : /* 57 */ { A1_OP_NAME, 147, "KRB5-PADATA-PKINIT-KX" },
366 : /* 58 */ { A1_OP_NAME, 148, "KRB5-PADATA-PKU2U-NAME" },
367 : /* 59 */ { A1_OP_NAME, 149, "KRB5-PADATA-REQ-ENC-PA-REP" },
368 : /* 60 */ { A1_OP_NAME, 161, "KER5-PADATA-KERB-KEY-LIST-REQ" },
369 : /* 61 */ { A1_OP_NAME, 162, "KER5-PADATA-KERB-PAKEY-LIST-REP" },
370 : /* 62 */ { A1_OP_NAME, 165, "KRB5-PADATA-SUPPORTED-ETYPES" },
371 : /* 63 */ { A1_OP_NAME, 167, "KRB5-PADATA-PAC-OPTIONS" },
372 : /* 64 */ { A1_OP_NAME, 655, "KRB5-PADATA-GSS" }
373 : };
374 : /* generate_template_type: PADATA_TYPE_tag__2 */
375 : const struct asn1_template asn1_PADATA_TYPE_tag__2[] = {
376 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
377 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_PADATA_TYPE_enum_names }
378 : };
379 : /* generate_template_type: PADATA_TYPE */
380 : const struct asn1_template asn1_PADATA_TYPE[] = {
381 : /* 0 */ { 0, sizeof(PADATA_TYPE), ((void *)(uintptr_t)1) },
382 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_PADATA_TYPE_tag__2 }
383 : };
384 :
385 : int ASN1CALL
386 0 : decode_PADATA_TYPE(const unsigned char *p, size_t len, PADATA_TYPE *data, size_t *size)
387 : {
388 0 : memset(data, 0, sizeof(*data));
389 0 : return _asn1_decode_top(asn1_PADATA_TYPE, 0|0, p, len, data, size);
390 : }
391 :
392 :
393 : int ASN1CALL
394 0 : encode_PADATA_TYPE(unsigned char *p, size_t len, const PADATA_TYPE *data, size_t *size)
395 : {
396 0 : return _asn1_encode(asn1_PADATA_TYPE, p, len, data, size);
397 : }
398 :
399 :
400 : size_t ASN1CALL
401 0 : length_PADATA_TYPE(const PADATA_TYPE *data)
402 : {
403 0 : return _asn1_length(asn1_PADATA_TYPE, data);
404 : }
405 :
406 :
407 : void ASN1CALL
408 0 : free_PADATA_TYPE(PADATA_TYPE *data)
409 : {
410 0 : _asn1_free_top(asn1_PADATA_TYPE, data);
411 0 : }
412 :
413 :
414 : int ASN1CALL
415 0 : copy_PADATA_TYPE(const PADATA_TYPE *from, PADATA_TYPE *to)
416 : {
417 0 : return _asn1_copy_top(asn1_PADATA_TYPE, from, to);
418 : }
419 :
420 :
421 : char * ASN1CALL
422 0 : print_PADATA_TYPE(const PADATA_TYPE *data, int flags)
423 : {
424 0 : return _asn1_print_top(asn1_PADATA_TYPE, flags, data);
425 : }
426 :
427 : /* template_members: AUTHDATA_TYPE exp exp */
428 : const struct asn1_template asn1_AUTHDATA_TYPE_enum_names[] = {
429 : /* 0 */ { 0, 0, ((void *)(uintptr_t)31) },
430 : /* 1 */ { A1_OP_NAME, 1, "KRB5-AUTHDATA-IF-RELEVANT" },
431 : /* 2 */ { A1_OP_NAME, 2, "KRB5-AUTHDATA-INTENDED-FOR_SERVER" },
432 : /* 3 */ { A1_OP_NAME, 3, "KRB5-AUTHDATA-INTENDED-FOR-APPLICATION-CLASS" },
433 : /* 4 */ { A1_OP_NAME, 4, "KRB5-AUTHDATA-KDC-ISSUED" },
434 : /* 5 */ { A1_OP_NAME, 5, "KRB5-AUTHDATA-AND-OR" },
435 : /* 6 */ { A1_OP_NAME, 6, "KRB5-AUTHDATA-MANDATORY-TICKET-EXTENSIONS" },
436 : /* 7 */ { A1_OP_NAME, 7, "KRB5-AUTHDATA-IN-TICKET-EXTENSIONS" },
437 : /* 8 */ { A1_OP_NAME, 8, "KRB5-AUTHDATA-MANDATORY-FOR-KDC" },
438 : /* 9 */ { A1_OP_NAME, 9, "KRB5-AUTHDATA-INITIAL-VERIFIED-CAS" },
439 : /* 10 */ { A1_OP_NAME, 64, "KRB5-AUTHDATA-OSF-DCE" },
440 : /* 11 */ { A1_OP_NAME, 65, "KRB5-AUTHDATA-SESAME" },
441 : /* 12 */ { A1_OP_NAME, 66, "KRB5-AUTHDATA-OSF-DCE-PKI-CERTID" },
442 : /* 13 */ { A1_OP_NAME, 70, "KRB5-AUTHDATA-AUTHENTICATION-STRENGTH" },
443 : /* 14 */ { A1_OP_NAME, 71, "KRB5-AUTHDATA-FX-FAST-ARMOR" },
444 : /* 15 */ { A1_OP_NAME, 72, "KRB5-AUTHDATA-FX-FAST-USED" },
445 : /* 16 */ { A1_OP_NAME, 128, "KRB5-AUTHDATA-WIN2K-PAC" },
446 : /* 17 */ { A1_OP_NAME, 129, "KRB5-AUTHDATA-GSS-API-ETYPE-NEGOTIATION" },
447 : /* 18 */ { A1_OP_NAME, -17, "KRB5-AUTHDATA-SIGNTICKET-OLDER" },
448 : /* 19 */ { A1_OP_NAME, 142, "KRB5-AUTHDATA-SIGNTICKET-OLD" },
449 : /* 20 */ { A1_OP_NAME, 512, "KRB5-AUTHDATA-SIGNTICKET" },
450 : /* 21 */ { A1_OP_NAME, 513, "KRB5-AUTHDATA-SYNTHETIC-PRINC-USED" },
451 : /* 22 */ { A1_OP_NAME, 141, "KRB5-AUTHDATA-KERB-LOCAL" },
452 : /* 23 */ { A1_OP_NAME, 142, "KRB5-AUTHDATA-TOKEN-RESTRICTIONS" },
453 : /* 24 */ { A1_OP_NAME, 143, "KRB5-AUTHDATA-AP-OPTIONS" },
454 : /* 25 */ { A1_OP_NAME, 144, "KRB5-AUTHDATA-TARGET-PRINCIPAL" },
455 : /* 26 */ { A1_OP_NAME, 580, "KRB5-AUTHDATA-ON-BEHALF-OF" },
456 : /* 27 */ { A1_OP_NAME, 581, "KRB5-AUTHDATA-BEARER-TOKEN-JWT" },
457 : /* 28 */ { A1_OP_NAME, 582, "KRB5-AUTHDATA-BEARER-TOKEN-SAML" },
458 : /* 29 */ { A1_OP_NAME, 583, "KRB5-AUTHDATA-BEARER-TOKEN-OIDC" },
459 : /* 30 */ { A1_OP_NAME, 584, "KRB5-AUTHDATA-CSR-AUTHORIZED" },
460 : /* 31 */ { A1_OP_NAME, 655, "KRB5-AUTHDATA-GSS-COMPOSITE-NAME" }
461 : };
462 : /* generate_template_type: AUTHDATA_TYPE_tag__3 */
463 : const struct asn1_template asn1_AUTHDATA_TYPE_tag__3[] = {
464 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
465 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_AUTHDATA_TYPE_enum_names }
466 : };
467 : /* generate_template_type: AUTHDATA_TYPE */
468 : const struct asn1_template asn1_AUTHDATA_TYPE[] = {
469 : /* 0 */ { 0, sizeof(AUTHDATA_TYPE), ((void *)(uintptr_t)1) },
470 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_AUTHDATA_TYPE_tag__3 }
471 : };
472 :
473 : int ASN1CALL
474 0 : decode_AUTHDATA_TYPE(const unsigned char *p, size_t len, AUTHDATA_TYPE *data, size_t *size)
475 : {
476 0 : memset(data, 0, sizeof(*data));
477 0 : return _asn1_decode_top(asn1_AUTHDATA_TYPE, 0|0, p, len, data, size);
478 : }
479 :
480 :
481 : int ASN1CALL
482 0 : encode_AUTHDATA_TYPE(unsigned char *p, size_t len, const AUTHDATA_TYPE *data, size_t *size)
483 : {
484 0 : return _asn1_encode(asn1_AUTHDATA_TYPE, p, len, data, size);
485 : }
486 :
487 :
488 : size_t ASN1CALL
489 0 : length_AUTHDATA_TYPE(const AUTHDATA_TYPE *data)
490 : {
491 0 : return _asn1_length(asn1_AUTHDATA_TYPE, data);
492 : }
493 :
494 :
495 : void ASN1CALL
496 0 : free_AUTHDATA_TYPE(AUTHDATA_TYPE *data)
497 : {
498 0 : _asn1_free_top(asn1_AUTHDATA_TYPE, data);
499 0 : }
500 :
501 :
502 : int ASN1CALL
503 0 : copy_AUTHDATA_TYPE(const AUTHDATA_TYPE *from, AUTHDATA_TYPE *to)
504 : {
505 0 : return _asn1_copy_top(asn1_AUTHDATA_TYPE, from, to);
506 : }
507 :
508 :
509 : char * ASN1CALL
510 0 : print_AUTHDATA_TYPE(const AUTHDATA_TYPE *data, int flags)
511 : {
512 0 : return _asn1_print_top(asn1_AUTHDATA_TYPE, flags, data);
513 : }
514 :
515 : /* template_members: CKSUMTYPE exp exp */
516 : const struct asn1_template asn1_CKSUMTYPE_enum_names[] = {
517 : /* 0 */ { 0, 0, ((void *)(uintptr_t)23) },
518 : /* 1 */ { A1_OP_NAME, 0, "CKSUMTYPE_NONE" },
519 : /* 2 */ { A1_OP_NAME, 1, "CKSUMTYPE_CRC32" },
520 : /* 3 */ { A1_OP_NAME, 2, "CKSUMTYPE_RSA_MD4" },
521 : /* 4 */ { A1_OP_NAME, 3, "CKSUMTYPE_RSA_MD4_DES" },
522 : /* 5 */ { A1_OP_NAME, 4, "CKSUMTYPE_DES_MAC" },
523 : /* 6 */ { A1_OP_NAME, 5, "CKSUMTYPE_DES_MAC_K" },
524 : /* 7 */ { A1_OP_NAME, 6, "CKSUMTYPE_RSA_MD4_DES_K" },
525 : /* 8 */ { A1_OP_NAME, 7, "CKSUMTYPE_RSA_MD5" },
526 : /* 9 */ { A1_OP_NAME, 8, "CKSUMTYPE_RSA_MD5_DES" },
527 : /* 10 */ { A1_OP_NAME, 9, "CKSUMTYPE_RSA_MD5_DES3" },
528 : /* 11 */ { A1_OP_NAME, 10, "CKSUMTYPE_SHA1_OTHER" },
529 : /* 12 */ { A1_OP_NAME, 12, "CKSUMTYPE_HMAC_SHA1_DES3" },
530 : /* 13 */ { A1_OP_NAME, 14, "CKSUMTYPE_SHA1" },
531 : /* 14 */ { A1_OP_NAME, 15, "CKSUMTYPE_HMAC_SHA1_96_AES_128" },
532 : /* 15 */ { A1_OP_NAME, 16, "CKSUMTYPE_HMAC_SHA1_96_AES_256" },
533 : /* 16 */ { A1_OP_NAME, 19, "CKSUMTYPE_HMAC_SHA256_128_AES128" },
534 : /* 17 */ { A1_OP_NAME, 20, "CKSUMTYPE_HMAC_SHA384_192_AES256" },
535 : /* 18 */ { A1_OP_NAME, 32771, "CKSUMTYPE_GSSAPI" },
536 : /* 19 */ { A1_OP_NAME, -138, "CKSUMTYPE_HMAC_MD5" },
537 : /* 20 */ { A1_OP_NAME, -1138, "CKSUMTYPE_HMAC_MD5_ENC" },
538 : /* 21 */ { A1_OP_NAME, -21, "CKSUMTYPE_SHA256" },
539 : /* 22 */ { A1_OP_NAME, -22, "CKSUMTYPE_SHA384" },
540 : /* 23 */ { A1_OP_NAME, -23, "CKSUMTYPE_SHA512" }
541 : };
542 : /* generate_template_type: CKSUMTYPE_tag__4 */
543 : const struct asn1_template asn1_CKSUMTYPE_tag__4[] = {
544 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
545 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_CKSUMTYPE_enum_names }
546 : };
547 : /* generate_template_type: CKSUMTYPE */
548 : const struct asn1_template asn1_CKSUMTYPE[] = {
549 : /* 0 */ { 0, sizeof(CKSUMTYPE), ((void *)(uintptr_t)1) },
550 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_CKSUMTYPE_tag__4 }
551 : };
552 :
553 : int ASN1CALL
554 0 : decode_CKSUMTYPE(const unsigned char *p, size_t len, CKSUMTYPE *data, size_t *size)
555 : {
556 0 : memset(data, 0, sizeof(*data));
557 0 : return _asn1_decode_top(asn1_CKSUMTYPE, 0|0, p, len, data, size);
558 : }
559 :
560 :
561 : int ASN1CALL
562 0 : encode_CKSUMTYPE(unsigned char *p, size_t len, const CKSUMTYPE *data, size_t *size)
563 : {
564 0 : return _asn1_encode(asn1_CKSUMTYPE, p, len, data, size);
565 : }
566 :
567 :
568 : size_t ASN1CALL
569 0 : length_CKSUMTYPE(const CKSUMTYPE *data)
570 : {
571 0 : return _asn1_length(asn1_CKSUMTYPE, data);
572 : }
573 :
574 :
575 : void ASN1CALL
576 0 : free_CKSUMTYPE(CKSUMTYPE *data)
577 : {
578 0 : _asn1_free_top(asn1_CKSUMTYPE, data);
579 0 : }
580 :
581 :
582 : int ASN1CALL
583 0 : copy_CKSUMTYPE(const CKSUMTYPE *from, CKSUMTYPE *to)
584 : {
585 0 : return _asn1_copy_top(asn1_CKSUMTYPE, from, to);
586 : }
587 :
588 :
589 : char * ASN1CALL
590 0 : print_CKSUMTYPE(const CKSUMTYPE *data, int flags)
591 : {
592 0 : return _asn1_print_top(asn1_CKSUMTYPE, flags, data);
593 : }
594 :
595 : /* template_members: ENCTYPE exp exp */
596 : const struct asn1_template asn1_ENCTYPE_enum_names[] = {
597 : /* 0 */ { 0, 0, ((void *)(uintptr_t)26) },
598 : /* 1 */ { A1_OP_NAME, 0, "KRB5_ENCTYPE_NULL" },
599 : /* 2 */ { A1_OP_NAME, 1, "KRB5_ENCTYPE_DES_CBC_CRC" },
600 : /* 3 */ { A1_OP_NAME, 2, "KRB5_ENCTYPE_DES_CBC_MD4" },
601 : /* 4 */ { A1_OP_NAME, 3, "KRB5_ENCTYPE_DES_CBC_MD5" },
602 : /* 5 */ { A1_OP_NAME, 5, "KRB5_ENCTYPE_DES3_CBC_MD5" },
603 : /* 6 */ { A1_OP_NAME, 7, "KRB5_ENCTYPE_OLD_DES3_CBC_SHA1" },
604 : /* 7 */ { A1_OP_NAME, 8, "KRB5_ENCTYPE_SIGN_DSA_GENERATE" },
605 : /* 8 */ { A1_OP_NAME, 9, "KRB5_ENCTYPE_ENCRYPT_RSA_PRIV" },
606 : /* 9 */ { A1_OP_NAME, 10, "KRB5_ENCTYPE_ENCRYPT_RSA_PUB" },
607 : /* 10 */ { A1_OP_NAME, 16, "KRB5_ENCTYPE_DES3_CBC_SHA1" },
608 : /* 11 */ { A1_OP_NAME, 17, "KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96" },
609 : /* 12 */ { A1_OP_NAME, 18, "KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96" },
610 : /* 13 */ { A1_OP_NAME, 19, "KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128" },
611 : /* 14 */ { A1_OP_NAME, 20, "KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192" },
612 : /* 15 */ { A1_OP_NAME, 23, "KRB5_ENCTYPE_ARCFOUR_HMAC_MD5" },
613 : /* 16 */ { A1_OP_NAME, 24, "KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56" },
614 : /* 17 */ { A1_OP_NAME, 48, "KRB5_ENCTYPE_ENCTYPE_PK_CROSS" },
615 : /* 18 */ { A1_OP_NAME, -128, "KRB5_ENCTYPE_ARCFOUR_MD4" },
616 : /* 19 */ { A1_OP_NAME, -133, "KRB5_ENCTYPE_ARCFOUR_HMAC_OLD" },
617 : /* 20 */ { A1_OP_NAME, -135, "KRB5_ENCTYPE_ARCFOUR_HMAC_OLD_EXP" },
618 : /* 21 */ { A1_OP_NAME, -4096, "KRB5_ENCTYPE_DES_CBC_NONE" },
619 : /* 22 */ { A1_OP_NAME, -4097, "KRB5_ENCTYPE_DES3_CBC_NONE" },
620 : /* 23 */ { A1_OP_NAME, -4098, "KRB5_ENCTYPE_DES_CFB64_NONE" },
621 : /* 24 */ { A1_OP_NAME, -4099, "KRB5_ENCTYPE_DES_PCBC_NONE" },
622 : /* 25 */ { A1_OP_NAME, -4100, "KRB5_ENCTYPE_DIGEST_MD5_NONE" },
623 : /* 26 */ { A1_OP_NAME, -4101, "KRB5_ENCTYPE_CRAM_MD5_NONE" }
624 : };
625 : /* generate_template_type: ENCTYPE_tag__5 */
626 : const struct asn1_template asn1_ENCTYPE_tag__5[] = {
627 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
628 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_ENCTYPE_enum_names }
629 : };
630 : /* generate_template_type: ENCTYPE */
631 : const struct asn1_template asn1_ENCTYPE[] = {
632 : /* 0 */ { 0, sizeof(ENCTYPE), ((void *)(uintptr_t)1) },
633 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_ENCTYPE_tag__5 }
634 : };
635 :
636 : int ASN1CALL
637 0 : decode_ENCTYPE(const unsigned char *p, size_t len, ENCTYPE *data, size_t *size)
638 : {
639 0 : memset(data, 0, sizeof(*data));
640 0 : return _asn1_decode_top(asn1_ENCTYPE, 0|0, p, len, data, size);
641 : }
642 :
643 :
644 : int ASN1CALL
645 0 : encode_ENCTYPE(unsigned char *p, size_t len, const ENCTYPE *data, size_t *size)
646 : {
647 0 : return _asn1_encode(asn1_ENCTYPE, p, len, data, size);
648 : }
649 :
650 :
651 : size_t ASN1CALL
652 0 : length_ENCTYPE(const ENCTYPE *data)
653 : {
654 0 : return _asn1_length(asn1_ENCTYPE, data);
655 : }
656 :
657 :
658 : void ASN1CALL
659 0 : free_ENCTYPE(ENCTYPE *data)
660 : {
661 0 : _asn1_free_top(asn1_ENCTYPE, data);
662 0 : }
663 :
664 :
665 : int ASN1CALL
666 0 : copy_ENCTYPE(const ENCTYPE *from, ENCTYPE *to)
667 : {
668 0 : return _asn1_copy_top(asn1_ENCTYPE, from, to);
669 : }
670 :
671 :
672 : char * ASN1CALL
673 0 : print_ENCTYPE(const ENCTYPE *data, int flags)
674 : {
675 0 : return _asn1_print_top(asn1_ENCTYPE, flags, data);
676 : }
677 :
678 : /* template_members: Krb5UInt32 exp exp */
679 : /* generate_template_type: Krb5UInt32_tag__6 */
680 : const struct asn1_template asn1_Krb5UInt32_tag__6[] = {
681 : /* 0 */ { 0, sizeof(unsigned), ((void *)(uintptr_t)1) },
682 : /* 1 */ { A1_PARSE_T(A1T_UNSIGNED), 0, NULL }
683 : };
684 : /* generate_template_type: Krb5UInt32 */
685 : const struct asn1_template asn1_Krb5UInt32[] = {
686 : /* 0 */ { 0, sizeof(Krb5UInt32), ((void *)(uintptr_t)1) },
687 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_Krb5UInt32_tag__6 }
688 : };
689 :
690 : int ASN1CALL
691 0 : decode_Krb5UInt32(const unsigned char *p, size_t len, Krb5UInt32 *data, size_t *size)
692 : {
693 0 : memset(data, 0, sizeof(*data));
694 0 : return _asn1_decode_top(asn1_Krb5UInt32, 0|0, p, len, data, size);
695 : }
696 :
697 :
698 : int ASN1CALL
699 0 : encode_Krb5UInt32(unsigned char *p, size_t len, const Krb5UInt32 *data, size_t *size)
700 : {
701 0 : return _asn1_encode(asn1_Krb5UInt32, p, len, data, size);
702 : }
703 :
704 :
705 : size_t ASN1CALL
706 0 : length_Krb5UInt32(const Krb5UInt32 *data)
707 : {
708 0 : return _asn1_length(asn1_Krb5UInt32, data);
709 : }
710 :
711 :
712 : void ASN1CALL
713 0 : free_Krb5UInt32(Krb5UInt32 *data)
714 : {
715 0 : _asn1_free_top(asn1_Krb5UInt32, data);
716 0 : }
717 :
718 :
719 : int ASN1CALL
720 0 : copy_Krb5UInt32(const Krb5UInt32 *from, Krb5UInt32 *to)
721 : {
722 0 : return _asn1_copy_top(asn1_Krb5UInt32, from, to);
723 : }
724 :
725 :
726 : char * ASN1CALL
727 0 : print_Krb5UInt32(const Krb5UInt32 *data, int flags)
728 : {
729 0 : return _asn1_print_top(asn1_Krb5UInt32, flags, data);
730 : }
731 :
732 : /* template_members: Krb5Int32 exp exp */
733 : /* generate_template_type: Krb5Int32_tag__7 */
734 : const struct asn1_template asn1_Krb5Int32_tag__7[] = {
735 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
736 : /* 1 */ { A1_PARSE_T(A1T_INTEGER), 0, NULL }
737 : };
738 : /* generate_template_type: Krb5Int32 */
739 : const struct asn1_template asn1_Krb5Int32[] = {
740 : /* 0 */ { 0, sizeof(Krb5Int32), ((void *)(uintptr_t)1) },
741 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_Krb5Int32_tag__7 }
742 : };
743 :
744 : int ASN1CALL
745 0 : decode_Krb5Int32(const unsigned char *p, size_t len, Krb5Int32 *data, size_t *size)
746 : {
747 0 : memset(data, 0, sizeof(*data));
748 0 : return _asn1_decode_top(asn1_Krb5Int32, 0|0, p, len, data, size);
749 : }
750 :
751 :
752 : int ASN1CALL
753 0 : encode_Krb5Int32(unsigned char *p, size_t len, const Krb5Int32 *data, size_t *size)
754 : {
755 0 : return _asn1_encode(asn1_Krb5Int32, p, len, data, size);
756 : }
757 :
758 :
759 : size_t ASN1CALL
760 0 : length_Krb5Int32(const Krb5Int32 *data)
761 : {
762 0 : return _asn1_length(asn1_Krb5Int32, data);
763 : }
764 :
765 :
766 : void ASN1CALL
767 0 : free_Krb5Int32(Krb5Int32 *data)
768 : {
769 0 : _asn1_free_top(asn1_Krb5Int32, data);
770 0 : }
771 :
772 :
773 : int ASN1CALL
774 0 : copy_Krb5Int32(const Krb5Int32 *from, Krb5Int32 *to)
775 : {
776 0 : return _asn1_copy_top(asn1_Krb5Int32, from, to);
777 : }
778 :
779 :
780 : char * ASN1CALL
781 0 : print_Krb5Int32(const Krb5Int32 *data, int flags)
782 : {
783 0 : return _asn1_print_top(asn1_Krb5Int32, flags, data);
784 : }
785 :
786 : /* template_members: KerberosString exp exp */
787 : /* generate_template_type: KerberosString_tag__8 */
788 : const struct asn1_template asn1_KerberosString_tag__8[] = {
789 : /* 0 */ { 0, sizeof(heim_general_string), ((void *)(uintptr_t)1) },
790 : /* 1 */ { A1_PARSE_T(A1T_GENERAL_STRING), 0, NULL }
791 : };
792 : /* generate_template_type: KerberosString */
793 : const struct asn1_template asn1_KerberosString[] = {
794 : /* 0 */ { 0, sizeof(KerberosString), ((void *)(uintptr_t)1) },
795 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_GeneralString), 0, asn1_KerberosString_tag__8 }
796 : };
797 :
798 : int ASN1CALL
799 0 : decode_KerberosString(const unsigned char *p, size_t len, KerberosString *data, size_t *size)
800 : {
801 0 : memset(data, 0, sizeof(*data));
802 0 : return _asn1_decode_top(asn1_KerberosString, 0|0, p, len, data, size);
803 : }
804 :
805 :
806 : int ASN1CALL
807 0 : encode_KerberosString(unsigned char *p, size_t len, const KerberosString *data, size_t *size)
808 : {
809 0 : return _asn1_encode(asn1_KerberosString, p, len, data, size);
810 : }
811 :
812 :
813 : size_t ASN1CALL
814 0 : length_KerberosString(const KerberosString *data)
815 : {
816 0 : return _asn1_length(asn1_KerberosString, data);
817 : }
818 :
819 :
820 : void ASN1CALL
821 0 : free_KerberosString(KerberosString *data)
822 : {
823 0 : _asn1_free_top(asn1_KerberosString, data);
824 0 : }
825 :
826 :
827 : int ASN1CALL
828 0 : copy_KerberosString(const KerberosString *from, KerberosString *to)
829 : {
830 0 : return _asn1_copy_top(asn1_KerberosString, from, to);
831 : }
832 :
833 :
834 : char * ASN1CALL
835 0 : print_KerberosString(const KerberosString *data, int flags)
836 : {
837 0 : return _asn1_print_top(asn1_KerberosString, flags, data);
838 : }
839 :
840 : /* template_members: Realm exp exp */
841 : /* generate_template_type: Realm_tag__9 */
842 : /* generate_template_type: Realm */
843 : const struct asn1_template asn1_Realm[] = {
844 : /* 0 */ { 0, sizeof(Realm), ((void *)(uintptr_t)1) },
845 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_GeneralString), 0, asn1_KerberosString_tag__8 }
846 : };
847 :
848 : int ASN1CALL
849 0 : decode_Realm(const unsigned char *p, size_t len, Realm *data, size_t *size)
850 : {
851 0 : memset(data, 0, sizeof(*data));
852 0 : return _asn1_decode_top(asn1_Realm, 0|0, p, len, data, size);
853 : }
854 :
855 :
856 : int ASN1CALL
857 0 : encode_Realm(unsigned char *p, size_t len, const Realm *data, size_t *size)
858 : {
859 0 : return _asn1_encode(asn1_Realm, p, len, data, size);
860 : }
861 :
862 :
863 : size_t ASN1CALL
864 0 : length_Realm(const Realm *data)
865 : {
866 0 : return _asn1_length(asn1_Realm, data);
867 : }
868 :
869 :
870 : void ASN1CALL
871 61772 : free_Realm(Realm *data)
872 : {
873 61772 : _asn1_free_top(asn1_Realm, data);
874 61772 : }
875 :
876 :
877 : int ASN1CALL
878 448271 : copy_Realm(const Realm *from, Realm *to)
879 : {
880 448271 : return _asn1_copy_top(asn1_Realm, from, to);
881 : }
882 :
883 :
884 : char * ASN1CALL
885 0 : print_Realm(const Realm *data, int flags)
886 : {
887 0 : return _asn1_print_top(asn1_Realm, flags, data);
888 : }
889 :
890 : /* template_members: PrincipalName exp exp */
891 : /* tsequence: members isstruct: 1 */
892 : /* template_members: PrincipalName exp exp */
893 : /* generate_template_type: PrincipalName_tag_name_type_11 */
894 : const struct asn1_template asn1_PrincipalName_tag_name_type_11[] = {
895 : /* 0 */ { 0, sizeof(NAME_TYPE), ((void *)(uintptr_t)1) },
896 : /* 1 */ { A1_OP_TYPE , 0, asn1_NAME_TYPE }
897 : };
898 : /* template_members: PrincipalName exp exp */
899 : /* template_members: PrincipalName exp exp */
900 : /* template_members: heim_general_string exp exp */
901 : /* generate_template_type: heim_general_string_tag__14 */
902 : /* generate_template_type: PrincipalName_name_string_0 */
903 : const struct asn1_template asn1_PrincipalName_name_string_0[] = {
904 : /* 0 */ { 0, sizeof(heim_general_string), ((void *)(uintptr_t)1) },
905 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_GeneralString), 0, asn1_KerberosString_tag__8 }
906 : };
907 : /* generate_template_type: PrincipalName_tag_name_string_13 */
908 : const struct asn1_template asn1_PrincipalName_tag_name_string_13[] = {
909 : /* 0 */ { 0, sizeof(struct PrincipalName_name_string), ((void *)(uintptr_t)1) },
910 : /* 1 */ { A1_OP_SEQOF, 0, asn1_PrincipalName_name_string_0 }
911 : };
912 : /* generate_template_type: PrincipalName_tag_name_string_12 */
913 : const struct asn1_template asn1_PrincipalName_tag_name_string_12[] = {
914 : /* 0 */ { 0, sizeof(struct PrincipalName_name_string), ((void *)(uintptr_t)1) },
915 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PrincipalName_tag_name_string_13 }
916 : };
917 : /* generate_template_type: PrincipalName_tag__10 */
918 : const struct asn1_template asn1_PrincipalName_tag__10[] = {
919 : /* 0 */ { 0, sizeof(struct PrincipalName), ((void *)(uintptr_t)5) },
920 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PrincipalName, name_type), asn1_PrincipalName_tag_name_type_11 },
921 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct PrincipalName, name_string), asn1_PrincipalName_tag_name_string_12 },
922 : /* 3 */ { A1_OP_NAME, 0, "PrincipalName" },
923 : /* 4 */ { A1_OP_NAME, 0, "name-type" },
924 : /* 5 */ { A1_OP_NAME, 0, "name-string" }
925 : };
926 : /* generate_template_type: PrincipalName */
927 : const struct asn1_template asn1_PrincipalName[] = {
928 : /* 0 */ { 0, sizeof(PrincipalName), ((void *)(uintptr_t)1) },
929 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PrincipalName_tag__10 }
930 : };
931 :
932 : int ASN1CALL
933 0 : decode_PrincipalName(const unsigned char *p, size_t len, PrincipalName *data, size_t *size)
934 : {
935 0 : memset(data, 0, sizeof(*data));
936 0 : return _asn1_decode_top(asn1_PrincipalName, 0|0, p, len, data, size);
937 : }
938 :
939 :
940 : int ASN1CALL
941 0 : encode_PrincipalName(unsigned char *p, size_t len, const PrincipalName *data, size_t *size)
942 : {
943 0 : return _asn1_encode(asn1_PrincipalName, p, len, data, size);
944 : }
945 :
946 :
947 : size_t ASN1CALL
948 0 : length_PrincipalName(const PrincipalName *data)
949 : {
950 0 : return _asn1_length(asn1_PrincipalName, data);
951 : }
952 :
953 :
954 : void ASN1CALL
955 62028 : free_PrincipalName(PrincipalName *data)
956 : {
957 62028 : _asn1_free_top(asn1_PrincipalName, data);
958 62028 : }
959 :
960 :
961 : int ASN1CALL
962 893581 : copy_PrincipalName(const PrincipalName *from, PrincipalName *to)
963 : {
964 893581 : return _asn1_copy_top(asn1_PrincipalName, from, to);
965 : }
966 :
967 :
968 : char * ASN1CALL
969 0 : print_PrincipalName(const PrincipalName *data, int flags)
970 : {
971 0 : return _asn1_print_top(asn1_PrincipalName, flags, data);
972 : }
973 :
974 : /* template_members: HostAddress exp exp */
975 : /* tsequence: members isstruct: 1 */
976 : /* template_members: HostAddress exp exp */
977 : /* generate_template_type: HostAddress_tag_addr_type_16 */
978 : const struct asn1_template asn1_HostAddress_tag_addr_type_16[] = {
979 : /* 0 */ { 0, sizeof(Krb5Int32), ((void *)(uintptr_t)1) },
980 : /* 1 */ { A1_OP_TYPE , 0, asn1_Krb5Int32 }
981 : };
982 : /* template_members: HostAddress exp exp */
983 : /* template_members: heim_octet_string exp exp */
984 : /* generate_template_type: heim_octet_string_tag_address_18 */
985 : const struct asn1_template asn1_heim_octet_string_tag_address_18[] = {
986 : /* 0 */ { 0, sizeof(heim_octet_string), ((void *)(uintptr_t)1) },
987 : /* 1 */ { A1_PARSE_T(A1T_OCTET_STRING), 0, NULL }
988 : };
989 : /* generate_template_type: HostAddress_tag_address_17 */
990 : const struct asn1_template asn1_HostAddress_tag_address_17[] = {
991 : /* 0 */ { 0, sizeof(heim_octet_string), ((void *)(uintptr_t)1) },
992 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString), 0, asn1_heim_octet_string_tag_address_18 }
993 : };
994 : /* generate_template_type: HostAddress_tag__15 */
995 : const struct asn1_template asn1_HostAddress_tag__15[] = {
996 : /* 0 */ { 0, sizeof(struct HostAddress), ((void *)(uintptr_t)5) },
997 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct HostAddress, addr_type), asn1_HostAddress_tag_addr_type_16 },
998 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct HostAddress, address), asn1_HostAddress_tag_address_17 },
999 : /* 3 */ { A1_OP_NAME, 0, "HostAddress" },
1000 : /* 4 */ { A1_OP_NAME, 0, "addr-type" },
1001 : /* 5 */ { A1_OP_NAME, 0, "address" }
1002 : };
1003 : /* generate_template_type: HostAddress */
1004 : const struct asn1_template asn1_HostAddress[] = {
1005 : /* 0 */ { 0, sizeof(HostAddress), ((void *)(uintptr_t)1) },
1006 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_HostAddress_tag__15 }
1007 : };
1008 :
1009 : int ASN1CALL
1010 0 : decode_HostAddress(const unsigned char *p, size_t len, HostAddress *data, size_t *size)
1011 : {
1012 0 : memset(data, 0, sizeof(*data));
1013 0 : return _asn1_decode_top(asn1_HostAddress, 0|0, p, len, data, size);
1014 : }
1015 :
1016 :
1017 : int ASN1CALL
1018 0 : encode_HostAddress(unsigned char *p, size_t len, const HostAddress *data, size_t *size)
1019 : {
1020 0 : return _asn1_encode(asn1_HostAddress, p, len, data, size);
1021 : }
1022 :
1023 :
1024 : size_t ASN1CALL
1025 0 : length_HostAddress(const HostAddress *data)
1026 : {
1027 0 : return _asn1_length(asn1_HostAddress, data);
1028 : }
1029 :
1030 :
1031 : void ASN1CALL
1032 63 : free_HostAddress(HostAddress *data)
1033 : {
1034 63 : _asn1_free_top(asn1_HostAddress, data);
1035 63 : }
1036 :
1037 :
1038 : int ASN1CALL
1039 66 : copy_HostAddress(const HostAddress *from, HostAddress *to)
1040 : {
1041 66 : return _asn1_copy_top(asn1_HostAddress, from, to);
1042 : }
1043 :
1044 :
1045 : char * ASN1CALL
1046 0 : print_HostAddress(const HostAddress *data, int flags)
1047 : {
1048 0 : return _asn1_print_top(asn1_HostAddress, flags, data);
1049 : }
1050 :
1051 : /* template_members: HostAddresses exp exp */
1052 : /* generate_template_type: HostAddress_seofTstruct_1 */
1053 : const struct asn1_template asn1_HostAddress_seofTstruct_1[] = {
1054 : /* 0 */ { 0, sizeof(HostAddress), ((void *)(uintptr_t)1) },
1055 : /* 1 */ { A1_OP_TYPE , 0, asn1_HostAddress }
1056 : };
1057 : /* generate_template_type: HostAddresses_tag__19 */
1058 : const struct asn1_template asn1_HostAddresses_tag__19[] = {
1059 : /* 0 */ { 0, sizeof(HostAddress), ((void *)(uintptr_t)1) },
1060 : /* 1 */ { A1_OP_SEQOF, 0, asn1_HostAddress_seofTstruct_1 }
1061 : };
1062 : /* generate_template_type: HostAddresses */
1063 : const struct asn1_template asn1_HostAddresses[] = {
1064 : /* 0 */ { 0, sizeof(HostAddresses), ((void *)(uintptr_t)1) },
1065 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_HostAddresses_tag__19 }
1066 : };
1067 :
1068 : int ASN1CALL
1069 0 : decode_HostAddresses(const unsigned char *p, size_t len, HostAddresses *data, size_t *size)
1070 : {
1071 0 : memset(data, 0, sizeof(*data));
1072 0 : return _asn1_decode_top(asn1_HostAddresses, 0|0, p, len, data, size);
1073 : }
1074 :
1075 :
1076 : int ASN1CALL
1077 0 : encode_HostAddresses(unsigned char *p, size_t len, const HostAddresses *data, size_t *size)
1078 : {
1079 0 : return _asn1_encode(asn1_HostAddresses, p, len, data, size);
1080 : }
1081 :
1082 :
1083 : size_t ASN1CALL
1084 0 : length_HostAddresses(const HostAddresses *data)
1085 : {
1086 0 : return _asn1_length(asn1_HostAddresses, data);
1087 : }
1088 :
1089 :
1090 : void ASN1CALL
1091 1448227 : free_HostAddresses(HostAddresses *data)
1092 : {
1093 1448227 : _asn1_free_top(asn1_HostAddresses, data);
1094 1448227 : }
1095 :
1096 :
1097 : int ASN1CALL
1098 17276 : copy_HostAddresses(const HostAddresses *from, HostAddresses *to)
1099 : {
1100 17276 : return _asn1_copy_top(asn1_HostAddresses, from, to);
1101 : }
1102 :
1103 :
1104 : char * ASN1CALL
1105 0 : print_HostAddresses(const HostAddresses *data, int flags)
1106 : {
1107 0 : return _asn1_print_top(asn1_HostAddresses, flags, data);
1108 : }
1109 :
1110 : /* template_members: KerberosTime exp exp */
1111 : /* generate_template_type: KerberosTime_tag__20 */
1112 : const struct asn1_template asn1_KerberosTime_tag__20[] = {
1113 : /* 0 */ { 0, sizeof(time_t), ((void *)(uintptr_t)1) },
1114 : /* 1 */ { A1_PARSE_T(A1T_GENERALIZED_TIME), 0, NULL }
1115 : };
1116 : /* generate_template_type: KerberosTime */
1117 : const struct asn1_template asn1_KerberosTime[] = {
1118 : /* 0 */ { 0, sizeof(KerberosTime), ((void *)(uintptr_t)1) },
1119 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_GeneralizedTime), 0, asn1_KerberosTime_tag__20 }
1120 : };
1121 :
1122 : int ASN1CALL
1123 0 : decode_KerberosTime(const unsigned char *p, size_t len, KerberosTime *data, size_t *size)
1124 : {
1125 0 : memset(data, 0, sizeof(*data));
1126 0 : return _asn1_decode_top(asn1_KerberosTime, 0|0, p, len, data, size);
1127 : }
1128 :
1129 :
1130 : int ASN1CALL
1131 77 : encode_KerberosTime(unsigned char *p, size_t len, const KerberosTime *data, size_t *size)
1132 : {
1133 77 : return _asn1_encode(asn1_KerberosTime, p, len, data, size);
1134 : }
1135 :
1136 :
1137 : size_t ASN1CALL
1138 77 : length_KerberosTime(const KerberosTime *data)
1139 : {
1140 77 : return _asn1_length(asn1_KerberosTime, data);
1141 : }
1142 :
1143 :
1144 : void ASN1CALL
1145 269095 : free_KerberosTime(KerberosTime *data)
1146 : {
1147 269095 : _asn1_free_top(asn1_KerberosTime, data);
1148 269095 : }
1149 :
1150 :
1151 : int ASN1CALL
1152 0 : copy_KerberosTime(const KerberosTime *from, KerberosTime *to)
1153 : {
1154 0 : return _asn1_copy_top(asn1_KerberosTime, from, to);
1155 : }
1156 :
1157 :
1158 : char * ASN1CALL
1159 0 : print_KerberosTime(const KerberosTime *data, int flags)
1160 : {
1161 0 : return _asn1_print_top(asn1_KerberosTime, flags, data);
1162 : }
1163 :
1164 : /* template_members: AuthorizationDataElement exp exp */
1165 : /* tsequence: members isstruct: 1 */
1166 : /* template_members: AuthorizationDataElement exp exp */
1167 : /* generate_template_type: AuthorizationDataElement_tag_ad_type_22 */
1168 : /* template_members: AuthorizationDataElement exp exp */
1169 : /* template_members: heim_octet_string exp exp */
1170 : /* generate_template_type: heim_octet_string_tag_ad_data_24 */
1171 : /* generate_template_type: AuthorizationDataElement_tag_ad_data_23 */
1172 : /* generate_template_type: AuthorizationDataElement_tag__21 */
1173 : const struct asn1_template asn1_AuthorizationDataElement_tag__21[] = {
1174 : /* 0 */ { 0, sizeof(struct AuthorizationDataElement), ((void *)(uintptr_t)5) },
1175 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct AuthorizationDataElement, ad_type), asn1_HostAddress_tag_addr_type_16 },
1176 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct AuthorizationDataElement, ad_data), asn1_HostAddress_tag_address_17 },
1177 : /* 3 */ { A1_OP_NAME, 0, "AuthorizationDataElement" },
1178 : /* 4 */ { A1_OP_NAME, 0, "ad-type" },
1179 : /* 5 */ { A1_OP_NAME, 0, "ad-data" }
1180 : };
1181 : /* generate_template_type: AuthorizationDataElement */
1182 : const struct asn1_template asn1_AuthorizationDataElement[] = {
1183 : /* 0 */ { 0, sizeof(AuthorizationDataElement), ((void *)(uintptr_t)1) },
1184 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_AuthorizationDataElement_tag__21 }
1185 : };
1186 :
1187 : int ASN1CALL
1188 0 : decode_AuthorizationDataElement(const unsigned char *p, size_t len, AuthorizationDataElement *data, size_t *size)
1189 : {
1190 0 : memset(data, 0, sizeof(*data));
1191 0 : return _asn1_decode_top(asn1_AuthorizationDataElement, 0|0, p, len, data, size);
1192 : }
1193 :
1194 :
1195 : int ASN1CALL
1196 0 : encode_AuthorizationDataElement(unsigned char *p, size_t len, const AuthorizationDataElement *data, size_t *size)
1197 : {
1198 0 : return _asn1_encode(asn1_AuthorizationDataElement, p, len, data, size);
1199 : }
1200 :
1201 :
1202 : size_t ASN1CALL
1203 0 : length_AuthorizationDataElement(const AuthorizationDataElement *data)
1204 : {
1205 0 : return _asn1_length(asn1_AuthorizationDataElement, data);
1206 : }
1207 :
1208 :
1209 : void ASN1CALL
1210 14682 : free_AuthorizationDataElement(AuthorizationDataElement *data)
1211 : {
1212 14682 : _asn1_free_top(asn1_AuthorizationDataElement, data);
1213 14682 : }
1214 :
1215 :
1216 : int ASN1CALL
1217 245910 : copy_AuthorizationDataElement(const AuthorizationDataElement *from, AuthorizationDataElement *to)
1218 : {
1219 245910 : return _asn1_copy_top(asn1_AuthorizationDataElement, from, to);
1220 : }
1221 :
1222 :
1223 : char * ASN1CALL
1224 0 : print_AuthorizationDataElement(const AuthorizationDataElement *data, int flags)
1225 : {
1226 0 : return _asn1_print_top(asn1_AuthorizationDataElement, flags, data);
1227 : }
1228 :
1229 : /* template_members: AuthorizationData exp exp */
1230 : /* generate_template_type: AuthorizationDataElement_seofTstruct_2 */
1231 : const struct asn1_template asn1_AuthorizationDataElement_seofTstruct_2[] = {
1232 : /* 0 */ { 0, sizeof(AuthorizationDataElement), ((void *)(uintptr_t)1) },
1233 : /* 1 */ { A1_OP_TYPE , 0, asn1_AuthorizationDataElement }
1234 : };
1235 : /* generate_template_type: AuthorizationData_tag__25 */
1236 : const struct asn1_template asn1_AuthorizationData_tag__25[] = {
1237 : /* 0 */ { 0, sizeof(AuthorizationDataElement), ((void *)(uintptr_t)1) },
1238 : /* 1 */ { A1_OP_SEQOF, 0, asn1_AuthorizationDataElement_seofTstruct_2 }
1239 : };
1240 : /* generate_template_type: AuthorizationData */
1241 : const struct asn1_template asn1_AuthorizationData[] = {
1242 : /* 0 */ { 0, sizeof(AuthorizationData), ((void *)(uintptr_t)1) },
1243 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_AuthorizationData_tag__25 }
1244 : };
1245 :
1246 : int ASN1CALL
1247 269339 : decode_AuthorizationData(const unsigned char *p, size_t len, AuthorizationData *data, size_t *size)
1248 : {
1249 269339 : memset(data, 0, sizeof(*data));
1250 269339 : return _asn1_decode_top(asn1_AuthorizationData, 0|0, p, len, data, size);
1251 : }
1252 :
1253 :
1254 : int ASN1CALL
1255 87132 : encode_AuthorizationData(unsigned char *p, size_t len, const AuthorizationData *data, size_t *size)
1256 : {
1257 87132 : return _asn1_encode(asn1_AuthorizationData, p, len, data, size);
1258 : }
1259 :
1260 :
1261 : size_t ASN1CALL
1262 87132 : length_AuthorizationData(const AuthorizationData *data)
1263 : {
1264 87132 : return _asn1_length(asn1_AuthorizationData, data);
1265 : }
1266 :
1267 :
1268 : void ASN1CALL
1269 1840325 : free_AuthorizationData(AuthorizationData *data)
1270 : {
1271 1840325 : _asn1_free_top(asn1_AuthorizationData, data);
1272 1840325 : }
1273 :
1274 :
1275 : int ASN1CALL
1276 1011669 : copy_AuthorizationData(const AuthorizationData *from, AuthorizationData *to)
1277 : {
1278 1011669 : return _asn1_copy_top(asn1_AuthorizationData, from, to);
1279 : }
1280 :
1281 :
1282 : char * ASN1CALL
1283 0 : print_AuthorizationData(const AuthorizationData *data, int flags)
1284 : {
1285 0 : return _asn1_print_top(asn1_AuthorizationData, flags, data);
1286 : }
1287 :
1288 : int ASN1CALL
1289 245910 : add_AuthorizationData(AuthorizationData *data, const AuthorizationDataElement *element)
1290 : {
1291 : int ret;
1292 : void *ptr;
1293 :
1294 245910 : ptr = realloc(data->val,
1295 245910 : (data->len + 1) * sizeof(data->val[0]));
1296 245910 : if (ptr == NULL) return ENOMEM;
1297 245910 : data->val = ptr;
1298 :
1299 245910 : ret = copy_AuthorizationDataElement(element, &data->val[data->len]);
1300 245910 : if (ret) return ret;
1301 245910 : data->len++;
1302 245910 : return 0;
1303 : }
1304 :
1305 : int ASN1CALL
1306 14682 : remove_AuthorizationData(AuthorizationData *data, unsigned int element)
1307 : {
1308 : void *ptr;
1309 :
1310 14682 : if (data->len == 0 || element >= data->len)
1311 0 : return ASN1_OVERRUN;
1312 14682 : free_AuthorizationDataElement(&data->val[element]);
1313 14682 : data->len--;
1314 14682 : if (element < data->len)
1315 0 : memmove(&data->val[element], &data->val[element + 1],
1316 0 : sizeof(data->val[0]) * (data->len - element));
1317 14682 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
1318 14682 : if (ptr != NULL || data->len == 0) data->val = ptr;
1319 14682 : return 0;
1320 : }
1321 :
1322 : /* template_members: APOptions exp exp */
1323 : static const struct asn1_template asn1_APOptions_bmember__0[] = {
1324 : /* 0 */ { 0|A1_HBF_RFC1510, sizeof(APOptions), ((void *)(uintptr_t)3) },
1325 : /* 1 */ { 0, 0, "reserved" },
1326 : /* 2 */ { 0, 1, "use_session_key" },
1327 : /* 3 */ { 0, 2, "mutual_required" }
1328 : };
1329 : /* generate_template_type: APOptions_tag__26 */
1330 : const struct asn1_template asn1_APOptions_tag__26[] = {
1331 : /* 0 */ { 0, sizeof(APOptions), ((void *)(uintptr_t)1) },
1332 : /* 1 */ { A1_OP_BMEMBER, 0, asn1_APOptions_bmember__0 }
1333 : };
1334 : /* generate_template_type: APOptions */
1335 : const struct asn1_template asn1_APOptions[] = {
1336 : /* 0 */ { 0, sizeof(APOptions), ((void *)(uintptr_t)1) },
1337 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_BitString), 0, asn1_APOptions_tag__26 }
1338 : };
1339 :
1340 : int ASN1CALL
1341 0 : decode_APOptions(const unsigned char *p, size_t len, APOptions *data, size_t *size)
1342 : {
1343 0 : memset(data, 0, sizeof(*data));
1344 0 : return _asn1_decode_top(asn1_APOptions, 0|0, p, len, data, size);
1345 : }
1346 :
1347 :
1348 : int ASN1CALL
1349 0 : encode_APOptions(unsigned char *p, size_t len, const APOptions *data, size_t *size)
1350 : {
1351 0 : return _asn1_encode(asn1_APOptions, p, len, data, size);
1352 : }
1353 :
1354 :
1355 : size_t ASN1CALL
1356 0 : length_APOptions(const APOptions *data)
1357 : {
1358 0 : return _asn1_length(asn1_APOptions, data);
1359 : }
1360 :
1361 :
1362 : void ASN1CALL
1363 0 : free_APOptions(APOptions *data)
1364 : {
1365 0 : _asn1_free_top(asn1_APOptions, data);
1366 0 : }
1367 :
1368 :
1369 : int ASN1CALL
1370 0 : copy_APOptions(const APOptions *from, APOptions *to)
1371 : {
1372 0 : return _asn1_copy_top(asn1_APOptions, from, to);
1373 : }
1374 :
1375 :
1376 : char * ASN1CALL
1377 0 : print_APOptions(const APOptions *data, int flags)
1378 : {
1379 0 : return _asn1_print_top(asn1_APOptions, flags, data);
1380 : }
1381 :
1382 0 : uint64_t APOptions2int(APOptions f)
1383 : {
1384 0 : uint64_t r = 0;
1385 0 : if(f.reserved) r |= (1ULL << 0);
1386 0 : if(f.use_session_key) r |= (1ULL << 1);
1387 0 : if(f.mutual_required) r |= (1ULL << 2);
1388 0 : return r;
1389 : }
1390 :
1391 0 : APOptions int2APOptions(uint64_t n)
1392 : {
1393 : APOptions flags;
1394 :
1395 0 : memset(&flags, 0, sizeof(flags));
1396 :
1397 0 : flags.reserved = (n >> 0) & 1;
1398 0 : flags.use_session_key = (n >> 1) & 1;
1399 0 : flags.mutual_required = (n >> 2) & 1;
1400 0 : return flags;
1401 : }
1402 :
1403 : static struct units APOptions_units[] = {
1404 : {"mutual-required", 1ULL << 2},
1405 : {"use-session-key", 1ULL << 1},
1406 : {"reserved", 1ULL << 0},
1407 : {NULL, 0}
1408 : };
1409 :
1410 0 : const struct units * asn1_APOptions_units(void){
1411 0 : return APOptions_units;
1412 : }
1413 :
1414 : /* template_members: TicketFlags exp exp */
1415 : static const struct asn1_template asn1_TicketFlags_bmember__1[] = {
1416 : /* 0 */ { 0|A1_HBF_RFC1510, sizeof(TicketFlags), ((void *)(uintptr_t)16) },
1417 : /* 1 */ { 0, 0, "reserved" },
1418 : /* 2 */ { 0, 1, "forwardable" },
1419 : /* 3 */ { 0, 2, "forwarded" },
1420 : /* 4 */ { 0, 3, "proxiable" },
1421 : /* 5 */ { 0, 4, "proxy" },
1422 : /* 6 */ { 0, 5, "may_postdate" },
1423 : /* 7 */ { 0, 6, "postdated" },
1424 : /* 8 */ { 0, 7, "invalid" },
1425 : /* 9 */ { 0, 8, "renewable" },
1426 : /* 10 */ { 0, 9, "initial" },
1427 : /* 11 */ { 0, 10, "pre_authent" },
1428 : /* 12 */ { 0, 11, "hw_authent" },
1429 : /* 13 */ { 0, 12, "transited_policy_checked" },
1430 : /* 14 */ { 0, 13, "ok_as_delegate" },
1431 : /* 15 */ { 0, 15, "enc_pa_rep" },
1432 : /* 16 */ { 0, 16, "anonymous" }
1433 : };
1434 : /* generate_template_type: TicketFlags_tag__27 */
1435 : const struct asn1_template asn1_TicketFlags_tag__27[] = {
1436 : /* 0 */ { 0, sizeof(TicketFlags), ((void *)(uintptr_t)1) },
1437 : /* 1 */ { A1_OP_BMEMBER, 0, asn1_TicketFlags_bmember__1 }
1438 : };
1439 : /* generate_template_type: TicketFlags */
1440 : const struct asn1_template asn1_TicketFlags[] = {
1441 : /* 0 */ { 0, sizeof(TicketFlags), ((void *)(uintptr_t)1) },
1442 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_BitString), 0, asn1_TicketFlags_tag__27 }
1443 : };
1444 :
1445 : int ASN1CALL
1446 0 : decode_TicketFlags(const unsigned char *p, size_t len, TicketFlags *data, size_t *size)
1447 : {
1448 0 : memset(data, 0, sizeof(*data));
1449 0 : return _asn1_decode_top(asn1_TicketFlags, 0|0, p, len, data, size);
1450 : }
1451 :
1452 :
1453 : int ASN1CALL
1454 0 : encode_TicketFlags(unsigned char *p, size_t len, const TicketFlags *data, size_t *size)
1455 : {
1456 0 : return _asn1_encode(asn1_TicketFlags, p, len, data, size);
1457 : }
1458 :
1459 :
1460 : size_t ASN1CALL
1461 0 : length_TicketFlags(const TicketFlags *data)
1462 : {
1463 0 : return _asn1_length(asn1_TicketFlags, data);
1464 : }
1465 :
1466 :
1467 : void ASN1CALL
1468 0 : free_TicketFlags(TicketFlags *data)
1469 : {
1470 0 : _asn1_free_top(asn1_TicketFlags, data);
1471 0 : }
1472 :
1473 :
1474 : int ASN1CALL
1475 0 : copy_TicketFlags(const TicketFlags *from, TicketFlags *to)
1476 : {
1477 0 : return _asn1_copy_top(asn1_TicketFlags, from, to);
1478 : }
1479 :
1480 :
1481 : char * ASN1CALL
1482 0 : print_TicketFlags(const TicketFlags *data, int flags)
1483 : {
1484 0 : return _asn1_print_top(asn1_TicketFlags, flags, data);
1485 : }
1486 :
1487 1376 : uint64_t TicketFlags2int(TicketFlags f)
1488 : {
1489 1376 : uint64_t r = 0;
1490 1376 : if(f.reserved) r |= (1ULL << 0);
1491 1376 : if(f.forwardable) r |= (1ULL << 1);
1492 1376 : if(f.forwarded) r |= (1ULL << 2);
1493 1376 : if(f.proxiable) r |= (1ULL << 3);
1494 1376 : if(f.proxy) r |= (1ULL << 4);
1495 1376 : if(f.may_postdate) r |= (1ULL << 5);
1496 1376 : if(f.postdated) r |= (1ULL << 6);
1497 1376 : if(f.invalid) r |= (1ULL << 7);
1498 1376 : if(f.renewable) r |= (1ULL << 8);
1499 1376 : if(f.initial) r |= (1ULL << 9);
1500 1376 : if(f.pre_authent) r |= (1ULL << 10);
1501 1376 : if(f.hw_authent) r |= (1ULL << 11);
1502 1376 : if(f.transited_policy_checked) r |= (1ULL << 12);
1503 1376 : if(f.ok_as_delegate) r |= (1ULL << 13);
1504 1376 : if(f.enc_pa_rep) r |= (1ULL << 15);
1505 1376 : if(f.anonymous) r |= (1ULL << 16);
1506 1376 : return r;
1507 : }
1508 :
1509 6916 : TicketFlags int2TicketFlags(uint64_t n)
1510 : {
1511 : TicketFlags flags;
1512 :
1513 6916 : memset(&flags, 0, sizeof(flags));
1514 :
1515 6916 : flags.reserved = (n >> 0) & 1;
1516 6916 : flags.forwardable = (n >> 1) & 1;
1517 6916 : flags.forwarded = (n >> 2) & 1;
1518 6916 : flags.proxiable = (n >> 3) & 1;
1519 6916 : flags.proxy = (n >> 4) & 1;
1520 6916 : flags.may_postdate = (n >> 5) & 1;
1521 6916 : flags.postdated = (n >> 6) & 1;
1522 6916 : flags.invalid = (n >> 7) & 1;
1523 6916 : flags.renewable = (n >> 8) & 1;
1524 6916 : flags.initial = (n >> 9) & 1;
1525 6916 : flags.pre_authent = (n >> 10) & 1;
1526 6916 : flags.hw_authent = (n >> 11) & 1;
1527 6916 : flags.transited_policy_checked = (n >> 12) & 1;
1528 6916 : flags.ok_as_delegate = (n >> 13) & 1;
1529 6916 : flags.enc_pa_rep = (n >> 15) & 1;
1530 6916 : flags.anonymous = (n >> 16) & 1;
1531 6916 : return flags;
1532 : }
1533 :
1534 : static struct units TicketFlags_units[] = {
1535 : {"anonymous", 1ULL << 16},
1536 : {"enc-pa-rep", 1ULL << 15},
1537 : {"ok-as-delegate", 1ULL << 13},
1538 : {"transited-policy-checked", 1ULL << 12},
1539 : {"hw-authent", 1ULL << 11},
1540 : {"pre-authent", 1ULL << 10},
1541 : {"initial", 1ULL << 9},
1542 : {"renewable", 1ULL << 8},
1543 : {"invalid", 1ULL << 7},
1544 : {"postdated", 1ULL << 6},
1545 : {"may-postdate", 1ULL << 5},
1546 : {"proxy", 1ULL << 4},
1547 : {"proxiable", 1ULL << 3},
1548 : {"forwarded", 1ULL << 2},
1549 : {"forwardable", 1ULL << 1},
1550 : {"reserved", 1ULL << 0},
1551 : {NULL, 0}
1552 : };
1553 :
1554 0 : const struct units * asn1_TicketFlags_units(void){
1555 0 : return TicketFlags_units;
1556 : }
1557 :
1558 : /* template_members: KDCOptions exp exp */
1559 : static const struct asn1_template asn1_KDCOptions_bmember__2[] = {
1560 : /* 0 */ { 0|A1_HBF_RFC1510, sizeof(KDCOptions), ((void *)(uintptr_t)16) },
1561 : /* 1 */ { 0, 0, "reserved" },
1562 : /* 2 */ { 0, 1, "forwardable" },
1563 : /* 3 */ { 0, 2, "forwarded" },
1564 : /* 4 */ { 0, 3, "proxiable" },
1565 : /* 5 */ { 0, 4, "proxy" },
1566 : /* 6 */ { 0, 5, "allow_postdate" },
1567 : /* 7 */ { 0, 6, "postdated" },
1568 : /* 8 */ { 0, 8, "renewable" },
1569 : /* 9 */ { 0, 14, "cname_in_addl_tkt" },
1570 : /* 10 */ { 0, 15, "canonicalize" },
1571 : /* 11 */ { 0, 16, "request_anonymous" },
1572 : /* 12 */ { 0, 26, "disable_transited_check" },
1573 : /* 13 */ { 0, 27, "renewable_ok" },
1574 : /* 14 */ { 0, 28, "enc_tkt_in_skey" },
1575 : /* 15 */ { 0, 30, "renew" },
1576 : /* 16 */ { 0, 31, "validate" }
1577 : };
1578 : /* generate_template_type: KDCOptions_tag__28 */
1579 : const struct asn1_template asn1_KDCOptions_tag__28[] = {
1580 : /* 0 */ { 0, sizeof(KDCOptions), ((void *)(uintptr_t)1) },
1581 : /* 1 */ { A1_OP_BMEMBER, 0, asn1_KDCOptions_bmember__2 }
1582 : };
1583 : /* generate_template_type: KDCOptions */
1584 : const struct asn1_template asn1_KDCOptions[] = {
1585 : /* 0 */ { 0, sizeof(KDCOptions), ((void *)(uintptr_t)1) },
1586 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_BitString), 0, asn1_KDCOptions_tag__28 }
1587 : };
1588 :
1589 : int ASN1CALL
1590 0 : decode_KDCOptions(const unsigned char *p, size_t len, KDCOptions *data, size_t *size)
1591 : {
1592 0 : memset(data, 0, sizeof(*data));
1593 0 : return _asn1_decode_top(asn1_KDCOptions, 0|0, p, len, data, size);
1594 : }
1595 :
1596 :
1597 : int ASN1CALL
1598 0 : encode_KDCOptions(unsigned char *p, size_t len, const KDCOptions *data, size_t *size)
1599 : {
1600 0 : return _asn1_encode(asn1_KDCOptions, p, len, data, size);
1601 : }
1602 :
1603 :
1604 : size_t ASN1CALL
1605 0 : length_KDCOptions(const KDCOptions *data)
1606 : {
1607 0 : return _asn1_length(asn1_KDCOptions, data);
1608 : }
1609 :
1610 :
1611 : void ASN1CALL
1612 0 : free_KDCOptions(KDCOptions *data)
1613 : {
1614 0 : _asn1_free_top(asn1_KDCOptions, data);
1615 0 : }
1616 :
1617 :
1618 : int ASN1CALL
1619 0 : copy_KDCOptions(const KDCOptions *from, KDCOptions *to)
1620 : {
1621 0 : return _asn1_copy_top(asn1_KDCOptions, from, to);
1622 : }
1623 :
1624 :
1625 : char * ASN1CALL
1626 0 : print_KDCOptions(const KDCOptions *data, int flags)
1627 : {
1628 0 : return _asn1_print_top(asn1_KDCOptions, flags, data);
1629 : }
1630 :
1631 91297 : uint64_t KDCOptions2int(KDCOptions f)
1632 : {
1633 91297 : uint64_t r = 0;
1634 91297 : if(f.reserved) r |= (1ULL << 0);
1635 91297 : if(f.forwardable) r |= (1ULL << 1);
1636 91297 : if(f.forwarded) r |= (1ULL << 2);
1637 91297 : if(f.proxiable) r |= (1ULL << 3);
1638 91297 : if(f.proxy) r |= (1ULL << 4);
1639 91297 : if(f.allow_postdate) r |= (1ULL << 5);
1640 91297 : if(f.postdated) r |= (1ULL << 6);
1641 91297 : if(f.renewable) r |= (1ULL << 8);
1642 91297 : if(f.cname_in_addl_tkt) r |= (1ULL << 14);
1643 91297 : if(f.canonicalize) r |= (1ULL << 15);
1644 91297 : if(f.request_anonymous) r |= (1ULL << 16);
1645 91297 : if(f.disable_transited_check) r |= (1ULL << 26);
1646 91297 : if(f.renewable_ok) r |= (1ULL << 27);
1647 91297 : if(f.enc_tkt_in_skey) r |= (1ULL << 28);
1648 91297 : if(f.renew) r |= (1ULL << 30);
1649 91297 : if(f.validate) r |= (1ULL << 31);
1650 91297 : return r;
1651 : }
1652 :
1653 17255 : KDCOptions int2KDCOptions(uint64_t n)
1654 : {
1655 : KDCOptions flags;
1656 :
1657 17255 : memset(&flags, 0, sizeof(flags));
1658 :
1659 17255 : flags.reserved = (n >> 0) & 1;
1660 17255 : flags.forwardable = (n >> 1) & 1;
1661 17255 : flags.forwarded = (n >> 2) & 1;
1662 17255 : flags.proxiable = (n >> 3) & 1;
1663 17255 : flags.proxy = (n >> 4) & 1;
1664 17255 : flags.allow_postdate = (n >> 5) & 1;
1665 17255 : flags.postdated = (n >> 6) & 1;
1666 17255 : flags.renewable = (n >> 8) & 1;
1667 17255 : flags.cname_in_addl_tkt = (n >> 14) & 1;
1668 17255 : flags.canonicalize = (n >> 15) & 1;
1669 17255 : flags.request_anonymous = (n >> 16) & 1;
1670 17255 : flags.disable_transited_check = (n >> 26) & 1;
1671 17255 : flags.renewable_ok = (n >> 27) & 1;
1672 17255 : flags.enc_tkt_in_skey = (n >> 28) & 1;
1673 17255 : flags.renew = (n >> 30) & 1;
1674 17255 : flags.validate = (n >> 31) & 1;
1675 17255 : return flags;
1676 : }
1677 :
1678 : static struct units KDCOptions_units[] = {
1679 : {"validate", 1ULL << 31},
1680 : {"renew", 1ULL << 30},
1681 : {"enc-tkt-in-skey", 1ULL << 28},
1682 : {"renewable-ok", 1ULL << 27},
1683 : {"disable-transited-check", 1ULL << 26},
1684 : {"request-anonymous", 1ULL << 16},
1685 : {"canonicalize", 1ULL << 15},
1686 : {"cname-in-addl-tkt", 1ULL << 14},
1687 : {"renewable", 1ULL << 8},
1688 : {"postdated", 1ULL << 6},
1689 : {"allow-postdate", 1ULL << 5},
1690 : {"proxy", 1ULL << 4},
1691 : {"proxiable", 1ULL << 3},
1692 : {"forwarded", 1ULL << 2},
1693 : {"forwardable", 1ULL << 1},
1694 : {"reserved", 1ULL << 0},
1695 : {NULL, 0}
1696 : };
1697 :
1698 91297 : const struct units * asn1_KDCOptions_units(void){
1699 91297 : return KDCOptions_units;
1700 : }
1701 :
1702 : /* template_members: LR_TYPE exp exp */
1703 : const struct asn1_template asn1_LR_TYPE_enum_names[] = {
1704 : /* 0 */ { 0, 0, ((void *)(uintptr_t)8) },
1705 : /* 1 */ { A1_OP_NAME, 0, "LR_NONE" },
1706 : /* 2 */ { A1_OP_NAME, 1, "LR_INITIAL_TGT" },
1707 : /* 3 */ { A1_OP_NAME, 2, "LR_INITIAL" },
1708 : /* 4 */ { A1_OP_NAME, 3, "LR_ISSUE_USE_TGT" },
1709 : /* 5 */ { A1_OP_NAME, 4, "LR_RENEWAL" },
1710 : /* 6 */ { A1_OP_NAME, 5, "LR_REQUEST" },
1711 : /* 7 */ { A1_OP_NAME, 6, "LR_PW_EXPTIME" },
1712 : /* 8 */ { A1_OP_NAME, 7, "LR_ACCT_EXPTIME" }
1713 : };
1714 : /* generate_template_type: LR_TYPE_tag__29 */
1715 : const struct asn1_template asn1_LR_TYPE_tag__29[] = {
1716 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
1717 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_LR_TYPE_enum_names }
1718 : };
1719 : /* generate_template_type: LR_TYPE */
1720 : const struct asn1_template asn1_LR_TYPE[] = {
1721 : /* 0 */ { 0, sizeof(LR_TYPE), ((void *)(uintptr_t)1) },
1722 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_LR_TYPE_tag__29 }
1723 : };
1724 :
1725 : int ASN1CALL
1726 0 : decode_LR_TYPE(const unsigned char *p, size_t len, LR_TYPE *data, size_t *size)
1727 : {
1728 0 : memset(data, 0, sizeof(*data));
1729 0 : return _asn1_decode_top(asn1_LR_TYPE, 0|0, p, len, data, size);
1730 : }
1731 :
1732 :
1733 : int ASN1CALL
1734 0 : encode_LR_TYPE(unsigned char *p, size_t len, const LR_TYPE *data, size_t *size)
1735 : {
1736 0 : return _asn1_encode(asn1_LR_TYPE, p, len, data, size);
1737 : }
1738 :
1739 :
1740 : size_t ASN1CALL
1741 0 : length_LR_TYPE(const LR_TYPE *data)
1742 : {
1743 0 : return _asn1_length(asn1_LR_TYPE, data);
1744 : }
1745 :
1746 :
1747 : void ASN1CALL
1748 0 : free_LR_TYPE(LR_TYPE *data)
1749 : {
1750 0 : _asn1_free_top(asn1_LR_TYPE, data);
1751 0 : }
1752 :
1753 :
1754 : int ASN1CALL
1755 0 : copy_LR_TYPE(const LR_TYPE *from, LR_TYPE *to)
1756 : {
1757 0 : return _asn1_copy_top(asn1_LR_TYPE, from, to);
1758 : }
1759 :
1760 :
1761 : char * ASN1CALL
1762 0 : print_LR_TYPE(const LR_TYPE *data, int flags)
1763 : {
1764 0 : return _asn1_print_top(asn1_LR_TYPE, flags, data);
1765 : }
1766 :
1767 : /* template_members: LastReq exp exp */
1768 : /* template_members: LastReq_val exp exp */
1769 : /* tsequence: members isstruct: 1 */
1770 : /* template_members: LastReq_val exp exp */
1771 : /* generate_template_type: LastReq_val_tag_lr_type_32 */
1772 : const struct asn1_template asn1_LastReq_val_tag_lr_type_32[] = {
1773 : /* 0 */ { 0, sizeof(LR_TYPE), ((void *)(uintptr_t)1) },
1774 : /* 1 */ { A1_OP_TYPE , 0, asn1_LR_TYPE }
1775 : };
1776 : /* template_members: LastReq_val exp exp */
1777 : /* generate_template_type: LastReq_val_tag_lr_value_33 */
1778 : const struct asn1_template asn1_LastReq_val_tag_lr_value_33[] = {
1779 : /* 0 */ { 0, sizeof(KerberosTime), ((void *)(uintptr_t)1) },
1780 : /* 1 */ { A1_OP_TYPE , 0, asn1_KerberosTime }
1781 : };
1782 : /* generate_template_type: LastReq_val_tag__31 */
1783 : const struct asn1_template asn1_LastReq_val_tag__31[] = {
1784 : /* 0 */ { 0, sizeof(struct LastReq_val), ((void *)(uintptr_t)5) },
1785 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct LastReq_val, lr_type), asn1_LastReq_val_tag_lr_type_32 },
1786 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct LastReq_val, lr_value), asn1_LastReq_val_tag_lr_value_33 },
1787 : /* 3 */ { A1_OP_NAME, 0, "LastReq_val" },
1788 : /* 4 */ { A1_OP_NAME, 0, "lr-type" },
1789 : /* 5 */ { A1_OP_NAME, 0, "lr-value" }
1790 : };
1791 : /* generate_template_type: LastReq_seofTstruct_3 */
1792 : const struct asn1_template asn1_LastReq_seofTstruct_3[] = {
1793 : /* 0 */ { 0, sizeof(struct LastReq_val), ((void *)(uintptr_t)1) },
1794 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_LastReq_val_tag__31 }
1795 : };
1796 : /* generate_template_type: LastReq_tag__30 */
1797 : const struct asn1_template asn1_LastReq_tag__30[] = {
1798 : /* 0 */ { 0, sizeof(LastReq), ((void *)(uintptr_t)1) },
1799 : /* 1 */ { A1_OP_SEQOF, 0, asn1_LastReq_seofTstruct_3 }
1800 : };
1801 : /* generate_template_type: LastReq */
1802 : const struct asn1_template asn1_LastReq[] = {
1803 : /* 0 */ { 0, sizeof(LastReq), ((void *)(uintptr_t)1) },
1804 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_LastReq_tag__30 }
1805 : };
1806 :
1807 : int ASN1CALL
1808 0 : decode_LastReq(const unsigned char *p, size_t len, LastReq *data, size_t *size)
1809 : {
1810 0 : memset(data, 0, sizeof(*data));
1811 0 : return _asn1_decode_top(asn1_LastReq, 0|0, p, len, data, size);
1812 : }
1813 :
1814 :
1815 : int ASN1CALL
1816 0 : encode_LastReq(unsigned char *p, size_t len, const LastReq *data, size_t *size)
1817 : {
1818 0 : return _asn1_encode(asn1_LastReq, p, len, data, size);
1819 : }
1820 :
1821 :
1822 : size_t ASN1CALL
1823 0 : length_LastReq(const LastReq *data)
1824 : {
1825 0 : return _asn1_length(asn1_LastReq, data);
1826 : }
1827 :
1828 :
1829 : void ASN1CALL
1830 38595 : free_LastReq(LastReq *data)
1831 : {
1832 38595 : _asn1_free_top(asn1_LastReq, data);
1833 38595 : }
1834 :
1835 :
1836 : int ASN1CALL
1837 0 : copy_LastReq(const LastReq *from, LastReq *to)
1838 : {
1839 0 : return _asn1_copy_top(asn1_LastReq, from, to);
1840 : }
1841 :
1842 :
1843 : char * ASN1CALL
1844 0 : print_LastReq(const LastReq *data, int flags)
1845 : {
1846 0 : return _asn1_print_top(asn1_LastReq, flags, data);
1847 : }
1848 :
1849 : /* template_members: EncryptedData exp exp */
1850 : /* tsequence: members isstruct: 1 */
1851 : /* template_members: EncryptedData exp exp */
1852 : /* generate_template_type: EncryptedData_tag_etype_35 */
1853 : const struct asn1_template asn1_EncryptedData_tag_etype_35[] = {
1854 : /* 0 */ { 0, sizeof(ENCTYPE), ((void *)(uintptr_t)1) },
1855 : /* 1 */ { A1_OP_TYPE , 0, asn1_ENCTYPE }
1856 : };
1857 : /* template_members: EncryptedData exp exp */
1858 : /* generate_template_type: EncryptedData_tag_kvno_36 */
1859 : /* template_members: EncryptedData exp exp */
1860 : /* template_members: heim_octet_string exp exp */
1861 : /* generate_template_type: heim_octet_string_tag_cipher_38 */
1862 : /* generate_template_type: EncryptedData_tag_cipher_37 */
1863 : /* generate_template_type: EncryptedData_tag__34 */
1864 : const struct asn1_template asn1_EncryptedData_tag__34[] = {
1865 : /* 0 */ { 0, sizeof(struct EncryptedData), ((void *)(uintptr_t)7) },
1866 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct EncryptedData, etype), asn1_EncryptedData_tag_etype_35 },
1867 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct EncryptedData, kvno), asn1_HostAddress_tag_addr_type_16 },
1868 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct EncryptedData, cipher), asn1_HostAddress_tag_address_17 },
1869 : /* 4 */ { A1_OP_NAME, 0, "EncryptedData" },
1870 : /* 5 */ { A1_OP_NAME, 0, "etype" },
1871 : /* 6 */ { A1_OP_NAME, 0, "kvno" },
1872 : /* 7 */ { A1_OP_NAME, 0, "cipher" }
1873 : };
1874 : /* generate_template_type: EncryptedData */
1875 : const struct asn1_template asn1_EncryptedData[] = {
1876 : /* 0 */ { 0, sizeof(EncryptedData), ((void *)(uintptr_t)1) },
1877 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_EncryptedData_tag__34 }
1878 : };
1879 :
1880 : int ASN1CALL
1881 19294 : decode_EncryptedData(const unsigned char *p, size_t len, EncryptedData *data, size_t *size)
1882 : {
1883 19294 : memset(data, 0, sizeof(*data));
1884 19294 : return _asn1_decode_top(asn1_EncryptedData, 0|0, p, len, data, size);
1885 : }
1886 :
1887 :
1888 : int ASN1CALL
1889 10075 : encode_EncryptedData(unsigned char *p, size_t len, const EncryptedData *data, size_t *size)
1890 : {
1891 10075 : return _asn1_encode(asn1_EncryptedData, p, len, data, size);
1892 : }
1893 :
1894 :
1895 : size_t ASN1CALL
1896 10075 : length_EncryptedData(const EncryptedData *data)
1897 : {
1898 10075 : return _asn1_length(asn1_EncryptedData, data);
1899 : }
1900 :
1901 :
1902 : void ASN1CALL
1903 30545 : free_EncryptedData(EncryptedData *data)
1904 : {
1905 30545 : _asn1_free_top(asn1_EncryptedData, data);
1906 30545 : }
1907 :
1908 :
1909 : int ASN1CALL
1910 0 : copy_EncryptedData(const EncryptedData *from, EncryptedData *to)
1911 : {
1912 0 : return _asn1_copy_top(asn1_EncryptedData, from, to);
1913 : }
1914 :
1915 :
1916 : char * ASN1CALL
1917 0 : print_EncryptedData(const EncryptedData *data, int flags)
1918 : {
1919 0 : return _asn1_print_top(asn1_EncryptedData, flags, data);
1920 : }
1921 :
1922 : /* template_members: EncryptionKey exp exp */
1923 : /* tsequence: members isstruct: 1 */
1924 : /* template_members: EncryptionKey exp exp */
1925 : /* generate_template_type: EncryptionKey_tag_keytype_40 */
1926 : /* template_members: EncryptionKey exp exp */
1927 : /* template_members: heim_octet_string exp exp */
1928 : /* generate_template_type: heim_octet_string_tag_keyvalue_42 */
1929 : /* generate_template_type: EncryptionKey_tag_keyvalue_41 */
1930 : /* generate_template_type: EncryptionKey_tag__39 */
1931 : const struct asn1_template asn1_EncryptionKey_tag__39[] = {
1932 : /* 0 */ { 0, sizeof(struct EncryptionKey), ((void *)(uintptr_t)5) },
1933 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct EncryptionKey, keytype), asn1_HostAddress_tag_addr_type_16 },
1934 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct EncryptionKey, keyvalue), asn1_HostAddress_tag_address_17 },
1935 : /* 3 */ { A1_OP_NAME, 0, "EncryptionKey" },
1936 : /* 4 */ { A1_OP_NAME, 0, "keytype" },
1937 : /* 5 */ { A1_OP_NAME, 0, "keyvalue" }
1938 : };
1939 : /* generate_template_type: EncryptionKey */
1940 : const struct asn1_template asn1_EncryptionKey[] = {
1941 : /* 0 */ { 0, sizeof(EncryptionKey), ((void *)(uintptr_t)1) },
1942 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_EncryptionKey_tag__39 }
1943 : };
1944 :
1945 : int ASN1CALL
1946 0 : decode_EncryptionKey(const unsigned char *p, size_t len, EncryptionKey *data, size_t *size)
1947 : {
1948 0 : memset(data, 0, sizeof(*data));
1949 0 : return _asn1_decode_top(asn1_EncryptionKey, 0|0, p, len, data, size);
1950 : }
1951 :
1952 :
1953 : int ASN1CALL
1954 0 : encode_EncryptionKey(unsigned char *p, size_t len, const EncryptionKey *data, size_t *size)
1955 : {
1956 0 : return _asn1_encode(asn1_EncryptionKey, p, len, data, size);
1957 : }
1958 :
1959 :
1960 : size_t ASN1CALL
1961 0 : length_EncryptionKey(const EncryptionKey *data)
1962 : {
1963 0 : return _asn1_length(asn1_EncryptionKey, data);
1964 : }
1965 :
1966 :
1967 : void ASN1CALL
1968 395050 : free_EncryptionKey(EncryptionKey *data)
1969 : {
1970 395050 : _asn1_free_top(asn1_EncryptionKey, data);
1971 395050 : }
1972 :
1973 :
1974 : int ASN1CALL
1975 5584415 : copy_EncryptionKey(const EncryptionKey *from, EncryptionKey *to)
1976 : {
1977 5584415 : return _asn1_copy_top(asn1_EncryptionKey, from, to);
1978 : }
1979 :
1980 :
1981 : char * ASN1CALL
1982 0 : print_EncryptionKey(const EncryptionKey *data, int flags)
1983 : {
1984 0 : return _asn1_print_top(asn1_EncryptionKey, flags, data);
1985 : }
1986 :
1987 : /* template_members: TransitedEncoding exp exp */
1988 : /* tsequence: members isstruct: 1 */
1989 : /* template_members: TransitedEncoding exp exp */
1990 : /* generate_template_type: TransitedEncoding_tag_tr_type_44 */
1991 : /* template_members: TransitedEncoding exp exp */
1992 : /* template_members: heim_octet_string exp exp */
1993 : /* generate_template_type: heim_octet_string_tag_contents_46 */
1994 : /* generate_template_type: TransitedEncoding_tag_contents_45 */
1995 : /* generate_template_type: TransitedEncoding_tag__43 */
1996 : const struct asn1_template asn1_TransitedEncoding_tag__43[] = {
1997 : /* 0 */ { 0, sizeof(struct TransitedEncoding), ((void *)(uintptr_t)5) },
1998 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct TransitedEncoding, tr_type), asn1_HostAddress_tag_addr_type_16 },
1999 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct TransitedEncoding, contents), asn1_HostAddress_tag_address_17 },
2000 : /* 3 */ { A1_OP_NAME, 0, "TransitedEncoding" },
2001 : /* 4 */ { A1_OP_NAME, 0, "tr-type" },
2002 : /* 5 */ { A1_OP_NAME, 0, "contents" }
2003 : };
2004 : /* generate_template_type: TransitedEncoding */
2005 : const struct asn1_template asn1_TransitedEncoding[] = {
2006 : /* 0 */ { 0, sizeof(TransitedEncoding), ((void *)(uintptr_t)1) },
2007 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_TransitedEncoding_tag__43 }
2008 : };
2009 :
2010 : int ASN1CALL
2011 0 : decode_TransitedEncoding(const unsigned char *p, size_t len, TransitedEncoding *data, size_t *size)
2012 : {
2013 0 : memset(data, 0, sizeof(*data));
2014 0 : return _asn1_decode_top(asn1_TransitedEncoding, 0|0, p, len, data, size);
2015 : }
2016 :
2017 :
2018 : int ASN1CALL
2019 0 : encode_TransitedEncoding(unsigned char *p, size_t len, const TransitedEncoding *data, size_t *size)
2020 : {
2021 0 : return _asn1_encode(asn1_TransitedEncoding, p, len, data, size);
2022 : }
2023 :
2024 :
2025 : size_t ASN1CALL
2026 0 : length_TransitedEncoding(const TransitedEncoding *data)
2027 : {
2028 0 : return _asn1_length(asn1_TransitedEncoding, data);
2029 : }
2030 :
2031 :
2032 : void ASN1CALL
2033 38595 : free_TransitedEncoding(TransitedEncoding *data)
2034 : {
2035 38595 : _asn1_free_top(asn1_TransitedEncoding, data);
2036 38595 : }
2037 :
2038 :
2039 : int ASN1CALL
2040 0 : copy_TransitedEncoding(const TransitedEncoding *from, TransitedEncoding *to)
2041 : {
2042 0 : return _asn1_copy_top(asn1_TransitedEncoding, from, to);
2043 : }
2044 :
2045 :
2046 : char * ASN1CALL
2047 0 : print_TransitedEncoding(const TransitedEncoding *data, int flags)
2048 : {
2049 0 : return _asn1_print_top(asn1_TransitedEncoding, flags, data);
2050 : }
2051 :
2052 : /* template_members: Ticket exp exp */
2053 : /* template_members: Ticket exp exp */
2054 : /* tsequence: members isstruct: 1 */
2055 : /* template_members: Ticket exp exp */
2056 : /* generate_template_type: Ticket_tag_tkt_vno_49 */
2057 : /* template_members: Ticket exp exp */
2058 : /* generate_template_type: Ticket_tag_realm_50 */
2059 : const struct asn1_template asn1_Ticket_tag_realm_50[] = {
2060 : /* 0 */ { 0, sizeof(Realm), ((void *)(uintptr_t)1) },
2061 : /* 1 */ { A1_OP_TYPE , 0, asn1_Realm }
2062 : };
2063 : /* template_members: Ticket exp exp */
2064 : /* generate_template_type: Ticket_tag_sname_51 */
2065 : const struct asn1_template asn1_Ticket_tag_sname_51[] = {
2066 : /* 0 */ { 0, sizeof(PrincipalName), ((void *)(uintptr_t)1) },
2067 : /* 1 */ { A1_OP_TYPE , 0, asn1_PrincipalName }
2068 : };
2069 : /* template_members: Ticket exp exp */
2070 : /* generate_template_type: Ticket_tag_enc_part_52 */
2071 : const struct asn1_template asn1_Ticket_tag_enc_part_52[] = {
2072 : /* 0 */ { 0, sizeof(EncryptedData), ((void *)(uintptr_t)1) },
2073 : /* 1 */ { A1_OP_TYPE , 0, asn1_EncryptedData }
2074 : };
2075 : /* generate_template_type: Ticket_tag__48 */
2076 : const struct asn1_template asn1_Ticket_tag__48[] = {
2077 : /* 0 */ { 0, sizeof(struct Ticket), ((void *)(uintptr_t)9) },
2078 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct Ticket, tkt_vno), asn1_HostAddress_tag_addr_type_16 },
2079 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct Ticket, realm), asn1_Ticket_tag_realm_50 },
2080 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct Ticket, sname), asn1_Ticket_tag_sname_51 },
2081 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct Ticket, enc_part), asn1_Ticket_tag_enc_part_52 },
2082 : /* 5 */ { A1_OP_NAME, 0, "Ticket" },
2083 : /* 6 */ { A1_OP_NAME, 0, "tkt-vno" },
2084 : /* 7 */ { A1_OP_NAME, 0, "realm" },
2085 : /* 8 */ { A1_OP_NAME, 0, "sname" },
2086 : /* 9 */ { A1_OP_NAME, 0, "enc-part" }
2087 : };
2088 : /* generate_template_type: Ticket_tag__47 */
2089 : const struct asn1_template asn1_Ticket_tag__47[] = {
2090 : /* 0 */ { 0, sizeof(struct Ticket), ((void *)(uintptr_t)1) },
2091 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_Ticket_tag__48 }
2092 : };
2093 : /* generate_template_type: Ticket */
2094 : const struct asn1_template asn1_Ticket[] = {
2095 : /* 0 */ { 0, sizeof(Ticket), ((void *)(uintptr_t)1) },
2096 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,1), 0, asn1_Ticket_tag__47 }
2097 : };
2098 :
2099 : int ASN1CALL
2100 77700 : decode_Ticket(const unsigned char *p, size_t len, Ticket *data, size_t *size)
2101 : {
2102 77700 : memset(data, 0, sizeof(*data));
2103 77700 : return _asn1_decode_top(asn1_Ticket, 0|0, p, len, data, size);
2104 : }
2105 :
2106 :
2107 : int ASN1CALL
2108 135259 : encode_Ticket(unsigned char *p, size_t len, const Ticket *data, size_t *size)
2109 : {
2110 135259 : return _asn1_encode(asn1_Ticket, p, len, data, size);
2111 : }
2112 :
2113 :
2114 : size_t ASN1CALL
2115 135259 : length_Ticket(const Ticket *data)
2116 : {
2117 135259 : return _asn1_length(asn1_Ticket, data);
2118 : }
2119 :
2120 :
2121 : void ASN1CALL
2122 114 : free_Ticket(Ticket *data)
2123 : {
2124 114 : _asn1_free_top(asn1_Ticket, data);
2125 114 : }
2126 :
2127 :
2128 : int ASN1CALL
2129 34 : copy_Ticket(const Ticket *from, Ticket *to)
2130 : {
2131 34 : return _asn1_copy_top(asn1_Ticket, from, to);
2132 : }
2133 :
2134 :
2135 : char * ASN1CALL
2136 0 : print_Ticket(const Ticket *data, int flags)
2137 : {
2138 0 : return _asn1_print_top(asn1_Ticket, flags, data);
2139 : }
2140 :
2141 : /* template_members: EncTicketPart exp exp */
2142 : /* template_members: EncTicketPart exp exp */
2143 : /* tsequence: members isstruct: 1 */
2144 : /* template_members: EncTicketPart exp exp */
2145 : /* generate_template_type: EncTicketPart_tag_flags_55 */
2146 : const struct asn1_template asn1_EncTicketPart_tag_flags_55[] = {
2147 : /* 0 */ { 0, sizeof(TicketFlags), ((void *)(uintptr_t)1) },
2148 : /* 1 */ { A1_OP_TYPE , 0, asn1_TicketFlags }
2149 : };
2150 : /* template_members: EncTicketPart exp exp */
2151 : /* generate_template_type: EncTicketPart_tag_key_56 */
2152 : const struct asn1_template asn1_EncTicketPart_tag_key_56[] = {
2153 : /* 0 */ { 0, sizeof(EncryptionKey), ((void *)(uintptr_t)1) },
2154 : /* 1 */ { A1_OP_TYPE , 0, asn1_EncryptionKey }
2155 : };
2156 : /* template_members: EncTicketPart exp exp */
2157 : /* generate_template_type: EncTicketPart_tag_crealm_57 */
2158 : /* template_members: EncTicketPart exp exp */
2159 : /* generate_template_type: EncTicketPart_tag_cname_58 */
2160 : /* template_members: EncTicketPart exp exp */
2161 : /* generate_template_type: EncTicketPart_tag_transited_59 */
2162 : const struct asn1_template asn1_EncTicketPart_tag_transited_59[] = {
2163 : /* 0 */ { 0, sizeof(TransitedEncoding), ((void *)(uintptr_t)1) },
2164 : /* 1 */ { A1_OP_TYPE , 0, asn1_TransitedEncoding }
2165 : };
2166 : /* template_members: EncTicketPart exp exp */
2167 : /* generate_template_type: EncTicketPart_tag_authtime_60 */
2168 : /* template_members: EncTicketPart exp exp */
2169 : /* generate_template_type: EncTicketPart_tag_starttime_61 */
2170 : /* template_members: EncTicketPart exp exp */
2171 : /* generate_template_type: EncTicketPart_tag_endtime_62 */
2172 : /* template_members: EncTicketPart exp exp */
2173 : /* generate_template_type: EncTicketPart_tag_renew_till_63 */
2174 : /* template_members: EncTicketPart exp exp */
2175 : /* generate_template_type: EncTicketPart_tag_caddr_64 */
2176 : const struct asn1_template asn1_EncTicketPart_tag_caddr_64[] = {
2177 : /* 0 */ { 0, sizeof(HostAddresses), ((void *)(uintptr_t)1) },
2178 : /* 1 */ { A1_OP_TYPE , 0, asn1_HostAddresses }
2179 : };
2180 : /* template_members: EncTicketPart exp exp */
2181 : /* generate_template_type: EncTicketPart_tag_authorization_data_65 */
2182 : const struct asn1_template asn1_EncTicketPart_tag_authorization_data_65[] = {
2183 : /* 0 */ { 0, sizeof(AuthorizationData), ((void *)(uintptr_t)1) },
2184 : /* 1 */ { A1_OP_TYPE , 0, asn1_AuthorizationData }
2185 : };
2186 : /* generate_template_type: EncTicketPart_tag__54 */
2187 : const struct asn1_template asn1_EncTicketPart_tag__54[] = {
2188 : /* 0 */ { 0, sizeof(struct EncTicketPart), ((void *)(uintptr_t)23) },
2189 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct EncTicketPart, flags), asn1_EncTicketPart_tag_flags_55 },
2190 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct EncTicketPart, key), asn1_EncTicketPart_tag_key_56 },
2191 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct EncTicketPart, crealm), asn1_Ticket_tag_realm_50 },
2192 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct EncTicketPart, cname), asn1_Ticket_tag_sname_51 },
2193 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct EncTicketPart, transited), asn1_EncTicketPart_tag_transited_59 },
2194 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5), offsetof(struct EncTicketPart, authtime), asn1_LastReq_val_tag_lr_value_33 },
2195 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6)|A1_FLAG_OPTIONAL, offsetof(struct EncTicketPart, starttime), asn1_LastReq_val_tag_lr_value_33 },
2196 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7), offsetof(struct EncTicketPart, endtime), asn1_LastReq_val_tag_lr_value_33 },
2197 : /* 9 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,8)|A1_FLAG_OPTIONAL, offsetof(struct EncTicketPart, renew_till), asn1_LastReq_val_tag_lr_value_33 },
2198 : /* 10 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,9)|A1_FLAG_OPTIONAL, offsetof(struct EncTicketPart, caddr), asn1_EncTicketPart_tag_caddr_64 },
2199 : /* 11 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,10)|A1_FLAG_OPTIONAL, offsetof(struct EncTicketPart, authorization_data), asn1_EncTicketPart_tag_authorization_data_65 },
2200 : /* 12 */ { A1_OP_NAME, 0, "EncTicketPart" },
2201 : /* 13 */ { A1_OP_NAME, 0, "flags" },
2202 : /* 14 */ { A1_OP_NAME, 0, "key" },
2203 : /* 15 */ { A1_OP_NAME, 0, "crealm" },
2204 : /* 16 */ { A1_OP_NAME, 0, "cname" },
2205 : /* 17 */ { A1_OP_NAME, 0, "transited" },
2206 : /* 18 */ { A1_OP_NAME, 0, "authtime" },
2207 : /* 19 */ { A1_OP_NAME, 0, "starttime" },
2208 : /* 20 */ { A1_OP_NAME, 0, "endtime" },
2209 : /* 21 */ { A1_OP_NAME, 0, "renew-till" },
2210 : /* 22 */ { A1_OP_NAME, 0, "caddr" },
2211 : /* 23 */ { A1_OP_NAME, 0, "authorization-data" }
2212 : };
2213 : /* generate_template_type: EncTicketPart_tag__53 */
2214 : const struct asn1_template asn1_EncTicketPart_tag__53[] = {
2215 : /* 0 */ { 0, sizeof(struct EncTicketPart), ((void *)(uintptr_t)1) },
2216 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_EncTicketPart_tag__54 }
2217 : };
2218 : /* generate_template_type: EncTicketPart */
2219 : const struct asn1_template asn1_EncTicketPart[] = {
2220 : /* 0 */ { 0, sizeof(EncTicketPart), ((void *)(uintptr_t)1) },
2221 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,3), 0, asn1_EncTicketPart_tag__53 }
2222 : };
2223 :
2224 : int ASN1CALL
2225 56781 : decode_EncTicketPart(const unsigned char *p, size_t len, EncTicketPart *data, size_t *size)
2226 : {
2227 56781 : memset(data, 0, sizeof(*data));
2228 56781 : return _asn1_decode_top(asn1_EncTicketPart, 0|0, p, len, data, size);
2229 : }
2230 :
2231 :
2232 : int ASN1CALL
2233 68837 : encode_EncTicketPart(unsigned char *p, size_t len, const EncTicketPart *data, size_t *size)
2234 : {
2235 68837 : return _asn1_encode(asn1_EncTicketPart, p, len, data, size);
2236 : }
2237 :
2238 :
2239 : size_t ASN1CALL
2240 68837 : length_EncTicketPart(const EncTicketPart *data)
2241 : {
2242 68837 : return _asn1_length(asn1_EncTicketPart, data);
2243 : }
2244 :
2245 :
2246 : void ASN1CALL
2247 145993 : free_EncTicketPart(EncTicketPart *data)
2248 : {
2249 145993 : _asn1_free_top(asn1_EncTicketPart, data);
2250 145993 : }
2251 :
2252 :
2253 : int ASN1CALL
2254 76084 : copy_EncTicketPart(const EncTicketPart *from, EncTicketPart *to)
2255 : {
2256 76084 : return _asn1_copy_top(asn1_EncTicketPart, from, to);
2257 : }
2258 :
2259 :
2260 : char * ASN1CALL
2261 0 : print_EncTicketPart(const EncTicketPart *data, int flags)
2262 : {
2263 0 : return _asn1_print_top(asn1_EncTicketPart, flags, data);
2264 : }
2265 :
2266 : /* template_members: Checksum exp exp */
2267 : /* tsequence: members isstruct: 1 */
2268 : /* template_members: Checksum exp exp */
2269 : /* generate_template_type: Checksum_tag_cksumtype_67 */
2270 : const struct asn1_template asn1_Checksum_tag_cksumtype_67[] = {
2271 : /* 0 */ { 0, sizeof(CKSUMTYPE), ((void *)(uintptr_t)1) },
2272 : /* 1 */ { A1_OP_TYPE , 0, asn1_CKSUMTYPE }
2273 : };
2274 : /* template_members: Checksum exp exp */
2275 : /* template_members: heim_octet_string exp exp */
2276 : /* generate_template_type: heim_octet_string_tag_checksum_69 */
2277 : /* generate_template_type: Checksum_tag_checksum_68 */
2278 : /* generate_template_type: Checksum_tag__66 */
2279 : const struct asn1_template asn1_Checksum_tag__66[] = {
2280 : /* 0 */ { 0, sizeof(struct Checksum), ((void *)(uintptr_t)5) },
2281 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct Checksum, cksumtype), asn1_Checksum_tag_cksumtype_67 },
2282 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct Checksum, checksum), asn1_HostAddress_tag_address_17 },
2283 : /* 3 */ { A1_OP_NAME, 0, "Checksum" },
2284 : /* 4 */ { A1_OP_NAME, 0, "cksumtype" },
2285 : /* 5 */ { A1_OP_NAME, 0, "checksum" }
2286 : };
2287 : /* generate_template_type: Checksum */
2288 : const struct asn1_template asn1_Checksum[] = {
2289 : /* 0 */ { 0, sizeof(Checksum), ((void *)(uintptr_t)1) },
2290 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_Checksum_tag__66 }
2291 : };
2292 :
2293 : int ASN1CALL
2294 9228 : decode_Checksum(const unsigned char *p, size_t len, Checksum *data, size_t *size)
2295 : {
2296 9228 : memset(data, 0, sizeof(*data));
2297 9228 : return _asn1_decode_top(asn1_Checksum, 0|0, p, len, data, size);
2298 : }
2299 :
2300 :
2301 : int ASN1CALL
2302 17041 : encode_Checksum(unsigned char *p, size_t len, const Checksum *data, size_t *size)
2303 : {
2304 17041 : return _asn1_encode(asn1_Checksum, p, len, data, size);
2305 : }
2306 :
2307 :
2308 : size_t ASN1CALL
2309 17041 : length_Checksum(const Checksum *data)
2310 : {
2311 17041 : return _asn1_length(asn1_Checksum, data);
2312 : }
2313 :
2314 :
2315 : void ASN1CALL
2316 1201963 : free_Checksum(Checksum *data)
2317 : {
2318 1201963 : _asn1_free_top(asn1_Checksum, data);
2319 1201963 : }
2320 :
2321 :
2322 : int ASN1CALL
2323 60525 : copy_Checksum(const Checksum *from, Checksum *to)
2324 : {
2325 60525 : return _asn1_copy_top(asn1_Checksum, from, to);
2326 : }
2327 :
2328 :
2329 : char * ASN1CALL
2330 0 : print_Checksum(const Checksum *data, int flags)
2331 : {
2332 0 : return _asn1_print_top(asn1_Checksum, flags, data);
2333 : }
2334 :
2335 : /* template_members: EncKDCRepPart exp exp */
2336 : /* tsequence: members isstruct: 1 */
2337 : /* template_members: EncKDCRepPart exp exp */
2338 : /* generate_template_type: EncKDCRepPart_tag_key_71 */
2339 : /* template_members: EncKDCRepPart exp exp */
2340 : /* generate_template_type: EncKDCRepPart_tag_last_req_72 */
2341 : const struct asn1_template asn1_EncKDCRepPart_tag_last_req_72[] = {
2342 : /* 0 */ { 0, sizeof(LastReq), ((void *)(uintptr_t)1) },
2343 : /* 1 */ { A1_OP_TYPE , 0, asn1_LastReq }
2344 : };
2345 : /* template_members: EncKDCRepPart exp exp */
2346 : /* generate_template_type: EncKDCRepPart_tag_nonce_73 */
2347 : /* template_members: EncKDCRepPart exp exp */
2348 : /* generate_template_type: EncKDCRepPart_tag_key_expiration_74 */
2349 : /* template_members: EncKDCRepPart exp exp */
2350 : /* generate_template_type: EncKDCRepPart_tag_flags_75 */
2351 : /* template_members: EncKDCRepPart exp exp */
2352 : /* generate_template_type: EncKDCRepPart_tag_authtime_76 */
2353 : /* template_members: EncKDCRepPart exp exp */
2354 : /* generate_template_type: EncKDCRepPart_tag_starttime_77 */
2355 : /* template_members: EncKDCRepPart exp exp */
2356 : /* generate_template_type: EncKDCRepPart_tag_endtime_78 */
2357 : /* template_members: EncKDCRepPart exp exp */
2358 : /* generate_template_type: EncKDCRepPart_tag_renew_till_79 */
2359 : /* template_members: EncKDCRepPart exp exp */
2360 : /* generate_template_type: EncKDCRepPart_tag_srealm_80 */
2361 : /* template_members: EncKDCRepPart exp exp */
2362 : /* generate_template_type: EncKDCRepPart_tag_sname_81 */
2363 : /* template_members: EncKDCRepPart exp exp */
2364 : /* generate_template_type: EncKDCRepPart_tag_caddr_82 */
2365 : /* template_members: EncKDCRepPart exp exp */
2366 : /* generate_template_type: EncKDCRepPart_tag_encrypted_pa_data_83 */
2367 : const struct asn1_template asn1_EncKDCRepPart_tag_encrypted_pa_data_83[] = {
2368 : /* 0 */ { 0, sizeof(METHOD_DATA), ((void *)(uintptr_t)1) },
2369 : /* 1 */ { A1_OP_TYPE , 0, asn1_METHOD_DATA }
2370 : };
2371 : /* generate_template_type: EncKDCRepPart_tag__70 */
2372 : const struct asn1_template asn1_EncKDCRepPart_tag__70[] = {
2373 : /* 0 */ { 0, sizeof(struct EncKDCRepPart), ((void *)(uintptr_t)27) },
2374 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct EncKDCRepPart, key), asn1_EncTicketPart_tag_key_56 },
2375 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct EncKDCRepPart, last_req), asn1_EncKDCRepPart_tag_last_req_72 },
2376 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct EncKDCRepPart, nonce), asn1_HostAddress_tag_addr_type_16 },
2377 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct EncKDCRepPart, key_expiration), asn1_LastReq_val_tag_lr_value_33 },
2378 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct EncKDCRepPart, flags), asn1_EncTicketPart_tag_flags_55 },
2379 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5), offsetof(struct EncKDCRepPart, authtime), asn1_LastReq_val_tag_lr_value_33 },
2380 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6)|A1_FLAG_OPTIONAL, offsetof(struct EncKDCRepPart, starttime), asn1_LastReq_val_tag_lr_value_33 },
2381 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7), offsetof(struct EncKDCRepPart, endtime), asn1_LastReq_val_tag_lr_value_33 },
2382 : /* 9 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,8)|A1_FLAG_OPTIONAL, offsetof(struct EncKDCRepPart, renew_till), asn1_LastReq_val_tag_lr_value_33 },
2383 : /* 10 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,9), offsetof(struct EncKDCRepPart, srealm), asn1_Ticket_tag_realm_50 },
2384 : /* 11 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,10), offsetof(struct EncKDCRepPart, sname), asn1_Ticket_tag_sname_51 },
2385 : /* 12 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,11)|A1_FLAG_OPTIONAL, offsetof(struct EncKDCRepPart, caddr), asn1_EncTicketPart_tag_caddr_64 },
2386 : /* 13 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,12)|A1_FLAG_OPTIONAL, offsetof(struct EncKDCRepPart, encrypted_pa_data), asn1_EncKDCRepPart_tag_encrypted_pa_data_83 },
2387 : /* 14 */ { A1_OP_NAME, 0, "EncKDCRepPart" },
2388 : /* 15 */ { A1_OP_NAME, 0, "key" },
2389 : /* 16 */ { A1_OP_NAME, 0, "last-req" },
2390 : /* 17 */ { A1_OP_NAME, 0, "nonce" },
2391 : /* 18 */ { A1_OP_NAME, 0, "key-expiration" },
2392 : /* 19 */ { A1_OP_NAME, 0, "flags" },
2393 : /* 20 */ { A1_OP_NAME, 0, "authtime" },
2394 : /* 21 */ { A1_OP_NAME, 0, "starttime" },
2395 : /* 22 */ { A1_OP_NAME, 0, "endtime" },
2396 : /* 23 */ { A1_OP_NAME, 0, "renew-till" },
2397 : /* 24 */ { A1_OP_NAME, 0, "srealm" },
2398 : /* 25 */ { A1_OP_NAME, 0, "sname" },
2399 : /* 26 */ { A1_OP_NAME, 0, "caddr" },
2400 : /* 27 */ { A1_OP_NAME, 0, "encrypted-pa-data" }
2401 : };
2402 : /* generate_template_type: EncKDCRepPart */
2403 : const struct asn1_template asn1_EncKDCRepPart[] = {
2404 : /* 0 */ { 0, sizeof(EncKDCRepPart), ((void *)(uintptr_t)1) },
2405 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_EncKDCRepPart_tag__70 }
2406 : };
2407 :
2408 : int ASN1CALL
2409 0 : decode_EncKDCRepPart(const unsigned char *p, size_t len, EncKDCRepPart *data, size_t *size)
2410 : {
2411 0 : memset(data, 0, sizeof(*data));
2412 0 : return _asn1_decode_top(asn1_EncKDCRepPart, 0|0, p, len, data, size);
2413 : }
2414 :
2415 :
2416 : int ASN1CALL
2417 0 : encode_EncKDCRepPart(unsigned char *p, size_t len, const EncKDCRepPart *data, size_t *size)
2418 : {
2419 0 : return _asn1_encode(asn1_EncKDCRepPart, p, len, data, size);
2420 : }
2421 :
2422 :
2423 : size_t ASN1CALL
2424 0 : length_EncKDCRepPart(const EncKDCRepPart *data)
2425 : {
2426 0 : return _asn1_length(asn1_EncKDCRepPart, data);
2427 : }
2428 :
2429 :
2430 : void ASN1CALL
2431 42936 : free_EncKDCRepPart(EncKDCRepPart *data)
2432 : {
2433 42936 : _asn1_free_top(asn1_EncKDCRepPart, data);
2434 42936 : }
2435 :
2436 :
2437 : int ASN1CALL
2438 52820 : copy_EncKDCRepPart(const EncKDCRepPart *from, EncKDCRepPart *to)
2439 : {
2440 52820 : return _asn1_copy_top(asn1_EncKDCRepPart, from, to);
2441 : }
2442 :
2443 :
2444 : char * ASN1CALL
2445 0 : print_EncKDCRepPart(const EncKDCRepPart *data, int flags)
2446 : {
2447 0 : return _asn1_print_top(asn1_EncKDCRepPart, flags, data);
2448 : }
2449 :
2450 : /* template_members: EncKDCRepPart exp exp */
2451 : /* generate_template_type: EncKDCRepPart_tag__84 */
2452 : const struct asn1_template asn1_EncKDCRepPart_tag__84[] = {
2453 : /* 0 */ { 0, sizeof(EncKDCRepPart), ((void *)(uintptr_t)1) },
2454 : /* 1 */ { A1_OP_TYPE , 0, asn1_EncKDCRepPart }
2455 : };
2456 : /* generate_template_type: PrincipalNameAttrSrc_choice_enc_kdc_rep_part */
2457 : const struct asn1_template asn1_PrincipalNameAttrSrc_choice_enc_kdc_rep_part[] = {
2458 : /* 0 */ { 0, sizeof(EncKDCRepPart), ((void *)(uintptr_t)1) },
2459 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), 0, asn1_EncKDCRepPart_tag__84 }
2460 : };
2461 : /* template_members: EncTicketPart exp exp */
2462 : /* generate_template_type: EncTicketPart_tag__85 */
2463 : const struct asn1_template asn1_EncTicketPart_tag__85[] = {
2464 : /* 0 */ { 0, sizeof(EncTicketPart), ((void *)(uintptr_t)1) },
2465 : /* 1 */ { A1_OP_TYPE , 0, asn1_EncTicketPart }
2466 : };
2467 : /* generate_template_type: PrincipalNameAttrSrc_choice_enc_ticket_part */
2468 : const struct asn1_template asn1_PrincipalNameAttrSrc_choice_enc_ticket_part[] = {
2469 : /* 0 */ { 0, sizeof(EncTicketPart), ((void *)(uintptr_t)1) },
2470 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), 0, asn1_EncTicketPart_tag__85 }
2471 : };
2472 : static const struct asn1_template asn1_choice_PrincipalNameAttrSrc_0[] = {
2473 : /* 0 */ { 0, offsetof(PrincipalNameAttrSrc, element), ((void *)(uintptr_t)4) },
2474 : /* 1 */ { choice_PrincipalNameAttrSrc_enc_kdc_rep_part, offsetof(PrincipalNameAttrSrc, u.enc_kdc_rep_part), asn1_PrincipalNameAttrSrc_choice_enc_kdc_rep_part },
2475 : /* 2 */ { choice_PrincipalNameAttrSrc_enc_ticket_part, offsetof(PrincipalNameAttrSrc, u.enc_ticket_part), asn1_PrincipalNameAttrSrc_choice_enc_ticket_part },
2476 : /* 3 */ { 0, 0, "enc-kdc-rep-part" },
2477 : /* 4 */ { 0, 0, "enc-ticket-part" }
2478 : };
2479 : /* generate_template_type: PrincipalNameAttrSrc */
2480 : const struct asn1_template asn1_PrincipalNameAttrSrc[] = {
2481 : /* 0 */ { 0, sizeof(PrincipalNameAttrSrc), ((void *)(uintptr_t)1) },
2482 : /* 1 */ { A1_OP_CHOICE, 0, asn1_choice_PrincipalNameAttrSrc_0 }
2483 : };
2484 :
2485 : int ASN1CALL
2486 0 : decode_PrincipalNameAttrSrc(const unsigned char *p, size_t len, PrincipalNameAttrSrc *data, size_t *size)
2487 : {
2488 0 : memset(data, 0, sizeof(*data));
2489 0 : return _asn1_decode_top(asn1_PrincipalNameAttrSrc, 0|0, p, len, data, size);
2490 : }
2491 :
2492 :
2493 : int ASN1CALL
2494 0 : encode_PrincipalNameAttrSrc(unsigned char *p, size_t len, const PrincipalNameAttrSrc *data, size_t *size)
2495 : {
2496 0 : return _asn1_encode(asn1_PrincipalNameAttrSrc, p, len, data, size);
2497 : }
2498 :
2499 :
2500 : size_t ASN1CALL
2501 0 : length_PrincipalNameAttrSrc(const PrincipalNameAttrSrc *data)
2502 : {
2503 0 : return _asn1_length(asn1_PrincipalNameAttrSrc, data);
2504 : }
2505 :
2506 :
2507 : void ASN1CALL
2508 0 : free_PrincipalNameAttrSrc(PrincipalNameAttrSrc *data)
2509 : {
2510 0 : _asn1_free_top(asn1_PrincipalNameAttrSrc, data);
2511 0 : }
2512 :
2513 :
2514 : int ASN1CALL
2515 0 : copy_PrincipalNameAttrSrc(const PrincipalNameAttrSrc *from, PrincipalNameAttrSrc *to)
2516 : {
2517 0 : return _asn1_copy_top(asn1_PrincipalNameAttrSrc, from, to);
2518 : }
2519 :
2520 :
2521 : char * ASN1CALL
2522 0 : print_PrincipalNameAttrSrc(const PrincipalNameAttrSrc *data, int flags)
2523 : {
2524 0 : return _asn1_print_top(asn1_PrincipalNameAttrSrc, flags, data);
2525 : }
2526 :
2527 : static const struct asn1_type_func asn1_extern_PrincipalNameAttrs_pac = {
2528 : (asn1_type_encode)0,
2529 : (asn1_type_decode)0,
2530 : (asn1_type_length)0,
2531 : (asn1_type_copy)0,
2532 : (asn1_type_release)0,
2533 : (asn1_type_print)0,
2534 : sizeof(void *)
2535 : };
2536 : /* template_members: PrincipalNameAttrs exp exp */
2537 : /* tsequence: members isstruct: 1 */
2538 : /* template_members: PrincipalNameAttrs exp exp */
2539 : /* template_members: int exp exp */
2540 : /* generate_template_type: int_tag_authenticated_88 */
2541 : const struct asn1_template asn1_int_tag_authenticated_88[] = {
2542 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
2543 : /* 1 */ { A1_PARSE_T(A1T_BOOLEAN), 0, NULL }
2544 : };
2545 : /* generate_template_type: PrincipalNameAttrs_tag_authenticated_87 */
2546 : const struct asn1_template asn1_PrincipalNameAttrs_tag_authenticated_87[] = {
2547 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
2548 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Boolean), 0, asn1_int_tag_authenticated_88 }
2549 : };
2550 : /* template_members: PrincipalNameAttrs exp exp */
2551 : /* generate_template_type: PrincipalNameAttrs_tag_source_89 */
2552 : const struct asn1_template asn1_PrincipalNameAttrs_tag_source_89[] = {
2553 : /* 0 */ { 0, sizeof(PrincipalNameAttrSrc), ((void *)(uintptr_t)1) },
2554 : /* 1 */ { A1_OP_TYPE , 0, asn1_PrincipalNameAttrSrc }
2555 : };
2556 : /* template_members: PrincipalNameAttrs exp exp */
2557 : /* generate_template_type: PrincipalNameAttrs_tag_authenticator_ad_90 */
2558 : /* template_members: PrincipalNameAttrs exp exp */
2559 : /* generate_template_type: PrincipalNameAttrs_tag_peer_realm_91 */
2560 : /* template_members: PrincipalNameAttrs exp exp */
2561 : /* generate_template_type: PrincipalNameAttrs_tag_transited_92 */
2562 : /* template_members: PrincipalNameAttrs exp exp */
2563 : /* template_members: int exp exp */
2564 : /* generate_template_type: int_tag_pac_verified_94 */
2565 : /* generate_template_type: PrincipalNameAttrs_tag_pac_verified_93 */
2566 : /* template_members: PrincipalNameAttrs exp exp */
2567 : /* template_members: int exp exp */
2568 : /* generate_template_type: int_tag_kdc_issued_verified_96 */
2569 : /* generate_template_type: PrincipalNameAttrs_tag_kdc_issued_verified_95 */
2570 : /* template_members: PrincipalNameAttrs exp exp */
2571 : /* generate_template_type: PrincipalNameAttrs_tag_want_ad_97 */
2572 : /* generate_template_type: PrincipalNameAttrs_tag__86 */
2573 : const struct asn1_template asn1_PrincipalNameAttrs_tag__86[] = {
2574 : /* 0 */ { 0, sizeof(struct PrincipalNameAttrs), ((void *)(uintptr_t)18) },
2575 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PrincipalNameAttrs, authenticated), asn1_PrincipalNameAttrs_tag_authenticated_87 },
2576 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct PrincipalNameAttrs, source), asn1_PrincipalNameAttrs_tag_source_89 },
2577 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct PrincipalNameAttrs, authenticator_ad), asn1_EncTicketPart_tag_authorization_data_65 },
2578 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct PrincipalNameAttrs, peer_realm), asn1_Ticket_tag_realm_50 },
2579 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct PrincipalNameAttrs, transited), asn1_EncTicketPart_tag_transited_59 },
2580 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5), offsetof(struct PrincipalNameAttrs, pac_verified), asn1_PrincipalNameAttrs_tag_authenticated_87 },
2581 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6), offsetof(struct PrincipalNameAttrs, kdc_issued_verified), asn1_PrincipalNameAttrs_tag_authenticated_87 },
2582 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7)|A1_FLAG_OPTIONAL, offsetof(struct PrincipalNameAttrs, want_ad), asn1_EncTicketPart_tag_authorization_data_65 },
2583 : /* 9 */ { A1_OP_TYPE_DECORATE_EXTERN , offsetof(struct PrincipalNameAttrs, pac), &asn1_extern_PrincipalNameAttrs_pac },
2584 : /* 10 */ { A1_OP_NAME, 0, "PrincipalNameAttrs" },
2585 : /* 11 */ { A1_OP_NAME, 0, "authenticated" },
2586 : /* 12 */ { A1_OP_NAME, 0, "source" },
2587 : /* 13 */ { A1_OP_NAME, 0, "authenticator-ad" },
2588 : /* 14 */ { A1_OP_NAME, 0, "peer-realm" },
2589 : /* 15 */ { A1_OP_NAME, 0, "transited" },
2590 : /* 16 */ { A1_OP_NAME, 0, "pac-verified" },
2591 : /* 17 */ { A1_OP_NAME, 0, "kdc-issued-verified" },
2592 : /* 18 */ { A1_OP_NAME, 0, "want-ad" }
2593 : };
2594 : /* generate_template_type: PrincipalNameAttrs */
2595 : const struct asn1_template asn1_PrincipalNameAttrs[] = {
2596 : /* 0 */ { 0, sizeof(PrincipalNameAttrs), ((void *)(uintptr_t)1) },
2597 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PrincipalNameAttrs_tag__86 }
2598 : };
2599 :
2600 : int ASN1CALL
2601 0 : decode_PrincipalNameAttrs(const unsigned char *p, size_t len, PrincipalNameAttrs *data, size_t *size)
2602 : {
2603 0 : memset(data, 0, sizeof(*data));
2604 0 : return _asn1_decode_top(asn1_PrincipalNameAttrs, 0|0, p, len, data, size);
2605 : }
2606 :
2607 :
2608 : int ASN1CALL
2609 0 : encode_PrincipalNameAttrs(unsigned char *p, size_t len, const PrincipalNameAttrs *data, size_t *size)
2610 : {
2611 0 : return _asn1_encode(asn1_PrincipalNameAttrs, p, len, data, size);
2612 : }
2613 :
2614 :
2615 : size_t ASN1CALL
2616 0 : length_PrincipalNameAttrs(const PrincipalNameAttrs *data)
2617 : {
2618 0 : return _asn1_length(asn1_PrincipalNameAttrs, data);
2619 : }
2620 :
2621 :
2622 : void ASN1CALL
2623 0 : free_PrincipalNameAttrs(PrincipalNameAttrs *data)
2624 : {
2625 0 : _asn1_free_top(asn1_PrincipalNameAttrs, data);
2626 0 : }
2627 :
2628 :
2629 : int ASN1CALL
2630 0 : copy_PrincipalNameAttrs(const PrincipalNameAttrs *from, PrincipalNameAttrs *to)
2631 : {
2632 0 : return _asn1_copy_top(asn1_PrincipalNameAttrs, from, to);
2633 : }
2634 :
2635 :
2636 : char * ASN1CALL
2637 0 : print_PrincipalNameAttrs(const PrincipalNameAttrs *data, int flags)
2638 : {
2639 0 : return _asn1_print_top(asn1_PrincipalNameAttrs, flags, data);
2640 : }
2641 :
2642 : /* template_members: CompositePrincipal exp exp */
2643 : /* template_members: CompositePrincipal exp exp */
2644 : /* tsequence: members isstruct: 1 */
2645 : /* template_members: CompositePrincipal exp exp */
2646 : /* generate_template_type: CompositePrincipal_tag_name_100 */
2647 : /* template_members: CompositePrincipal exp exp */
2648 : /* generate_template_type: CompositePrincipal_tag_realm_101 */
2649 : /* template_members: CompositePrincipal exp exp */
2650 : /* generate_template_type: CompositePrincipal_tag_nameattrs_102 */
2651 : const struct asn1_template asn1_CompositePrincipal_tag_nameattrs_102[] = {
2652 : /* 0 */ { 0, sizeof(PrincipalNameAttrs), ((void *)(uintptr_t)1) },
2653 : /* 1 */ { A1_OP_TYPE , 0, asn1_PrincipalNameAttrs }
2654 : };
2655 : /* generate_template_type: CompositePrincipal_tag__99 */
2656 : const struct asn1_template asn1_CompositePrincipal_tag__99[] = {
2657 : /* 0 */ { 0, sizeof(struct CompositePrincipal), ((void *)(uintptr_t)7) },
2658 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct CompositePrincipal, name), asn1_Ticket_tag_sname_51 },
2659 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct CompositePrincipal, realm), asn1_Ticket_tag_realm_50 },
2660 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct CompositePrincipal, nameattrs), asn1_CompositePrincipal_tag_nameattrs_102 },
2661 : /* 4 */ { A1_OP_NAME, 0, "CompositePrincipal" },
2662 : /* 5 */ { A1_OP_NAME, 0, "name" },
2663 : /* 6 */ { A1_OP_NAME, 0, "realm" },
2664 : /* 7 */ { A1_OP_NAME, 0, "nameattrs" }
2665 : };
2666 : /* generate_template_type: CompositePrincipal_tag__98 */
2667 : const struct asn1_template asn1_CompositePrincipal_tag__98[] = {
2668 : /* 0 */ { 0, sizeof(struct CompositePrincipal), ((void *)(uintptr_t)1) },
2669 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_CompositePrincipal_tag__99 }
2670 : };
2671 : /* generate_template_type: CompositePrincipal */
2672 : const struct asn1_template asn1_CompositePrincipal[] = {
2673 : /* 0 */ { 0, sizeof(CompositePrincipal), ((void *)(uintptr_t)1) },
2674 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,48), 0, asn1_CompositePrincipal_tag__98 }
2675 : };
2676 :
2677 : int ASN1CALL
2678 0 : decode_CompositePrincipal(const unsigned char *p, size_t len, CompositePrincipal *data, size_t *size)
2679 : {
2680 0 : memset(data, 0, sizeof(*data));
2681 0 : return _asn1_decode_top(asn1_CompositePrincipal, 0|0, p, len, data, size);
2682 : }
2683 :
2684 :
2685 : int ASN1CALL
2686 0 : encode_CompositePrincipal(unsigned char *p, size_t len, const CompositePrincipal *data, size_t *size)
2687 : {
2688 0 : return _asn1_encode(asn1_CompositePrincipal, p, len, data, size);
2689 : }
2690 :
2691 :
2692 : size_t ASN1CALL
2693 0 : length_CompositePrincipal(const CompositePrincipal *data)
2694 : {
2695 0 : return _asn1_length(asn1_CompositePrincipal, data);
2696 : }
2697 :
2698 :
2699 : void ASN1CALL
2700 0 : free_CompositePrincipal(CompositePrincipal *data)
2701 : {
2702 0 : _asn1_free_top(asn1_CompositePrincipal, data);
2703 0 : }
2704 :
2705 :
2706 : int ASN1CALL
2707 0 : copy_CompositePrincipal(const CompositePrincipal *from, CompositePrincipal *to)
2708 : {
2709 0 : return _asn1_copy_top(asn1_CompositePrincipal, from, to);
2710 : }
2711 :
2712 :
2713 : char * ASN1CALL
2714 0 : print_CompositePrincipal(const CompositePrincipal *data, int flags)
2715 : {
2716 0 : return _asn1_print_top(asn1_CompositePrincipal, flags, data);
2717 : }
2718 :
2719 : /* template_members: Principal exp exp */
2720 : /* tsequence: members isstruct: 1 */
2721 : /* template_members: Principal exp exp */
2722 : /* generate_template_type: Principal_tag_name_104 */
2723 : /* template_members: Principal exp exp */
2724 : /* generate_template_type: Principal_tag_realm_105 */
2725 : /* generate_template_type: Principal_tag__103 */
2726 : const struct asn1_template asn1_Principal_tag__103[] = {
2727 : /* 0 */ { 0, sizeof(struct Principal), ((void *)(uintptr_t)6) },
2728 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct Principal, name), asn1_Ticket_tag_sname_51 },
2729 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct Principal, realm), asn1_Ticket_tag_realm_50 },
2730 : /* 3 */ { A1_OP_TYPE_DECORATE |A1_FLAG_OPTIONAL, offsetof(struct Principal, nameattrs), asn1_PrincipalNameAttrs },
2731 : /* 4 */ { A1_OP_NAME, 0, "Principal" },
2732 : /* 5 */ { A1_OP_NAME, 0, "name" },
2733 : /* 6 */ { A1_OP_NAME, 0, "realm" }
2734 : };
2735 : /* generate_template_type: Principal */
2736 : const struct asn1_template asn1_Principal[] = {
2737 : /* 0 */ { 0, sizeof(Principal), ((void *)(uintptr_t)1) },
2738 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_Principal_tag__103 }
2739 : };
2740 :
2741 : int ASN1CALL
2742 0 : decode_Principal(const unsigned char *p, size_t len, Principal *data, size_t *size)
2743 : {
2744 0 : memset(data, 0, sizeof(*data));
2745 0 : return _asn1_decode_top(asn1_Principal, 0|0, p, len, data, size);
2746 : }
2747 :
2748 :
2749 : int ASN1CALL
2750 0 : encode_Principal(unsigned char *p, size_t len, const Principal *data, size_t *size)
2751 : {
2752 0 : return _asn1_encode(asn1_Principal, p, len, data, size);
2753 : }
2754 :
2755 :
2756 : size_t ASN1CALL
2757 0 : length_Principal(const Principal *data)
2758 : {
2759 0 : return _asn1_length(asn1_Principal, data);
2760 : }
2761 :
2762 :
2763 : void ASN1CALL
2764 4596570 : free_Principal(Principal *data)
2765 : {
2766 4596570 : _asn1_free_top(asn1_Principal, data);
2767 4596570 : }
2768 :
2769 :
2770 : int ASN1CALL
2771 3192432 : copy_Principal(const Principal *from, Principal *to)
2772 : {
2773 3192432 : return _asn1_copy_top(asn1_Principal, from, to);
2774 : }
2775 :
2776 :
2777 : char * ASN1CALL
2778 0 : print_Principal(const Principal *data, int flags)
2779 : {
2780 0 : return _asn1_print_top(asn1_Principal, flags, data);
2781 : }
2782 :
2783 : /* template_members: Principals exp exp */
2784 : /* generate_template_type: Principal_seofTstruct_4 */
2785 : const struct asn1_template asn1_Principal_seofTstruct_4[] = {
2786 : /* 0 */ { 0, sizeof(Principal), ((void *)(uintptr_t)1) },
2787 : /* 1 */ { A1_OP_TYPE , 0, asn1_Principal }
2788 : };
2789 : /* generate_template_type: Principals_tag__106 */
2790 : const struct asn1_template asn1_Principals_tag__106[] = {
2791 : /* 0 */ { 0, sizeof(Principal), ((void *)(uintptr_t)1) },
2792 : /* 1 */ { A1_OP_SEQOF, 0, asn1_Principal_seofTstruct_4 }
2793 : };
2794 : /* generate_template_type: Principals */
2795 : const struct asn1_template asn1_Principals[] = {
2796 : /* 0 */ { 0, sizeof(Principals), ((void *)(uintptr_t)1) },
2797 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_Principals_tag__106 }
2798 : };
2799 :
2800 : int ASN1CALL
2801 0 : decode_Principals(const unsigned char *p, size_t len, Principals *data, size_t *size)
2802 : {
2803 0 : memset(data, 0, sizeof(*data));
2804 0 : return _asn1_decode_top(asn1_Principals, 0|0, p, len, data, size);
2805 : }
2806 :
2807 :
2808 : int ASN1CALL
2809 0 : encode_Principals(unsigned char *p, size_t len, const Principals *data, size_t *size)
2810 : {
2811 0 : return _asn1_encode(asn1_Principals, p, len, data, size);
2812 : }
2813 :
2814 :
2815 : size_t ASN1CALL
2816 0 : length_Principals(const Principals *data)
2817 : {
2818 0 : return _asn1_length(asn1_Principals, data);
2819 : }
2820 :
2821 :
2822 : void ASN1CALL
2823 0 : free_Principals(Principals *data)
2824 : {
2825 0 : _asn1_free_top(asn1_Principals, data);
2826 0 : }
2827 :
2828 :
2829 : int ASN1CALL
2830 0 : copy_Principals(const Principals *from, Principals *to)
2831 : {
2832 0 : return _asn1_copy_top(asn1_Principals, from, to);
2833 : }
2834 :
2835 :
2836 : char * ASN1CALL
2837 0 : print_Principals(const Principals *data, int flags)
2838 : {
2839 0 : return _asn1_print_top(asn1_Principals, flags, data);
2840 : }
2841 :
2842 : int ASN1CALL
2843 0 : add_Principals(Principals *data, const Principal *element)
2844 : {
2845 : int ret;
2846 : void *ptr;
2847 :
2848 0 : ptr = realloc(data->val,
2849 0 : (data->len + 1) * sizeof(data->val[0]));
2850 0 : if (ptr == NULL) return ENOMEM;
2851 0 : data->val = ptr;
2852 :
2853 0 : ret = copy_Principal(element, &data->val[data->len]);
2854 0 : if (ret) return ret;
2855 0 : data->len++;
2856 0 : return 0;
2857 : }
2858 :
2859 : int ASN1CALL
2860 0 : remove_Principals(Principals *data, unsigned int element)
2861 : {
2862 : void *ptr;
2863 :
2864 0 : if (data->len == 0 || element >= data->len)
2865 0 : return ASN1_OVERRUN;
2866 0 : free_Principal(&data->val[element]);
2867 0 : data->len--;
2868 0 : if (element < data->len)
2869 0 : memmove(&data->val[element], &data->val[element + 1],
2870 0 : sizeof(data->val[0]) * (data->len - element));
2871 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
2872 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
2873 0 : return 0;
2874 : }
2875 :
2876 : /* template_members: Authenticator exp exp */
2877 : /* template_members: Authenticator exp exp */
2878 : /* tsequence: members isstruct: 1 */
2879 : /* template_members: Authenticator exp exp */
2880 : /* generate_template_type: Authenticator_tag_authenticator_vno_109 */
2881 : /* template_members: Authenticator exp exp */
2882 : /* generate_template_type: Authenticator_tag_crealm_110 */
2883 : /* template_members: Authenticator exp exp */
2884 : /* generate_template_type: Authenticator_tag_cname_111 */
2885 : /* template_members: Authenticator exp exp */
2886 : /* generate_template_type: Authenticator_tag_cksum_112 */
2887 : const struct asn1_template asn1_Authenticator_tag_cksum_112[] = {
2888 : /* 0 */ { 0, sizeof(Checksum), ((void *)(uintptr_t)1) },
2889 : /* 1 */ { A1_OP_TYPE , 0, asn1_Checksum }
2890 : };
2891 : /* template_members: Authenticator exp exp */
2892 : /* generate_template_type: Authenticator_tag_cusec_113 */
2893 : /* template_members: Authenticator exp exp */
2894 : /* generate_template_type: Authenticator_tag_ctime_114 */
2895 : /* template_members: Authenticator exp exp */
2896 : /* generate_template_type: Authenticator_tag_subkey_115 */
2897 : /* template_members: Authenticator exp exp */
2898 : /* generate_template_type: Authenticator_tag_seq_number_116 */
2899 : const struct asn1_template asn1_Authenticator_tag_seq_number_116[] = {
2900 : /* 0 */ { 0, sizeof(Krb5UInt32), ((void *)(uintptr_t)1) },
2901 : /* 1 */ { A1_OP_TYPE , 0, asn1_Krb5UInt32 }
2902 : };
2903 : /* template_members: Authenticator exp exp */
2904 : /* generate_template_type: Authenticator_tag_authorization_data_117 */
2905 : /* generate_template_type: Authenticator_tag__108 */
2906 : const struct asn1_template asn1_Authenticator_tag__108[] = {
2907 : /* 0 */ { 0, sizeof(struct Authenticator), ((void *)(uintptr_t)19) },
2908 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct Authenticator, authenticator_vno), asn1_HostAddress_tag_addr_type_16 },
2909 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct Authenticator, crealm), asn1_Ticket_tag_realm_50 },
2910 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct Authenticator, cname), asn1_Ticket_tag_sname_51 },
2911 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct Authenticator, cksum), asn1_Authenticator_tag_cksum_112 },
2912 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct Authenticator, cusec), asn1_HostAddress_tag_addr_type_16 },
2913 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5), offsetof(struct Authenticator, ctime), asn1_LastReq_val_tag_lr_value_33 },
2914 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6)|A1_FLAG_OPTIONAL, offsetof(struct Authenticator, subkey), asn1_EncTicketPart_tag_key_56 },
2915 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7)|A1_FLAG_OPTIONAL, offsetof(struct Authenticator, seq_number), asn1_Authenticator_tag_seq_number_116 },
2916 : /* 9 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,8)|A1_FLAG_OPTIONAL, offsetof(struct Authenticator, authorization_data), asn1_EncTicketPart_tag_authorization_data_65 },
2917 : /* 10 */ { A1_OP_NAME, 0, "Authenticator" },
2918 : /* 11 */ { A1_OP_NAME, 0, "authenticator-vno" },
2919 : /* 12 */ { A1_OP_NAME, 0, "crealm" },
2920 : /* 13 */ { A1_OP_NAME, 0, "cname" },
2921 : /* 14 */ { A1_OP_NAME, 0, "cksum" },
2922 : /* 15 */ { A1_OP_NAME, 0, "cusec" },
2923 : /* 16 */ { A1_OP_NAME, 0, "ctime" },
2924 : /* 17 */ { A1_OP_NAME, 0, "subkey" },
2925 : /* 18 */ { A1_OP_NAME, 0, "seq-number" },
2926 : /* 19 */ { A1_OP_NAME, 0, "authorization-data" }
2927 : };
2928 : /* generate_template_type: Authenticator_tag__107 */
2929 : const struct asn1_template asn1_Authenticator_tag__107[] = {
2930 : /* 0 */ { 0, sizeof(struct Authenticator), ((void *)(uintptr_t)1) },
2931 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_Authenticator_tag__108 }
2932 : };
2933 : /* generate_template_type: Authenticator */
2934 : const struct asn1_template asn1_Authenticator[] = {
2935 : /* 0 */ { 0, sizeof(Authenticator), ((void *)(uintptr_t)1) },
2936 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,2), 0, asn1_Authenticator_tag__107 }
2937 : };
2938 :
2939 : int ASN1CALL
2940 56664 : decode_Authenticator(const unsigned char *p, size_t len, Authenticator *data, size_t *size)
2941 : {
2942 56664 : memset(data, 0, sizeof(*data));
2943 56664 : return _asn1_decode_top(asn1_Authenticator, 0|0, p, len, data, size);
2944 : }
2945 :
2946 :
2947 : int ASN1CALL
2948 60588 : encode_Authenticator(unsigned char *p, size_t len, const Authenticator *data, size_t *size)
2949 : {
2950 60588 : return _asn1_encode(asn1_Authenticator, p, len, data, size);
2951 : }
2952 :
2953 :
2954 : size_t ASN1CALL
2955 60588 : length_Authenticator(const Authenticator *data)
2956 : {
2957 60588 : return _asn1_length(asn1_Authenticator, data);
2958 : }
2959 :
2960 :
2961 : void ASN1CALL
2962 300857 : free_Authenticator(Authenticator *data)
2963 : {
2964 300857 : _asn1_free_top(asn1_Authenticator, data);
2965 300857 : }
2966 :
2967 :
2968 : int ASN1CALL
2969 92719 : copy_Authenticator(const Authenticator *from, Authenticator *to)
2970 : {
2971 92719 : return _asn1_copy_top(asn1_Authenticator, from, to);
2972 : }
2973 :
2974 :
2975 : char * ASN1CALL
2976 0 : print_Authenticator(const Authenticator *data, int flags)
2977 : {
2978 0 : return _asn1_print_top(asn1_Authenticator, flags, data);
2979 : }
2980 :
2981 : /* template_members: PA_DATA exp exp */
2982 : /* tsequence: members isstruct: 1 */
2983 : /* template_members: PA_DATA exp exp */
2984 : /* generate_template_type: PA_DATA_tag_padata_type_119 */
2985 : const struct asn1_template asn1_PA_DATA_tag_padata_type_119[] = {
2986 : /* 0 */ { 0, sizeof(PADATA_TYPE), ((void *)(uintptr_t)1) },
2987 : /* 1 */ { A1_OP_TYPE , 0, asn1_PADATA_TYPE }
2988 : };
2989 : /* template_members: PA_DATA exp exp */
2990 : /* template_members: heim_octet_string exp exp */
2991 : /* generate_template_type: heim_octet_string_tag_padata_value_121 */
2992 : /* generate_template_type: PA_DATA_tag_padata_value_120 */
2993 : /* generate_template_type: PA_DATA_tag__118 */
2994 : const struct asn1_template asn1_PA_DATA_tag__118[] = {
2995 : /* 0 */ { 0, sizeof(struct PA_DATA), ((void *)(uintptr_t)5) },
2996 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct PA_DATA, padata_type), asn1_PA_DATA_tag_padata_type_119 },
2997 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct PA_DATA, padata_value), asn1_HostAddress_tag_address_17 },
2998 : /* 3 */ { A1_OP_NAME, 0, "PA_DATA" },
2999 : /* 4 */ { A1_OP_NAME, 0, "padata-type" },
3000 : /* 5 */ { A1_OP_NAME, 0, "padata-value" }
3001 : };
3002 : /* generate_template_type: PA_DATA */
3003 : const struct asn1_template asn1_PA_DATA[] = {
3004 : /* 0 */ { 0, sizeof(PA_DATA), ((void *)(uintptr_t)1) },
3005 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_DATA_tag__118 }
3006 : };
3007 :
3008 : int ASN1CALL
3009 0 : decode_PA_DATA(const unsigned char *p, size_t len, PA_DATA *data, size_t *size)
3010 : {
3011 0 : memset(data, 0, sizeof(*data));
3012 0 : return _asn1_decode_top(asn1_PA_DATA, 0|0, p, len, data, size);
3013 : }
3014 :
3015 :
3016 : int ASN1CALL
3017 0 : encode_PA_DATA(unsigned char *p, size_t len, const PA_DATA *data, size_t *size)
3018 : {
3019 0 : return _asn1_encode(asn1_PA_DATA, p, len, data, size);
3020 : }
3021 :
3022 :
3023 : size_t ASN1CALL
3024 0 : length_PA_DATA(const PA_DATA *data)
3025 : {
3026 0 : return _asn1_length(asn1_PA_DATA, data);
3027 : }
3028 :
3029 :
3030 : void ASN1CALL
3031 536 : free_PA_DATA(PA_DATA *data)
3032 : {
3033 536 : _asn1_free_top(asn1_PA_DATA, data);
3034 536 : }
3035 :
3036 :
3037 : int ASN1CALL
3038 25447 : copy_PA_DATA(const PA_DATA *from, PA_DATA *to)
3039 : {
3040 25447 : return _asn1_copy_top(asn1_PA_DATA, from, to);
3041 : }
3042 :
3043 :
3044 : char * ASN1CALL
3045 0 : print_PA_DATA(const PA_DATA *data, int flags)
3046 : {
3047 0 : return _asn1_print_top(asn1_PA_DATA, flags, data);
3048 : }
3049 :
3050 : /* template_members: ETYPE_INFO_ENTRY exp exp */
3051 : /* tsequence: members isstruct: 1 */
3052 : /* template_members: ETYPE_INFO_ENTRY exp exp */
3053 : /* generate_template_type: ETYPE_INFO_ENTRY_tag_etype_123 */
3054 : /* template_members: ETYPE_INFO_ENTRY exp exp */
3055 : /* template_members: heim_octet_string exp exp */
3056 : /* generate_template_type: heim_octet_string_tag_salt_125 */
3057 : /* generate_template_type: ETYPE_INFO_ENTRY_tag_salt_124 */
3058 : /* template_members: ETYPE_INFO_ENTRY exp exp */
3059 : /* generate_template_type: ETYPE_INFO_ENTRY_tag_salttype_126 */
3060 : /* generate_template_type: ETYPE_INFO_ENTRY_tag__122 */
3061 : const struct asn1_template asn1_ETYPE_INFO_ENTRY_tag__122[] = {
3062 : /* 0 */ { 0, sizeof(struct ETYPE_INFO_ENTRY), ((void *)(uintptr_t)7) },
3063 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct ETYPE_INFO_ENTRY, etype), asn1_EncryptedData_tag_etype_35 },
3064 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct ETYPE_INFO_ENTRY, salt), asn1_HostAddress_tag_address_17 },
3065 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct ETYPE_INFO_ENTRY, salttype), asn1_HostAddress_tag_addr_type_16 },
3066 : /* 4 */ { A1_OP_NAME, 0, "ETYPE_INFO_ENTRY" },
3067 : /* 5 */ { A1_OP_NAME, 0, "etype" },
3068 : /* 6 */ { A1_OP_NAME, 0, "salt" },
3069 : /* 7 */ { A1_OP_NAME, 0, "salttype" }
3070 : };
3071 : /* generate_template_type: ETYPE_INFO_ENTRY */
3072 : const struct asn1_template asn1_ETYPE_INFO_ENTRY[] = {
3073 : /* 0 */ { 0, sizeof(ETYPE_INFO_ENTRY), ((void *)(uintptr_t)1) },
3074 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_ETYPE_INFO_ENTRY_tag__122 }
3075 : };
3076 :
3077 : int ASN1CALL
3078 0 : decode_ETYPE_INFO_ENTRY(const unsigned char *p, size_t len, ETYPE_INFO_ENTRY *data, size_t *size)
3079 : {
3080 0 : memset(data, 0, sizeof(*data));
3081 0 : return _asn1_decode_top(asn1_ETYPE_INFO_ENTRY, 0|0, p, len, data, size);
3082 : }
3083 :
3084 :
3085 : int ASN1CALL
3086 0 : encode_ETYPE_INFO_ENTRY(unsigned char *p, size_t len, const ETYPE_INFO_ENTRY *data, size_t *size)
3087 : {
3088 0 : return _asn1_encode(asn1_ETYPE_INFO_ENTRY, p, len, data, size);
3089 : }
3090 :
3091 :
3092 : size_t ASN1CALL
3093 0 : length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *data)
3094 : {
3095 0 : return _asn1_length(asn1_ETYPE_INFO_ENTRY, data);
3096 : }
3097 :
3098 :
3099 : void ASN1CALL
3100 0 : free_ETYPE_INFO_ENTRY(ETYPE_INFO_ENTRY *data)
3101 : {
3102 0 : _asn1_free_top(asn1_ETYPE_INFO_ENTRY, data);
3103 0 : }
3104 :
3105 :
3106 : int ASN1CALL
3107 536 : copy_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *from, ETYPE_INFO_ENTRY *to)
3108 : {
3109 536 : return _asn1_copy_top(asn1_ETYPE_INFO_ENTRY, from, to);
3110 : }
3111 :
3112 :
3113 : char * ASN1CALL
3114 0 : print_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *data, int flags)
3115 : {
3116 0 : return _asn1_print_top(asn1_ETYPE_INFO_ENTRY, flags, data);
3117 : }
3118 :
3119 : /* template_members: ETYPE_INFO exp exp */
3120 : /* generate_template_type: ETYPE_INFO_ENTRY_seofTstruct_5 */
3121 : const struct asn1_template asn1_ETYPE_INFO_ENTRY_seofTstruct_5[] = {
3122 : /* 0 */ { 0, sizeof(ETYPE_INFO_ENTRY), ((void *)(uintptr_t)1) },
3123 : /* 1 */ { A1_OP_TYPE , 0, asn1_ETYPE_INFO_ENTRY }
3124 : };
3125 : /* generate_template_type: ETYPE_INFO_tag__127 */
3126 : const struct asn1_template asn1_ETYPE_INFO_tag__127[] = {
3127 : /* 0 */ { 0, sizeof(ETYPE_INFO_ENTRY), ((void *)(uintptr_t)1) },
3128 : /* 1 */ { A1_OP_SEQOF, 0, asn1_ETYPE_INFO_ENTRY_seofTstruct_5 }
3129 : };
3130 : /* generate_template_type: ETYPE_INFO */
3131 : const struct asn1_template asn1_ETYPE_INFO[] = {
3132 : /* 0 */ { 0, sizeof(ETYPE_INFO), ((void *)(uintptr_t)1) },
3133 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_ETYPE_INFO_tag__127 }
3134 : };
3135 :
3136 : int ASN1CALL
3137 0 : decode_ETYPE_INFO(const unsigned char *p, size_t len, ETYPE_INFO *data, size_t *size)
3138 : {
3139 0 : memset(data, 0, sizeof(*data));
3140 0 : return _asn1_decode_top(asn1_ETYPE_INFO, 0|0, p, len, data, size);
3141 : }
3142 :
3143 :
3144 : int ASN1CALL
3145 536 : encode_ETYPE_INFO(unsigned char *p, size_t len, const ETYPE_INFO *data, size_t *size)
3146 : {
3147 536 : return _asn1_encode(asn1_ETYPE_INFO, p, len, data, size);
3148 : }
3149 :
3150 :
3151 : size_t ASN1CALL
3152 536 : length_ETYPE_INFO(const ETYPE_INFO *data)
3153 : {
3154 536 : return _asn1_length(asn1_ETYPE_INFO, data);
3155 : }
3156 :
3157 :
3158 : void ASN1CALL
3159 536 : free_ETYPE_INFO(ETYPE_INFO *data)
3160 : {
3161 536 : _asn1_free_top(asn1_ETYPE_INFO, data);
3162 536 : }
3163 :
3164 :
3165 : int ASN1CALL
3166 0 : copy_ETYPE_INFO(const ETYPE_INFO *from, ETYPE_INFO *to)
3167 : {
3168 0 : return _asn1_copy_top(asn1_ETYPE_INFO, from, to);
3169 : }
3170 :
3171 :
3172 : char * ASN1CALL
3173 0 : print_ETYPE_INFO(const ETYPE_INFO *data, int flags)
3174 : {
3175 0 : return _asn1_print_top(asn1_ETYPE_INFO, flags, data);
3176 : }
3177 :
3178 : int ASN1CALL
3179 536 : add_ETYPE_INFO(ETYPE_INFO *data, const ETYPE_INFO_ENTRY *element)
3180 : {
3181 : int ret;
3182 : void *ptr;
3183 :
3184 536 : ptr = realloc(data->val,
3185 536 : (data->len + 1) * sizeof(data->val[0]));
3186 536 : if (ptr == NULL) return ENOMEM;
3187 536 : data->val = ptr;
3188 :
3189 536 : ret = copy_ETYPE_INFO_ENTRY(element, &data->val[data->len]);
3190 536 : if (ret) return ret;
3191 536 : data->len++;
3192 536 : return 0;
3193 : }
3194 :
3195 : int ASN1CALL
3196 0 : remove_ETYPE_INFO(ETYPE_INFO *data, unsigned int element)
3197 : {
3198 : void *ptr;
3199 :
3200 0 : if (data->len == 0 || element >= data->len)
3201 0 : return ASN1_OVERRUN;
3202 0 : free_ETYPE_INFO_ENTRY(&data->val[element]);
3203 0 : data->len--;
3204 0 : if (element < data->len)
3205 0 : memmove(&data->val[element], &data->val[element + 1],
3206 0 : sizeof(data->val[0]) * (data->len - element));
3207 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
3208 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
3209 0 : return 0;
3210 : }
3211 :
3212 : /* template_members: ETYPE_INFO2_ENTRY exp exp */
3213 : /* tsequence: members isstruct: 1 */
3214 : /* template_members: ETYPE_INFO2_ENTRY exp exp */
3215 : /* generate_template_type: ETYPE_INFO2_ENTRY_tag_etype_129 */
3216 : /* template_members: ETYPE_INFO2_ENTRY exp exp */
3217 : /* generate_template_type: ETYPE_INFO2_ENTRY_tag_salt_130 */
3218 : const struct asn1_template asn1_ETYPE_INFO2_ENTRY_tag_salt_130[] = {
3219 : /* 0 */ { 0, sizeof(KerberosString), ((void *)(uintptr_t)1) },
3220 : /* 1 */ { A1_OP_TYPE , 0, asn1_KerberosString }
3221 : };
3222 : /* template_members: ETYPE_INFO2_ENTRY exp exp */
3223 : /* template_members: heim_octet_string exp exp */
3224 : /* generate_template_type: heim_octet_string_tag_s2kparams_132 */
3225 : /* generate_template_type: ETYPE_INFO2_ENTRY_tag_s2kparams_131 */
3226 : /* generate_template_type: ETYPE_INFO2_ENTRY_tag__128 */
3227 : const struct asn1_template asn1_ETYPE_INFO2_ENTRY_tag__128[] = {
3228 : /* 0 */ { 0, sizeof(struct ETYPE_INFO2_ENTRY), ((void *)(uintptr_t)7) },
3229 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct ETYPE_INFO2_ENTRY, etype), asn1_EncryptedData_tag_etype_35 },
3230 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct ETYPE_INFO2_ENTRY, salt), asn1_ETYPE_INFO2_ENTRY_tag_salt_130 },
3231 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct ETYPE_INFO2_ENTRY, s2kparams), asn1_HostAddress_tag_address_17 },
3232 : /* 4 */ { A1_OP_NAME, 0, "ETYPE_INFO2_ENTRY" },
3233 : /* 5 */ { A1_OP_NAME, 0, "etype" },
3234 : /* 6 */ { A1_OP_NAME, 0, "salt" },
3235 : /* 7 */ { A1_OP_NAME, 0, "s2kparams" }
3236 : };
3237 : /* generate_template_type: ETYPE_INFO2_ENTRY */
3238 : const struct asn1_template asn1_ETYPE_INFO2_ENTRY[] = {
3239 : /* 0 */ { 0, sizeof(ETYPE_INFO2_ENTRY), ((void *)(uintptr_t)1) },
3240 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_ETYPE_INFO2_ENTRY_tag__128 }
3241 : };
3242 :
3243 : int ASN1CALL
3244 0 : decode_ETYPE_INFO2_ENTRY(const unsigned char *p, size_t len, ETYPE_INFO2_ENTRY *data, size_t *size)
3245 : {
3246 0 : memset(data, 0, sizeof(*data));
3247 0 : return _asn1_decode_top(asn1_ETYPE_INFO2_ENTRY, 0|0, p, len, data, size);
3248 : }
3249 :
3250 :
3251 : int ASN1CALL
3252 0 : encode_ETYPE_INFO2_ENTRY(unsigned char *p, size_t len, const ETYPE_INFO2_ENTRY *data, size_t *size)
3253 : {
3254 0 : return _asn1_encode(asn1_ETYPE_INFO2_ENTRY, p, len, data, size);
3255 : }
3256 :
3257 :
3258 : size_t ASN1CALL
3259 0 : length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *data)
3260 : {
3261 0 : return _asn1_length(asn1_ETYPE_INFO2_ENTRY, data);
3262 : }
3263 :
3264 :
3265 : void ASN1CALL
3266 0 : free_ETYPE_INFO2_ENTRY(ETYPE_INFO2_ENTRY *data)
3267 : {
3268 0 : _asn1_free_top(asn1_ETYPE_INFO2_ENTRY, data);
3269 0 : }
3270 :
3271 :
3272 : int ASN1CALL
3273 0 : copy_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *from, ETYPE_INFO2_ENTRY *to)
3274 : {
3275 0 : return _asn1_copy_top(asn1_ETYPE_INFO2_ENTRY, from, to);
3276 : }
3277 :
3278 :
3279 : char * ASN1CALL
3280 0 : print_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *data, int flags)
3281 : {
3282 0 : return _asn1_print_top(asn1_ETYPE_INFO2_ENTRY, flags, data);
3283 : }
3284 :
3285 : /* template_members: ETYPE_INFO2 exp exp */
3286 : /* generate_template_type: ETYPE_INFO2_ENTRY_seofTstruct_6 */
3287 : const struct asn1_template asn1_ETYPE_INFO2_ENTRY_seofTstruct_6[] = {
3288 : /* 0 */ { 0, sizeof(ETYPE_INFO2_ENTRY), ((void *)(uintptr_t)1) },
3289 : /* 1 */ { A1_OP_TYPE , 0, asn1_ETYPE_INFO2_ENTRY }
3290 : };
3291 : /* generate_template_type: ETYPE_INFO2_tag__133 */
3292 : const struct asn1_template asn1_ETYPE_INFO2_tag__133[] = {
3293 : /* 0 */ { 0, sizeof(ETYPE_INFO2_ENTRY), ((void *)(uintptr_t)1) },
3294 : /* 1 */ { A1_OP_SEQOF, 0, asn1_ETYPE_INFO2_ENTRY_seofTstruct_6 }
3295 : };
3296 : /* generate_template_type: ETYPE_INFO2 */
3297 : const struct asn1_template asn1_ETYPE_INFO2[] = {
3298 : /* 0 */ { 0, sizeof(ETYPE_INFO2), ((void *)(uintptr_t)1) },
3299 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_ETYPE_INFO2_tag__133 }
3300 : };
3301 :
3302 : int ASN1CALL
3303 26764 : decode_ETYPE_INFO2(const unsigned char *p, size_t len, ETYPE_INFO2 *data, size_t *size)
3304 : {
3305 26764 : memset(data, 0, sizeof(*data));
3306 26764 : return _asn1_decode_top(asn1_ETYPE_INFO2, 0|0, p, len, data, size);
3307 : }
3308 :
3309 :
3310 : int ASN1CALL
3311 28880 : encode_ETYPE_INFO2(unsigned char *p, size_t len, const ETYPE_INFO2 *data, size_t *size)
3312 : {
3313 28880 : return _asn1_encode(asn1_ETYPE_INFO2, p, len, data, size);
3314 : }
3315 :
3316 :
3317 : size_t ASN1CALL
3318 28880 : length_ETYPE_INFO2(const ETYPE_INFO2 *data)
3319 : {
3320 28880 : return _asn1_length(asn1_ETYPE_INFO2, data);
3321 : }
3322 :
3323 :
3324 : void ASN1CALL
3325 55644 : free_ETYPE_INFO2(ETYPE_INFO2 *data)
3326 : {
3327 55644 : _asn1_free_top(asn1_ETYPE_INFO2, data);
3328 55644 : }
3329 :
3330 :
3331 : int ASN1CALL
3332 0 : copy_ETYPE_INFO2(const ETYPE_INFO2 *from, ETYPE_INFO2 *to)
3333 : {
3334 0 : return _asn1_copy_top(asn1_ETYPE_INFO2, from, to);
3335 : }
3336 :
3337 :
3338 : char * ASN1CALL
3339 0 : print_ETYPE_INFO2(const ETYPE_INFO2 *data, int flags)
3340 : {
3341 0 : return _asn1_print_top(asn1_ETYPE_INFO2, flags, data);
3342 : }
3343 :
3344 : int ASN1CALL
3345 0 : add_ETYPE_INFO2(ETYPE_INFO2 *data, const ETYPE_INFO2_ENTRY *element)
3346 : {
3347 : int ret;
3348 : void *ptr;
3349 :
3350 0 : ptr = realloc(data->val,
3351 0 : (data->len + 1) * sizeof(data->val[0]));
3352 0 : if (ptr == NULL) return ENOMEM;
3353 0 : data->val = ptr;
3354 :
3355 0 : ret = copy_ETYPE_INFO2_ENTRY(element, &data->val[data->len]);
3356 0 : if (ret) return ret;
3357 0 : data->len++;
3358 0 : return 0;
3359 : }
3360 :
3361 : int ASN1CALL
3362 0 : remove_ETYPE_INFO2(ETYPE_INFO2 *data, unsigned int element)
3363 : {
3364 : void *ptr;
3365 :
3366 0 : if (data->len == 0 || element >= data->len)
3367 0 : return ASN1_OVERRUN;
3368 0 : free_ETYPE_INFO2_ENTRY(&data->val[element]);
3369 0 : data->len--;
3370 0 : if (element < data->len)
3371 0 : memmove(&data->val[element], &data->val[element + 1],
3372 0 : sizeof(data->val[0]) * (data->len - element));
3373 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
3374 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
3375 0 : return 0;
3376 : }
3377 :
3378 : /* template_members: METHOD_DATA exp exp */
3379 : /* generate_template_type: PA_DATA_seofTstruct_7 */
3380 : const struct asn1_template asn1_PA_DATA_seofTstruct_7[] = {
3381 : /* 0 */ { 0, sizeof(PA_DATA), ((void *)(uintptr_t)1) },
3382 : /* 1 */ { A1_OP_TYPE , 0, asn1_PA_DATA }
3383 : };
3384 : /* generate_template_type: METHOD_DATA_tag__134 */
3385 : const struct asn1_template asn1_METHOD_DATA_tag__134[] = {
3386 : /* 0 */ { 0, sizeof(PA_DATA), ((void *)(uintptr_t)1) },
3387 : /* 1 */ { A1_OP_SEQOF, 0, asn1_PA_DATA_seofTstruct_7 }
3388 : };
3389 : /* generate_template_type: METHOD_DATA */
3390 : const struct asn1_template asn1_METHOD_DATA[] = {
3391 : /* 0 */ { 0, sizeof(METHOD_DATA), ((void *)(uintptr_t)1) },
3392 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_METHOD_DATA_tag__134 }
3393 : };
3394 :
3395 : int ASN1CALL
3396 10946 : decode_METHOD_DATA(const unsigned char *p, size_t len, METHOD_DATA *data, size_t *size)
3397 : {
3398 10946 : memset(data, 0, sizeof(*data));
3399 10946 : return _asn1_decode_top(asn1_METHOD_DATA, 0|0, p, len, data, size);
3400 : }
3401 :
3402 :
3403 : int ASN1CALL
3404 20169 : encode_METHOD_DATA(unsigned char *p, size_t len, const METHOD_DATA *data, size_t *size)
3405 : {
3406 20169 : return _asn1_encode(asn1_METHOD_DATA, p, len, data, size);
3407 : }
3408 :
3409 :
3410 : size_t ASN1CALL
3411 20169 : length_METHOD_DATA(const METHOD_DATA *data)
3412 : {
3413 20169 : return _asn1_length(asn1_METHOD_DATA, data);
3414 : }
3415 :
3416 :
3417 : void ASN1CALL
3418 171531 : free_METHOD_DATA(METHOD_DATA *data)
3419 : {
3420 171531 : _asn1_free_top(asn1_METHOD_DATA, data);
3421 171531 : }
3422 :
3423 :
3424 : int ASN1CALL
3425 62996 : copy_METHOD_DATA(const METHOD_DATA *from, METHOD_DATA *to)
3426 : {
3427 62996 : return _asn1_copy_top(asn1_METHOD_DATA, from, to);
3428 : }
3429 :
3430 :
3431 : char * ASN1CALL
3432 0 : print_METHOD_DATA(const METHOD_DATA *data, int flags)
3433 : {
3434 0 : return _asn1_print_top(asn1_METHOD_DATA, flags, data);
3435 : }
3436 :
3437 : int ASN1CALL
3438 24551 : add_METHOD_DATA(METHOD_DATA *data, const PA_DATA *element)
3439 : {
3440 : int ret;
3441 : void *ptr;
3442 :
3443 24551 : ptr = realloc(data->val,
3444 24551 : (data->len + 1) * sizeof(data->val[0]));
3445 24551 : if (ptr == NULL) return ENOMEM;
3446 24551 : data->val = ptr;
3447 :
3448 24551 : ret = copy_PA_DATA(element, &data->val[data->len]);
3449 24551 : if (ret) return ret;
3450 24551 : data->len++;
3451 24551 : return 0;
3452 : }
3453 :
3454 : int ASN1CALL
3455 0 : remove_METHOD_DATA(METHOD_DATA *data, unsigned int element)
3456 : {
3457 : void *ptr;
3458 :
3459 0 : if (data->len == 0 || element >= data->len)
3460 0 : return ASN1_OVERRUN;
3461 0 : free_PA_DATA(&data->val[element]);
3462 0 : data->len--;
3463 0 : if (element < data->len)
3464 0 : memmove(&data->val[element], &data->val[element + 1],
3465 0 : sizeof(data->val[0]) * (data->len - element));
3466 0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
3467 0 : if (ptr != NULL || data->len == 0) data->val = ptr;
3468 0 : return 0;
3469 : }
3470 :
3471 : /* template_members: TypedData exp exp */
3472 : /* tsequence: members isstruct: 1 */
3473 : /* template_members: TypedData exp exp */
3474 : /* generate_template_type: TypedData_tag_data_type_136 */
3475 : /* template_members: TypedData exp exp */
3476 : /* template_members: heim_octet_string exp exp */
3477 : /* generate_template_type: heim_octet_string_tag_data_value_138 */
3478 : /* generate_template_type: TypedData_tag_data_value_137 */
3479 : /* generate_template_type: TypedData_tag__135 */
3480 : const struct asn1_template asn1_TypedData_tag__135[] = {
3481 : /* 0 */ { 0, sizeof(struct TypedData), ((void *)(uintptr_t)5) },
3482 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct TypedData, data_type), asn1_HostAddress_tag_addr_type_16 },
3483 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct TypedData, data_value), asn1_HostAddress_tag_address_17 },
3484 : /* 3 */ { A1_OP_NAME, 0, "TypedData" },
3485 : /* 4 */ { A1_OP_NAME, 0, "data-type" },
3486 : /* 5 */ { A1_OP_NAME, 0, "data-value" }
3487 : };
3488 : /* generate_template_type: TypedData */
3489 : const struct asn1_template asn1_TypedData[] = {
3490 : /* 0 */ { 0, sizeof(TypedData), ((void *)(uintptr_t)1) },
3491 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_TypedData_tag__135 }
3492 : };
3493 :
3494 : int ASN1CALL
3495 0 : decode_TypedData(const unsigned char *p, size_t len, TypedData *data, size_t *size)
3496 : {
3497 0 : memset(data, 0, sizeof(*data));
3498 0 : return _asn1_decode_top(asn1_TypedData, 0|0, p, len, data, size);
3499 : }
3500 :
3501 :
3502 : int ASN1CALL
3503 0 : encode_TypedData(unsigned char *p, size_t len, const TypedData *data, size_t *size)
3504 : {
3505 0 : return _asn1_encode(asn1_TypedData, p, len, data, size);
3506 : }
3507 :
3508 :
3509 : size_t ASN1CALL
3510 0 : length_TypedData(const TypedData *data)
3511 : {
3512 0 : return _asn1_length(asn1_TypedData, data);
3513 : }
3514 :
3515 :
3516 : void ASN1CALL
3517 0 : free_TypedData(TypedData *data)
3518 : {
3519 0 : _asn1_free_top(asn1_TypedData, data);
3520 0 : }
3521 :
3522 :
3523 : int ASN1CALL
3524 0 : copy_TypedData(const TypedData *from, TypedData *to)
3525 : {
3526 0 : return _asn1_copy_top(asn1_TypedData, from, to);
3527 : }
3528 :
3529 :
3530 : char * ASN1CALL
3531 0 : print_TypedData(const TypedData *data, int flags)
3532 : {
3533 0 : return _asn1_print_top(asn1_TypedData, flags, data);
3534 : }
3535 :
3536 : /* template_members: TYPED_DATA exp exp */
3537 : /* generate_template_type: TypedData_seofTstruct_8 */
3538 : const struct asn1_template asn1_TypedData_seofTstruct_8[] = {
3539 : /* 0 */ { 0, sizeof(TypedData), ((void *)(uintptr_t)1) },
3540 : /* 1 */ { A1_OP_TYPE , 0, asn1_TypedData }
3541 : };
3542 : /* generate_template_type: TYPED_DATA_tag__139 */
3543 : const struct asn1_template asn1_TYPED_DATA_tag__139[] = {
3544 : /* 0 */ { 0, sizeof(TypedData), ((void *)(uintptr_t)1) },
3545 : /* 1 */ { A1_OP_SEQOF, 0, asn1_TypedData_seofTstruct_8 }
3546 : };
3547 : /* generate_template_type: TYPED_DATA */
3548 : const struct asn1_template asn1_TYPED_DATA[] = {
3549 : /* 0 */ { 0, sizeof(TYPED_DATA), ((void *)(uintptr_t)1) },
3550 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_TYPED_DATA_tag__139 }
3551 : };
3552 :
3553 : int ASN1CALL
3554 0 : decode_TYPED_DATA(const unsigned char *p, size_t len, TYPED_DATA *data, size_t *size)
3555 : {
3556 0 : memset(data, 0, sizeof(*data));
3557 0 : return _asn1_decode_top(asn1_TYPED_DATA, 0|0, p, len, data, size);
3558 : }
3559 :
3560 :
3561 : int ASN1CALL
3562 0 : encode_TYPED_DATA(unsigned char *p, size_t len, const TYPED_DATA *data, size_t *size)
3563 : {
3564 0 : return _asn1_encode(asn1_TYPED_DATA, p, len, data, size);
3565 : }
3566 :
3567 :
3568 : size_t ASN1CALL
3569 0 : length_TYPED_DATA(const TYPED_DATA *data)
3570 : {
3571 0 : return _asn1_length(asn1_TYPED_DATA, data);
3572 : }
3573 :
3574 :
3575 : void ASN1CALL
3576 0 : free_TYPED_DATA(TYPED_DATA *data)
3577 : {
3578 0 : _asn1_free_top(asn1_TYPED_DATA, data);
3579 0 : }
3580 :
3581 :
3582 : int ASN1CALL
3583 0 : copy_TYPED_DATA(const TYPED_DATA *from, TYPED_DATA *to)
3584 : {
3585 0 : return _asn1_copy_top(asn1_TYPED_DATA, from, to);
3586 : }
3587 :
3588 :
3589 : char * ASN1CALL
3590 0 : print_TYPED_DATA(const TYPED_DATA *data, int flags)
3591 : {
3592 0 : return _asn1_print_top(asn1_TYPED_DATA, flags, data);
3593 : }
3594 :
3595 : /* template_members: KDC_REQ_BODY exp exp */
3596 : /* tsequence: members isstruct: 1 */
3597 : /* template_members: KDC_REQ_BODY exp exp */
3598 : /* generate_template_type: KDC_REQ_BODY_tag_kdc_options_141 */
3599 : const struct asn1_template asn1_KDC_REQ_BODY_tag_kdc_options_141[] = {
3600 : /* 0 */ { 0, sizeof(KDCOptions), ((void *)(uintptr_t)1) },
3601 : /* 1 */ { A1_OP_TYPE , 0, asn1_KDCOptions }
3602 : };
3603 : /* template_members: KDC_REQ_BODY exp exp */
3604 : /* generate_template_type: KDC_REQ_BODY_tag_cname_142 */
3605 : /* template_members: KDC_REQ_BODY exp exp */
3606 : /* generate_template_type: KDC_REQ_BODY_tag_realm_143 */
3607 : /* template_members: KDC_REQ_BODY exp exp */
3608 : /* generate_template_type: KDC_REQ_BODY_tag_sname_144 */
3609 : /* template_members: KDC_REQ_BODY exp exp */
3610 : /* generate_template_type: KDC_REQ_BODY_tag_from_145 */
3611 : /* template_members: KDC_REQ_BODY exp exp */
3612 : /* generate_template_type: KDC_REQ_BODY_tag_till_146 */
3613 : /* template_members: KDC_REQ_BODY exp exp */
3614 : /* generate_template_type: KDC_REQ_BODY_tag_rtime_147 */
3615 : /* template_members: KDC_REQ_BODY exp exp */
3616 : /* generate_template_type: KDC_REQ_BODY_tag_nonce_148 */
3617 : /* template_members: KDC_REQ_BODY exp exp */
3618 : /* template_members: KDC_REQ_BODY exp exp */
3619 : /* generate_template_type: KDC_REQ_BODY_etype_9 */
3620 : /* generate_template_type: KDC_REQ_BODY_tag_etype_150 */
3621 : const struct asn1_template asn1_KDC_REQ_BODY_tag_etype_150[] = {
3622 : /* 0 */ { 0, sizeof(struct KDC_REQ_BODY_etype), ((void *)(uintptr_t)1) },
3623 : /* 1 */ { A1_OP_SEQOF, 0, asn1_EncryptedData_tag_etype_35 }
3624 : };
3625 : /* generate_template_type: KDC_REQ_BODY_tag_etype_149 */
3626 : const struct asn1_template asn1_KDC_REQ_BODY_tag_etype_149[] = {
3627 : /* 0 */ { 0, sizeof(struct KDC_REQ_BODY_etype), ((void *)(uintptr_t)1) },
3628 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDC_REQ_BODY_tag_etype_150 }
3629 : };
3630 : /* template_members: KDC_REQ_BODY exp exp */
3631 : /* generate_template_type: KDC_REQ_BODY_tag_addresses_151 */
3632 : /* template_members: KDC_REQ_BODY exp exp */
3633 : /* generate_template_type: KDC_REQ_BODY_tag_enc_authorization_data_152 */
3634 : /* template_members: KDC_REQ_BODY exp exp */
3635 : /* template_members: KDC_REQ_BODY exp exp */
3636 : /* generate_template_type: KDC_REQ_BODY_additional_tickets_10 */
3637 : const struct asn1_template asn1_KDC_REQ_BODY_additional_tickets_10[] = {
3638 : /* 0 */ { 0, sizeof(Ticket), ((void *)(uintptr_t)1) },
3639 : /* 1 */ { A1_OP_TYPE , 0, asn1_Ticket }
3640 : };
3641 : /* generate_template_type: KDC_REQ_BODY_tag_additional_tickets_154 */
3642 : const struct asn1_template asn1_KDC_REQ_BODY_tag_additional_tickets_154[] = {
3643 : /* 0 */ { 0, sizeof(struct KDC_REQ_BODY_additional_tickets), ((void *)(uintptr_t)1) },
3644 : /* 1 */ { A1_OP_SEQOF, 0, asn1_KDC_REQ_BODY_additional_tickets_10 }
3645 : };
3646 : /* generate_template_type: KDC_REQ_BODY_tag_additional_tickets_153 */
3647 : const struct asn1_template asn1_KDC_REQ_BODY_tag_additional_tickets_153[] = {
3648 : /* 0 */ { 0, sizeof(struct KDC_REQ_BODY_additional_tickets), ((void *)(uintptr_t)1) },
3649 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDC_REQ_BODY_tag_additional_tickets_154 }
3650 : };
3651 : /* generate_template_type: KDC_REQ_BODY_tag__140 */
3652 : const struct asn1_template asn1_KDC_REQ_BODY_tag__140[] = {
3653 : /* 0 */ { 0, sizeof(struct KDC_REQ_BODY), ((void *)(uintptr_t)25) },
3654 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KDC_REQ_BODY, kdc_options), asn1_KDC_REQ_BODY_tag_kdc_options_141 },
3655 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ_BODY, cname), asn1_Ticket_tag_sname_51 },
3656 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KDC_REQ_BODY, realm), asn1_Ticket_tag_realm_50 },
3657 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ_BODY, sname), asn1_Ticket_tag_sname_51 },
3658 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ_BODY, from), asn1_LastReq_val_tag_lr_value_33 },
3659 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ_BODY, till), asn1_LastReq_val_tag_lr_value_33 },
3660 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ_BODY, rtime), asn1_LastReq_val_tag_lr_value_33 },
3661 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7), offsetof(struct KDC_REQ_BODY, nonce), asn1_HostAddress_tag_addr_type_16 },
3662 : /* 9 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,8), offsetof(struct KDC_REQ_BODY, etype), asn1_KDC_REQ_BODY_tag_etype_149 },
3663 : /* 10 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,9)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ_BODY, addresses), asn1_EncTicketPart_tag_caddr_64 },
3664 : /* 11 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,10)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ_BODY, enc_authorization_data), asn1_Ticket_tag_enc_part_52 },
3665 : /* 12 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,11)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ_BODY, additional_tickets), asn1_KDC_REQ_BODY_tag_additional_tickets_153 },
3666 : /* 13 */ { A1_OP_NAME, 0, "KDC_REQ_BODY" },
3667 : /* 14 */ { A1_OP_NAME, 0, "kdc-options" },
3668 : /* 15 */ { A1_OP_NAME, 0, "cname" },
3669 : /* 16 */ { A1_OP_NAME, 0, "realm" },
3670 : /* 17 */ { A1_OP_NAME, 0, "sname" },
3671 : /* 18 */ { A1_OP_NAME, 0, "from" },
3672 : /* 19 */ { A1_OP_NAME, 0, "till" },
3673 : /* 20 */ { A1_OP_NAME, 0, "rtime" },
3674 : /* 21 */ { A1_OP_NAME, 0, "nonce" },
3675 : /* 22 */ { A1_OP_NAME, 0, "etype" },
3676 : /* 23 */ { A1_OP_NAME, 0, "addresses" },
3677 : /* 24 */ { A1_OP_NAME, 0, "enc-authorization-data" },
3678 : /* 25 */ { A1_OP_NAME, 0, "additional-tickets" }
3679 : };
3680 : /* generate_template_type: KDC_REQ_BODY */
3681 : const struct asn1_template asn1_KDC_REQ_BODY[] = {
3682 : /* 0 */ { 0|A1_HF_PRESERVE, sizeof(KDC_REQ_BODY), ((void *)(uintptr_t)1) },
3683 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDC_REQ_BODY_tag__140 }
3684 : };
3685 :
3686 : int ASN1CALL
3687 0 : decode_KDC_REQ_BODY(const unsigned char *p, size_t len, KDC_REQ_BODY *data, size_t *size)
3688 : {
3689 0 : memset(data, 0, sizeof(*data));
3690 0 : return _asn1_decode_top(asn1_KDC_REQ_BODY, 0|0, p, len, data, size);
3691 : }
3692 :
3693 :
3694 : int ASN1CALL
3695 36000 : encode_KDC_REQ_BODY(unsigned char *p, size_t len, const KDC_REQ_BODY *data, size_t *size)
3696 : {
3697 36000 : return _asn1_encode(asn1_KDC_REQ_BODY, p, len, data, size);
3698 : }
3699 :
3700 :
3701 : size_t ASN1CALL
3702 36000 : length_KDC_REQ_BODY(const KDC_REQ_BODY *data)
3703 : {
3704 36000 : return _asn1_length(asn1_KDC_REQ_BODY, data);
3705 : }
3706 :
3707 :
3708 : void ASN1CALL
3709 32155 : free_KDC_REQ_BODY(KDC_REQ_BODY *data)
3710 : {
3711 32155 : _asn1_free_top(asn1_KDC_REQ_BODY, data);
3712 32155 : }
3713 :
3714 :
3715 : int ASN1CALL
3716 68078 : copy_KDC_REQ_BODY(const KDC_REQ_BODY *from, KDC_REQ_BODY *to)
3717 : {
3718 68078 : return _asn1_copy_top(asn1_KDC_REQ_BODY, from, to);
3719 : }
3720 :
3721 :
3722 : char * ASN1CALL
3723 0 : print_KDC_REQ_BODY(const KDC_REQ_BODY *data, int flags)
3724 : {
3725 0 : return _asn1_print_top(asn1_KDC_REQ_BODY, flags, data);
3726 : }
3727 :
3728 : /* template_members: KDC_REQ exp exp */
3729 : /* tsequence: members isstruct: 1 */
3730 : /* template_members: KDC_REQ exp exp */
3731 : /* generate_template_type: KDC_REQ_tag_pvno_156 */
3732 : /* template_members: KDC_REQ exp exp */
3733 : /* generate_template_type: KDC_REQ_tag_msg_type_157 */
3734 : const struct asn1_template asn1_KDC_REQ_tag_msg_type_157[] = {
3735 : /* 0 */ { 0, sizeof(MESSAGE_TYPE), ((void *)(uintptr_t)1) },
3736 : /* 1 */ { A1_OP_TYPE , 0, asn1_MESSAGE_TYPE }
3737 : };
3738 : /* template_members: KDC_REQ exp exp */
3739 : /* generate_template_type: KDC_REQ_tag_padata_158 */
3740 : /* template_members: KDC_REQ exp exp */
3741 : /* generate_template_type: KDC_REQ_tag_req_body_159 */
3742 : const struct asn1_template asn1_KDC_REQ_tag_req_body_159[] = {
3743 : /* 0 */ { 0, sizeof(KDC_REQ_BODY), ((void *)(uintptr_t)1) },
3744 : /* 1 */ { A1_OP_TYPE , 0, asn1_KDC_REQ_BODY }
3745 : };
3746 : /* generate_template_type: KDC_REQ_tag__155 */
3747 : const struct asn1_template asn1_KDC_REQ_tag__155[] = {
3748 : /* 0 */ { 0, sizeof(struct KDC_REQ), ((void *)(uintptr_t)9) },
3749 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KDC_REQ, pvno), asn1_HostAddress_tag_addr_type_16 },
3750 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KDC_REQ, msg_type), asn1_KDC_REQ_tag_msg_type_157 },
3751 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REQ, padata), asn1_EncKDCRepPart_tag_encrypted_pa_data_83 },
3752 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct KDC_REQ, req_body), asn1_KDC_REQ_tag_req_body_159 },
3753 : /* 5 */ { A1_OP_NAME, 0, "KDC_REQ" },
3754 : /* 6 */ { A1_OP_NAME, 0, "pvno" },
3755 : /* 7 */ { A1_OP_NAME, 0, "msg-type" },
3756 : /* 8 */ { A1_OP_NAME, 0, "padata" },
3757 : /* 9 */ { A1_OP_NAME, 0, "req-body" }
3758 : };
3759 : /* generate_template_type: KDC_REQ */
3760 : const struct asn1_template asn1_KDC_REQ[] = {
3761 : /* 0 */ { 0, sizeof(KDC_REQ), ((void *)(uintptr_t)1) },
3762 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDC_REQ_tag__155 }
3763 : };
3764 :
3765 : int ASN1CALL
3766 0 : decode_KDC_REQ(const unsigned char *p, size_t len, KDC_REQ *data, size_t *size)
3767 : {
3768 0 : memset(data, 0, sizeof(*data));
3769 0 : return _asn1_decode_top(asn1_KDC_REQ, 0|0, p, len, data, size);
3770 : }
3771 :
3772 :
3773 : int ASN1CALL
3774 0 : encode_KDC_REQ(unsigned char *p, size_t len, const KDC_REQ *data, size_t *size)
3775 : {
3776 0 : return _asn1_encode(asn1_KDC_REQ, p, len, data, size);
3777 : }
3778 :
3779 :
3780 : size_t ASN1CALL
3781 0 : length_KDC_REQ(const KDC_REQ *data)
3782 : {
3783 0 : return _asn1_length(asn1_KDC_REQ, data);
3784 : }
3785 :
3786 :
3787 : void ASN1CALL
3788 0 : free_KDC_REQ(KDC_REQ *data)
3789 : {
3790 0 : _asn1_free_top(asn1_KDC_REQ, data);
3791 0 : }
3792 :
3793 :
3794 : int ASN1CALL
3795 0 : copy_KDC_REQ(const KDC_REQ *from, KDC_REQ *to)
3796 : {
3797 0 : return _asn1_copy_top(asn1_KDC_REQ, from, to);
3798 : }
3799 :
3800 :
3801 : char * ASN1CALL
3802 0 : print_KDC_REQ(const KDC_REQ *data, int flags)
3803 : {
3804 0 : return _asn1_print_top(asn1_KDC_REQ, flags, data);
3805 : }
3806 :
3807 : /* template_members: AS_REQ exp exp */
3808 : /* generate_template_type: AS_REQ_tag__160 */
3809 : const struct asn1_template asn1_AS_REQ_tag__160[] = {
3810 : /* 0 */ { 0, sizeof(KDC_REQ), ((void *)(uintptr_t)1) },
3811 : /* 1 */ { A1_OP_TYPE , 0, asn1_KDC_REQ }
3812 : };
3813 : /* generate_template_type: AS_REQ */
3814 : const struct asn1_template asn1_AS_REQ[] = {
3815 : /* 0 */ { 0, sizeof(AS_REQ), ((void *)(uintptr_t)1) },
3816 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,10), 0, asn1_AS_REQ_tag__160 }
3817 : };
3818 :
3819 : int ASN1CALL
3820 71176 : decode_AS_REQ(const unsigned char *p, size_t len, AS_REQ *data, size_t *size)
3821 : {
3822 71176 : memset(data, 0, sizeof(*data));
3823 71176 : return _asn1_decode_top(asn1_AS_REQ, 0|0, p, len, data, size);
3824 : }
3825 :
3826 :
3827 : int ASN1CALL
3828 20287 : encode_AS_REQ(unsigned char *p, size_t len, const AS_REQ *data, size_t *size)
3829 : {
3830 20287 : return _asn1_encode(asn1_AS_REQ, p, len, data, size);
3831 : }
3832 :
3833 :
3834 : size_t ASN1CALL
3835 20287 : length_AS_REQ(const AS_REQ *data)
3836 : {
3837 20287 : return _asn1_length(asn1_AS_REQ, data);
3838 : }
3839 :
3840 :
3841 : void ASN1CALL
3842 63289 : free_AS_REQ(AS_REQ *data)
3843 : {
3844 63289 : _asn1_free_top(asn1_AS_REQ, data);
3845 63289 : }
3846 :
3847 :
3848 : int ASN1CALL
3849 20263 : copy_AS_REQ(const AS_REQ *from, AS_REQ *to)
3850 : {
3851 20263 : return _asn1_copy_top(asn1_AS_REQ, from, to);
3852 : }
3853 :
3854 :
3855 : char * ASN1CALL
3856 0 : print_AS_REQ(const AS_REQ *data, int flags)
3857 : {
3858 0 : return _asn1_print_top(asn1_AS_REQ, flags, data);
3859 : }
3860 :
3861 : /* template_members: TGS_REQ exp exp */
3862 : /* generate_template_type: TGS_REQ_tag__161 */
3863 : /* generate_template_type: TGS_REQ */
3864 : const struct asn1_template asn1_TGS_REQ[] = {
3865 : /* 0 */ { 0, sizeof(TGS_REQ), ((void *)(uintptr_t)1) },
3866 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,12), 0, asn1_AS_REQ_tag__160 }
3867 : };
3868 :
3869 : int ASN1CALL
3870 38595 : decode_TGS_REQ(const unsigned char *p, size_t len, TGS_REQ *data, size_t *size)
3871 : {
3872 38595 : memset(data, 0, sizeof(*data));
3873 38595 : return _asn1_decode_top(asn1_TGS_REQ, 0|0, p, len, data, size);
3874 : }
3875 :
3876 :
3877 : int ASN1CALL
3878 35923 : encode_TGS_REQ(unsigned char *p, size_t len, const TGS_REQ *data, size_t *size)
3879 : {
3880 35923 : return _asn1_encode(asn1_TGS_REQ, p, len, data, size);
3881 : }
3882 :
3883 :
3884 : size_t ASN1CALL
3885 35923 : length_TGS_REQ(const TGS_REQ *data)
3886 : {
3887 35923 : return _asn1_length(asn1_TGS_REQ, data);
3888 : }
3889 :
3890 :
3891 : void ASN1CALL
3892 74518 : free_TGS_REQ(TGS_REQ *data)
3893 : {
3894 74518 : _asn1_free_top(asn1_TGS_REQ, data);
3895 74518 : }
3896 :
3897 :
3898 : int ASN1CALL
3899 0 : copy_TGS_REQ(const TGS_REQ *from, TGS_REQ *to)
3900 : {
3901 0 : return _asn1_copy_top(asn1_TGS_REQ, from, to);
3902 : }
3903 :
3904 :
3905 : char * ASN1CALL
3906 0 : print_TGS_REQ(const TGS_REQ *data, int flags)
3907 : {
3908 0 : return _asn1_print_top(asn1_TGS_REQ, flags, data);
3909 : }
3910 :
3911 : /* template_members: PA_ENC_TS_ENC exp exp */
3912 : /* tsequence: members isstruct: 1 */
3913 : /* template_members: PA_ENC_TS_ENC exp exp */
3914 : /* generate_template_type: PA_ENC_TS_ENC_tag_patimestamp_163 */
3915 : /* template_members: PA_ENC_TS_ENC exp exp */
3916 : /* generate_template_type: PA_ENC_TS_ENC_tag_pausec_164 */
3917 : /* generate_template_type: PA_ENC_TS_ENC_tag__162 */
3918 : const struct asn1_template asn1_PA_ENC_TS_ENC_tag__162[] = {
3919 : /* 0 */ { 0, sizeof(struct PA_ENC_TS_ENC), ((void *)(uintptr_t)5) },
3920 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_ENC_TS_ENC, patimestamp), asn1_LastReq_val_tag_lr_value_33 },
3921 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct PA_ENC_TS_ENC, pausec), asn1_HostAddress_tag_addr_type_16 },
3922 : /* 3 */ { A1_OP_NAME, 0, "PA_ENC_TS_ENC" },
3923 : /* 4 */ { A1_OP_NAME, 0, "patimestamp" },
3924 : /* 5 */ { A1_OP_NAME, 0, "pausec" }
3925 : };
3926 : /* generate_template_type: PA_ENC_TS_ENC */
3927 : const struct asn1_template asn1_PA_ENC_TS_ENC[] = {
3928 : /* 0 */ { 0, sizeof(PA_ENC_TS_ENC), ((void *)(uintptr_t)1) },
3929 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_ENC_TS_ENC_tag__162 }
3930 : };
3931 :
3932 : int ASN1CALL
3933 18421 : decode_PA_ENC_TS_ENC(const unsigned char *p, size_t len, PA_ENC_TS_ENC *data, size_t *size)
3934 : {
3935 18421 : memset(data, 0, sizeof(*data));
3936 18421 : return _asn1_decode_top(asn1_PA_ENC_TS_ENC, 0|0, p, len, data, size);
3937 : }
3938 :
3939 :
3940 : int ASN1CALL
3941 9499 : encode_PA_ENC_TS_ENC(unsigned char *p, size_t len, const PA_ENC_TS_ENC *data, size_t *size)
3942 : {
3943 9499 : return _asn1_encode(asn1_PA_ENC_TS_ENC, p, len, data, size);
3944 : }
3945 :
3946 :
3947 : size_t ASN1CALL
3948 9499 : length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *data)
3949 : {
3950 9499 : return _asn1_length(asn1_PA_ENC_TS_ENC, data);
3951 : }
3952 :
3953 :
3954 : void ASN1CALL
3955 18421 : free_PA_ENC_TS_ENC(PA_ENC_TS_ENC *data)
3956 : {
3957 18421 : _asn1_free_top(asn1_PA_ENC_TS_ENC, data);
3958 18421 : }
3959 :
3960 :
3961 : int ASN1CALL
3962 0 : copy_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *from, PA_ENC_TS_ENC *to)
3963 : {
3964 0 : return _asn1_copy_top(asn1_PA_ENC_TS_ENC, from, to);
3965 : }
3966 :
3967 :
3968 : char * ASN1CALL
3969 0 : print_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *data, int flags)
3970 : {
3971 0 : return _asn1_print_top(asn1_PA_ENC_TS_ENC, flags, data);
3972 : }
3973 :
3974 : /* template_members: PA_PAC_REQUEST exp exp */
3975 : /* tsequence: members isstruct: 1 */
3976 : /* template_members: PA_PAC_REQUEST exp exp */
3977 : /* template_members: int exp exp */
3978 : /* generate_template_type: int_tag_include_pac_167 */
3979 : /* generate_template_type: PA_PAC_REQUEST_tag_include_pac_166 */
3980 : /* generate_template_type: PA_PAC_REQUEST_tag__165 */
3981 : const struct asn1_template asn1_PA_PAC_REQUEST_tag__165[] = {
3982 : /* 0 */ { 0, sizeof(struct PA_PAC_REQUEST), ((void *)(uintptr_t)3) },
3983 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_PAC_REQUEST, include_pac), asn1_PrincipalNameAttrs_tag_authenticated_87 },
3984 : /* 2 */ { A1_OP_NAME, 0, "PA_PAC_REQUEST" },
3985 : /* 3 */ { A1_OP_NAME, 0, "include-pac" }
3986 : };
3987 : /* generate_template_type: PA_PAC_REQUEST */
3988 : const struct asn1_template asn1_PA_PAC_REQUEST[] = {
3989 : /* 0 */ { 0, sizeof(PA_PAC_REQUEST), ((void *)(uintptr_t)1) },
3990 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_PAC_REQUEST_tag__165 }
3991 : };
3992 :
3993 : int ASN1CALL
3994 404 : decode_PA_PAC_REQUEST(const unsigned char *p, size_t len, PA_PAC_REQUEST *data, size_t *size)
3995 : {
3996 404 : memset(data, 0, sizeof(*data));
3997 404 : return _asn1_decode_top(asn1_PA_PAC_REQUEST, 0|0, p, len, data, size);
3998 : }
3999 :
4000 :
4001 : int ASN1CALL
4002 956 : encode_PA_PAC_REQUEST(unsigned char *p, size_t len, const PA_PAC_REQUEST *data, size_t *size)
4003 : {
4004 956 : return _asn1_encode(asn1_PA_PAC_REQUEST, p, len, data, size);
4005 : }
4006 :
4007 :
4008 : size_t ASN1CALL
4009 956 : length_PA_PAC_REQUEST(const PA_PAC_REQUEST *data)
4010 : {
4011 956 : return _asn1_length(asn1_PA_PAC_REQUEST, data);
4012 : }
4013 :
4014 :
4015 : void ASN1CALL
4016 404 : free_PA_PAC_REQUEST(PA_PAC_REQUEST *data)
4017 : {
4018 404 : _asn1_free_top(asn1_PA_PAC_REQUEST, data);
4019 404 : }
4020 :
4021 :
4022 : int ASN1CALL
4023 0 : copy_PA_PAC_REQUEST(const PA_PAC_REQUEST *from, PA_PAC_REQUEST *to)
4024 : {
4025 0 : return _asn1_copy_top(asn1_PA_PAC_REQUEST, from, to);
4026 : }
4027 :
4028 :
4029 : char * ASN1CALL
4030 0 : print_PA_PAC_REQUEST(const PA_PAC_REQUEST *data, int flags)
4031 : {
4032 0 : return _asn1_print_top(asn1_PA_PAC_REQUEST, flags, data);
4033 : }
4034 :
4035 : /* template_members: PAC_OPTIONS_FLAGS exp exp */
4036 : static const struct asn1_template asn1_PAC_OPTIONS_FLAGS_bmember__3[] = {
4037 : /* 0 */ { 0|A1_HBF_RFC1510, sizeof(PAC_OPTIONS_FLAGS), ((void *)(uintptr_t)4) },
4038 : /* 1 */ { 0, 0, "claims" },
4039 : /* 2 */ { 0, 1, "branch_aware" },
4040 : /* 3 */ { 0, 2, "forward_to_full_dc" },
4041 : /* 4 */ { 0, 3, "resource_based_constrained_delegation" }
4042 : };
4043 : /* generate_template_type: PAC_OPTIONS_FLAGS_tag__168 */
4044 : const struct asn1_template asn1_PAC_OPTIONS_FLAGS_tag__168[] = {
4045 : /* 0 */ { 0, sizeof(PAC_OPTIONS_FLAGS), ((void *)(uintptr_t)1) },
4046 : /* 1 */ { A1_OP_BMEMBER, 0, asn1_PAC_OPTIONS_FLAGS_bmember__3 }
4047 : };
4048 : /* generate_template_type: PAC_OPTIONS_FLAGS */
4049 : const struct asn1_template asn1_PAC_OPTIONS_FLAGS[] = {
4050 : /* 0 */ { 0, sizeof(PAC_OPTIONS_FLAGS), ((void *)(uintptr_t)1) },
4051 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_BitString), 0, asn1_PAC_OPTIONS_FLAGS_tag__168 }
4052 : };
4053 :
4054 : int ASN1CALL
4055 0 : decode_PAC_OPTIONS_FLAGS(const unsigned char *p, size_t len, PAC_OPTIONS_FLAGS *data, size_t *size)
4056 : {
4057 0 : memset(data, 0, sizeof(*data));
4058 0 : return _asn1_decode_top(asn1_PAC_OPTIONS_FLAGS, 0|0, p, len, data, size);
4059 : }
4060 :
4061 :
4062 : int ASN1CALL
4063 0 : encode_PAC_OPTIONS_FLAGS(unsigned char *p, size_t len, const PAC_OPTIONS_FLAGS *data, size_t *size)
4064 : {
4065 0 : return _asn1_encode(asn1_PAC_OPTIONS_FLAGS, p, len, data, size);
4066 : }
4067 :
4068 :
4069 : size_t ASN1CALL
4070 0 : length_PAC_OPTIONS_FLAGS(const PAC_OPTIONS_FLAGS *data)
4071 : {
4072 0 : return _asn1_length(asn1_PAC_OPTIONS_FLAGS, data);
4073 : }
4074 :
4075 :
4076 : void ASN1CALL
4077 0 : free_PAC_OPTIONS_FLAGS(PAC_OPTIONS_FLAGS *data)
4078 : {
4079 0 : _asn1_free_top(asn1_PAC_OPTIONS_FLAGS, data);
4080 0 : }
4081 :
4082 :
4083 : int ASN1CALL
4084 0 : copy_PAC_OPTIONS_FLAGS(const PAC_OPTIONS_FLAGS *from, PAC_OPTIONS_FLAGS *to)
4085 : {
4086 0 : return _asn1_copy_top(asn1_PAC_OPTIONS_FLAGS, from, to);
4087 : }
4088 :
4089 :
4090 : char * ASN1CALL
4091 0 : print_PAC_OPTIONS_FLAGS(const PAC_OPTIONS_FLAGS *data, int flags)
4092 : {
4093 0 : return _asn1_print_top(asn1_PAC_OPTIONS_FLAGS, flags, data);
4094 : }
4095 :
4096 0 : uint64_t PAC_OPTIONS_FLAGS2int(PAC_OPTIONS_FLAGS f)
4097 : {
4098 0 : uint64_t r = 0;
4099 0 : if(f.claims) r |= (1ULL << 0);
4100 0 : if(f.branch_aware) r |= (1ULL << 1);
4101 0 : if(f.forward_to_full_dc) r |= (1ULL << 2);
4102 0 : if(f.resource_based_constrained_delegation) r |= (1ULL << 3);
4103 0 : return r;
4104 : }
4105 :
4106 0 : PAC_OPTIONS_FLAGS int2PAC_OPTIONS_FLAGS(uint64_t n)
4107 : {
4108 : PAC_OPTIONS_FLAGS flags;
4109 :
4110 0 : memset(&flags, 0, sizeof(flags));
4111 :
4112 0 : flags.claims = (n >> 0) & 1;
4113 0 : flags.branch_aware = (n >> 1) & 1;
4114 0 : flags.forward_to_full_dc = (n >> 2) & 1;
4115 0 : flags.resource_based_constrained_delegation = (n >> 3) & 1;
4116 0 : return flags;
4117 : }
4118 :
4119 : static struct units PAC_OPTIONS_FLAGS_units[] = {
4120 : {"resource-based-constrained-delegation", 1ULL << 3},
4121 : {"forward-to-full-dc", 1ULL << 2},
4122 : {"branch-aware", 1ULL << 1},
4123 : {"claims", 1ULL << 0},
4124 : {NULL, 0}
4125 : };
4126 :
4127 0 : const struct units * asn1_PAC_OPTIONS_FLAGS_units(void){
4128 0 : return PAC_OPTIONS_FLAGS_units;
4129 : }
4130 :
4131 : /* template_members: PA_PAC_OPTIONS exp exp */
4132 : /* tsequence: members isstruct: 1 */
4133 : /* template_members: PA_PAC_OPTIONS exp exp */
4134 : /* generate_template_type: PA_PAC_OPTIONS_tag_flags_170 */
4135 : const struct asn1_template asn1_PA_PAC_OPTIONS_tag_flags_170[] = {
4136 : /* 0 */ { 0, sizeof(PAC_OPTIONS_FLAGS), ((void *)(uintptr_t)1) },
4137 : /* 1 */ { A1_OP_TYPE , 0, asn1_PAC_OPTIONS_FLAGS }
4138 : };
4139 : /* generate_template_type: PA_PAC_OPTIONS_tag__169 */
4140 : const struct asn1_template asn1_PA_PAC_OPTIONS_tag__169[] = {
4141 : /* 0 */ { 0, sizeof(struct PA_PAC_OPTIONS), ((void *)(uintptr_t)3) },
4142 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_PAC_OPTIONS, flags), asn1_PA_PAC_OPTIONS_tag_flags_170 },
4143 : /* 2 */ { A1_OP_NAME, 0, "PA_PAC_OPTIONS" },
4144 : /* 3 */ { A1_OP_NAME, 0, "flags" }
4145 : };
4146 : /* generate_template_type: PA_PAC_OPTIONS */
4147 : const struct asn1_template asn1_PA_PAC_OPTIONS[] = {
4148 : /* 0 */ { 0, sizeof(PA_PAC_OPTIONS), ((void *)(uintptr_t)1) },
4149 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_PAC_OPTIONS_tag__169 }
4150 : };
4151 :
4152 : int ASN1CALL
4153 0 : decode_PA_PAC_OPTIONS(const unsigned char *p, size_t len, PA_PAC_OPTIONS *data, size_t *size)
4154 : {
4155 0 : memset(data, 0, sizeof(*data));
4156 0 : return _asn1_decode_top(asn1_PA_PAC_OPTIONS, 0|0, p, len, data, size);
4157 : }
4158 :
4159 :
4160 : int ASN1CALL
4161 0 : encode_PA_PAC_OPTIONS(unsigned char *p, size_t len, const PA_PAC_OPTIONS *data, size_t *size)
4162 : {
4163 0 : return _asn1_encode(asn1_PA_PAC_OPTIONS, p, len, data, size);
4164 : }
4165 :
4166 :
4167 : size_t ASN1CALL
4168 0 : length_PA_PAC_OPTIONS(const PA_PAC_OPTIONS *data)
4169 : {
4170 0 : return _asn1_length(asn1_PA_PAC_OPTIONS, data);
4171 : }
4172 :
4173 :
4174 : void ASN1CALL
4175 0 : free_PA_PAC_OPTIONS(PA_PAC_OPTIONS *data)
4176 : {
4177 0 : _asn1_free_top(asn1_PA_PAC_OPTIONS, data);
4178 0 : }
4179 :
4180 :
4181 : int ASN1CALL
4182 0 : copy_PA_PAC_OPTIONS(const PA_PAC_OPTIONS *from, PA_PAC_OPTIONS *to)
4183 : {
4184 0 : return _asn1_copy_top(asn1_PA_PAC_OPTIONS, from, to);
4185 : }
4186 :
4187 :
4188 : char * ASN1CALL
4189 0 : print_PA_PAC_OPTIONS(const PA_PAC_OPTIONS *data, int flags)
4190 : {
4191 0 : return _asn1_print_top(asn1_PA_PAC_OPTIONS, flags, data);
4192 : }
4193 :
4194 : /* template_members: KERB_AD_RESTRICTION_ENTRY exp exp */
4195 : /* template_members: KERB_AD_RESTRICTION_ENTRY exp exp */
4196 : /* tsequence: members isstruct: 1 */
4197 : /* template_members: KERB_AD_RESTRICTION_ENTRY exp exp */
4198 : /* generate_template_type: KERB_AD_RESTRICTION_ENTRY_tag_restriction_type_173 */
4199 : /* template_members: KERB_AD_RESTRICTION_ENTRY exp exp */
4200 : /* template_members: heim_octet_string exp exp */
4201 : /* generate_template_type: heim_octet_string_tag_restriction_175 */
4202 : /* generate_template_type: KERB_AD_RESTRICTION_ENTRY_tag_restriction_174 */
4203 : /* generate_template_type: KERB_AD_RESTRICTION_ENTRY_tag__172 */
4204 : const struct asn1_template asn1_KERB_AD_RESTRICTION_ENTRY_tag__172[] = {
4205 : /* 0 */ { 0, sizeof(struct KERB_AD_RESTRICTION_ENTRY), ((void *)(uintptr_t)5) },
4206 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KERB_AD_RESTRICTION_ENTRY, restriction_type), asn1_HostAddress_tag_addr_type_16 },
4207 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KERB_AD_RESTRICTION_ENTRY, restriction), asn1_HostAddress_tag_address_17 },
4208 : /* 3 */ { A1_OP_NAME, 0, "KERB_AD_RESTRICTION_ENTRY" },
4209 : /* 4 */ { A1_OP_NAME, 0, "restriction-type" },
4210 : /* 5 */ { A1_OP_NAME, 0, "restriction" }
4211 : };
4212 : /* generate_template_type: KERB_AD_RESTRICTION_ENTRY_tag__171 */
4213 : const struct asn1_template asn1_KERB_AD_RESTRICTION_ENTRY_tag__171[] = {
4214 : /* 0 */ { 0, sizeof(struct KERB_AD_RESTRICTION_ENTRY), ((void *)(uintptr_t)1) },
4215 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_AD_RESTRICTION_ENTRY_tag__172 }
4216 : };
4217 : /* generate_template_type: KERB_AD_RESTRICTION_ENTRY */
4218 : const struct asn1_template asn1_KERB_AD_RESTRICTION_ENTRY[] = {
4219 : /* 0 */ { 0, sizeof(KERB_AD_RESTRICTION_ENTRY), ((void *)(uintptr_t)1) },
4220 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_AD_RESTRICTION_ENTRY_tag__171 }
4221 : };
4222 :
4223 : int ASN1CALL
4224 0 : decode_KERB_AD_RESTRICTION_ENTRY(const unsigned char *p, size_t len, KERB_AD_RESTRICTION_ENTRY *data, size_t *size)
4225 : {
4226 0 : memset(data, 0, sizeof(*data));
4227 0 : return _asn1_decode_top(asn1_KERB_AD_RESTRICTION_ENTRY, 0|0, p, len, data, size);
4228 : }
4229 :
4230 :
4231 : int ASN1CALL
4232 0 : encode_KERB_AD_RESTRICTION_ENTRY(unsigned char *p, size_t len, const KERB_AD_RESTRICTION_ENTRY *data, size_t *size)
4233 : {
4234 0 : return _asn1_encode(asn1_KERB_AD_RESTRICTION_ENTRY, p, len, data, size);
4235 : }
4236 :
4237 :
4238 : size_t ASN1CALL
4239 0 : length_KERB_AD_RESTRICTION_ENTRY(const KERB_AD_RESTRICTION_ENTRY *data)
4240 : {
4241 0 : return _asn1_length(asn1_KERB_AD_RESTRICTION_ENTRY, data);
4242 : }
4243 :
4244 :
4245 : void ASN1CALL
4246 0 : free_KERB_AD_RESTRICTION_ENTRY(KERB_AD_RESTRICTION_ENTRY *data)
4247 : {
4248 0 : _asn1_free_top(asn1_KERB_AD_RESTRICTION_ENTRY, data);
4249 0 : }
4250 :
4251 :
4252 : int ASN1CALL
4253 0 : copy_KERB_AD_RESTRICTION_ENTRY(const KERB_AD_RESTRICTION_ENTRY *from, KERB_AD_RESTRICTION_ENTRY *to)
4254 : {
4255 0 : return _asn1_copy_top(asn1_KERB_AD_RESTRICTION_ENTRY, from, to);
4256 : }
4257 :
4258 :
4259 : char * ASN1CALL
4260 0 : print_KERB_AD_RESTRICTION_ENTRY(const KERB_AD_RESTRICTION_ENTRY *data, int flags)
4261 : {
4262 0 : return _asn1_print_top(asn1_KERB_AD_RESTRICTION_ENTRY, flags, data);
4263 : }
4264 :
4265 : /* template_members: PA_KERB_KEY_LIST_REQ exp exp */
4266 : /* generate_template_type: ENCTYPE_seofTstruct_11 */
4267 : /* generate_template_type: PA_KERB_KEY_LIST_REQ_tag__176 */
4268 : const struct asn1_template asn1_PA_KERB_KEY_LIST_REQ_tag__176[] = {
4269 : /* 0 */ { 0, sizeof(ENCTYPE), ((void *)(uintptr_t)1) },
4270 : /* 1 */ { A1_OP_SEQOF, 0, asn1_EncryptedData_tag_etype_35 }
4271 : };
4272 : /* generate_template_type: PA_KERB_KEY_LIST_REQ */
4273 : const struct asn1_template asn1_PA_KERB_KEY_LIST_REQ[] = {
4274 : /* 0 */ { 0, sizeof(PA_KERB_KEY_LIST_REQ), ((void *)(uintptr_t)1) },
4275 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_KERB_KEY_LIST_REQ_tag__176 }
4276 : };
4277 :
4278 : int ASN1CALL
4279 0 : decode_PA_KERB_KEY_LIST_REQ(const unsigned char *p, size_t len, PA_KERB_KEY_LIST_REQ *data, size_t *size)
4280 : {
4281 0 : memset(data, 0, sizeof(*data));
4282 0 : return _asn1_decode_top(asn1_PA_KERB_KEY_LIST_REQ, 0|0, p, len, data, size);
4283 : }
4284 :
4285 :
4286 : int ASN1CALL
4287 0 : encode_PA_KERB_KEY_LIST_REQ(unsigned char *p, size_t len, const PA_KERB_KEY_LIST_REQ *data, size_t *size)
4288 : {
4289 0 : return _asn1_encode(asn1_PA_KERB_KEY_LIST_REQ, p, len, data, size);
4290 : }
4291 :
4292 :
4293 : size_t ASN1CALL
4294 0 : length_PA_KERB_KEY_LIST_REQ(const PA_KERB_KEY_LIST_REQ *data)
4295 : {
4296 0 : return _asn1_length(asn1_PA_KERB_KEY_LIST_REQ, data);
4297 : }
4298 :
4299 :
4300 : void ASN1CALL
4301 0 : free_PA_KERB_KEY_LIST_REQ(PA_KERB_KEY_LIST_REQ *data)
4302 : {
4303 0 : _asn1_free_top(asn1_PA_KERB_KEY_LIST_REQ, data);
4304 0 : }
4305 :
4306 :
4307 : int ASN1CALL
4308 0 : copy_PA_KERB_KEY_LIST_REQ(const PA_KERB_KEY_LIST_REQ *from, PA_KERB_KEY_LIST_REQ *to)
4309 : {
4310 0 : return _asn1_copy_top(asn1_PA_KERB_KEY_LIST_REQ, from, to);
4311 : }
4312 :
4313 :
4314 : char * ASN1CALL
4315 0 : print_PA_KERB_KEY_LIST_REQ(const PA_KERB_KEY_LIST_REQ *data, int flags)
4316 : {
4317 0 : return _asn1_print_top(asn1_PA_KERB_KEY_LIST_REQ, flags, data);
4318 : }
4319 :
4320 : /* template_members: PA_KERB_KEY_LIST_REP exp exp */
4321 : /* generate_template_type: ENCTYPE_seofTstruct_12 */
4322 : /* generate_template_type: PA_KERB_KEY_LIST_REP_tag__177 */
4323 : /* generate_template_type: PA_KERB_KEY_LIST_REP */
4324 : const struct asn1_template asn1_PA_KERB_KEY_LIST_REP[] = {
4325 : /* 0 */ { 0, sizeof(PA_KERB_KEY_LIST_REP), ((void *)(uintptr_t)1) },
4326 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_KERB_KEY_LIST_REQ_tag__176 }
4327 : };
4328 :
4329 : int ASN1CALL
4330 0 : decode_PA_KERB_KEY_LIST_REP(const unsigned char *p, size_t len, PA_KERB_KEY_LIST_REP *data, size_t *size)
4331 : {
4332 0 : memset(data, 0, sizeof(*data));
4333 0 : return _asn1_decode_top(asn1_PA_KERB_KEY_LIST_REP, 0|0, p, len, data, size);
4334 : }
4335 :
4336 :
4337 : int ASN1CALL
4338 0 : encode_PA_KERB_KEY_LIST_REP(unsigned char *p, size_t len, const PA_KERB_KEY_LIST_REP *data, size_t *size)
4339 : {
4340 0 : return _asn1_encode(asn1_PA_KERB_KEY_LIST_REP, p, len, data, size);
4341 : }
4342 :
4343 :
4344 : size_t ASN1CALL
4345 0 : length_PA_KERB_KEY_LIST_REP(const PA_KERB_KEY_LIST_REP *data)
4346 : {
4347 0 : return _asn1_length(asn1_PA_KERB_KEY_LIST_REP, data);
4348 : }
4349 :
4350 :
4351 : void ASN1CALL
4352 0 : free_PA_KERB_KEY_LIST_REP(PA_KERB_KEY_LIST_REP *data)
4353 : {
4354 0 : _asn1_free_top(asn1_PA_KERB_KEY_LIST_REP, data);
4355 0 : }
4356 :
4357 :
4358 : int ASN1CALL
4359 0 : copy_PA_KERB_KEY_LIST_REP(const PA_KERB_KEY_LIST_REP *from, PA_KERB_KEY_LIST_REP *to)
4360 : {
4361 0 : return _asn1_copy_top(asn1_PA_KERB_KEY_LIST_REP, from, to);
4362 : }
4363 :
4364 :
4365 : char * ASN1CALL
4366 0 : print_PA_KERB_KEY_LIST_REP(const PA_KERB_KEY_LIST_REP *data, int flags)
4367 : {
4368 0 : return _asn1_print_top(asn1_PA_KERB_KEY_LIST_REP, flags, data);
4369 : }
4370 :
4371 : /* template_members: PROV_SRV_LOCATION exp exp */
4372 : /* generate_template_type: PROV_SRV_LOCATION_tag__178 */
4373 : /* generate_template_type: PROV_SRV_LOCATION */
4374 : const struct asn1_template asn1_PROV_SRV_LOCATION[] = {
4375 : /* 0 */ { 0, sizeof(PROV_SRV_LOCATION), ((void *)(uintptr_t)1) },
4376 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_GeneralString), 0, asn1_KerberosString_tag__8 }
4377 : };
4378 :
4379 : int ASN1CALL
4380 0 : decode_PROV_SRV_LOCATION(const unsigned char *p, size_t len, PROV_SRV_LOCATION *data, size_t *size)
4381 : {
4382 0 : memset(data, 0, sizeof(*data));
4383 0 : return _asn1_decode_top(asn1_PROV_SRV_LOCATION, 0|0, p, len, data, size);
4384 : }
4385 :
4386 :
4387 : int ASN1CALL
4388 0 : encode_PROV_SRV_LOCATION(unsigned char *p, size_t len, const PROV_SRV_LOCATION *data, size_t *size)
4389 : {
4390 0 : return _asn1_encode(asn1_PROV_SRV_LOCATION, p, len, data, size);
4391 : }
4392 :
4393 :
4394 : size_t ASN1CALL
4395 0 : length_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *data)
4396 : {
4397 0 : return _asn1_length(asn1_PROV_SRV_LOCATION, data);
4398 : }
4399 :
4400 :
4401 : void ASN1CALL
4402 0 : free_PROV_SRV_LOCATION(PROV_SRV_LOCATION *data)
4403 : {
4404 0 : _asn1_free_top(asn1_PROV_SRV_LOCATION, data);
4405 0 : }
4406 :
4407 :
4408 : int ASN1CALL
4409 0 : copy_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *from, PROV_SRV_LOCATION *to)
4410 : {
4411 0 : return _asn1_copy_top(asn1_PROV_SRV_LOCATION, from, to);
4412 : }
4413 :
4414 :
4415 : char * ASN1CALL
4416 0 : print_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *data, int flags)
4417 : {
4418 0 : return _asn1_print_top(asn1_PROV_SRV_LOCATION, flags, data);
4419 : }
4420 :
4421 : /* template_members: KDC_REP exp exp */
4422 : /* tsequence: members isstruct: 1 */
4423 : /* template_members: KDC_REP exp exp */
4424 : /* generate_template_type: KDC_REP_tag_pvno_180 */
4425 : /* template_members: KDC_REP exp exp */
4426 : /* generate_template_type: KDC_REP_tag_msg_type_181 */
4427 : /* template_members: KDC_REP exp exp */
4428 : /* generate_template_type: KDC_REP_tag_padata_182 */
4429 : /* template_members: KDC_REP exp exp */
4430 : /* generate_template_type: KDC_REP_tag_crealm_183 */
4431 : /* template_members: KDC_REP exp exp */
4432 : /* generate_template_type: KDC_REP_tag_cname_184 */
4433 : /* template_members: KDC_REP exp exp */
4434 : /* generate_template_type: KDC_REP_tag_ticket_185 */
4435 : /* template_members: KDC_REP exp exp */
4436 : /* generate_template_type: KDC_REP_tag_enc_part_186 */
4437 : /* generate_template_type: KDC_REP_tag__179 */
4438 : const struct asn1_template asn1_KDC_REP_tag__179[] = {
4439 : /* 0 */ { 0, sizeof(struct KDC_REP), ((void *)(uintptr_t)15) },
4440 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KDC_REP, pvno), asn1_HostAddress_tag_addr_type_16 },
4441 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KDC_REP, msg_type), asn1_KDC_REQ_tag_msg_type_157 },
4442 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct KDC_REP, padata), asn1_EncKDCRepPart_tag_encrypted_pa_data_83 },
4443 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KDC_REP, crealm), asn1_Ticket_tag_realm_50 },
4444 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct KDC_REP, cname), asn1_Ticket_tag_sname_51 },
4445 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5), offsetof(struct KDC_REP, ticket), asn1_KDC_REQ_BODY_additional_tickets_10 },
4446 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6), offsetof(struct KDC_REP, enc_part), asn1_Ticket_tag_enc_part_52 },
4447 : /* 8 */ { A1_OP_NAME, 0, "KDC_REP" },
4448 : /* 9 */ { A1_OP_NAME, 0, "pvno" },
4449 : /* 10 */ { A1_OP_NAME, 0, "msg-type" },
4450 : /* 11 */ { A1_OP_NAME, 0, "padata" },
4451 : /* 12 */ { A1_OP_NAME, 0, "crealm" },
4452 : /* 13 */ { A1_OP_NAME, 0, "cname" },
4453 : /* 14 */ { A1_OP_NAME, 0, "ticket" },
4454 : /* 15 */ { A1_OP_NAME, 0, "enc-part" }
4455 : };
4456 : /* generate_template_type: KDC_REP */
4457 : const struct asn1_template asn1_KDC_REP[] = {
4458 : /* 0 */ { 0, sizeof(KDC_REP), ((void *)(uintptr_t)1) },
4459 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDC_REP_tag__179 }
4460 : };
4461 :
4462 : int ASN1CALL
4463 0 : decode_KDC_REP(const unsigned char *p, size_t len, KDC_REP *data, size_t *size)
4464 : {
4465 0 : memset(data, 0, sizeof(*data));
4466 0 : return _asn1_decode_top(asn1_KDC_REP, 0|0, p, len, data, size);
4467 : }
4468 :
4469 :
4470 : int ASN1CALL
4471 0 : encode_KDC_REP(unsigned char *p, size_t len, const KDC_REP *data, size_t *size)
4472 : {
4473 0 : return _asn1_encode(asn1_KDC_REP, p, len, data, size);
4474 : }
4475 :
4476 :
4477 : size_t ASN1CALL
4478 0 : length_KDC_REP(const KDC_REP *data)
4479 : {
4480 0 : return _asn1_length(asn1_KDC_REP, data);
4481 : }
4482 :
4483 :
4484 : void ASN1CALL
4485 35923 : free_KDC_REP(KDC_REP *data)
4486 : {
4487 35923 : _asn1_free_top(asn1_KDC_REP, data);
4488 35923 : }
4489 :
4490 :
4491 : int ASN1CALL
4492 0 : copy_KDC_REP(const KDC_REP *from, KDC_REP *to)
4493 : {
4494 0 : return _asn1_copy_top(asn1_KDC_REP, from, to);
4495 : }
4496 :
4497 :
4498 : char * ASN1CALL
4499 0 : print_KDC_REP(const KDC_REP *data, int flags)
4500 : {
4501 0 : return _asn1_print_top(asn1_KDC_REP, flags, data);
4502 : }
4503 :
4504 : /* template_members: AS_REP exp exp */
4505 : /* generate_template_type: AS_REP_tag__187 */
4506 : const struct asn1_template asn1_AS_REP_tag__187[] = {
4507 : /* 0 */ { 0, sizeof(KDC_REP), ((void *)(uintptr_t)1) },
4508 : /* 1 */ { A1_OP_TYPE , 0, asn1_KDC_REP }
4509 : };
4510 : /* generate_template_type: AS_REP */
4511 : const struct asn1_template asn1_AS_REP[] = {
4512 : /* 0 */ { 0, sizeof(AS_REP), ((void *)(uintptr_t)1) },
4513 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,11), 0, asn1_AS_REP_tag__187 }
4514 : };
4515 :
4516 : int ASN1CALL
4517 19713 : decode_AS_REP(const unsigned char *p, size_t len, AS_REP *data, size_t *size)
4518 : {
4519 19713 : memset(data, 0, sizeof(*data));
4520 19713 : return _asn1_decode_top(asn1_AS_REP, 0|0, p, len, data, size);
4521 : }
4522 :
4523 :
4524 : int ASN1CALL
4525 18343 : encode_AS_REP(unsigned char *p, size_t len, const AS_REP *data, size_t *size)
4526 : {
4527 18343 : return _asn1_encode(asn1_AS_REP, p, len, data, size);
4528 : }
4529 :
4530 :
4531 : size_t ASN1CALL
4532 18343 : length_AS_REP(const AS_REP *data)
4533 : {
4534 18343 : return _asn1_length(asn1_AS_REP, data);
4535 : }
4536 :
4537 :
4538 : void ASN1CALL
4539 41677 : free_AS_REP(AS_REP *data)
4540 : {
4541 41677 : _asn1_free_top(asn1_AS_REP, data);
4542 41677 : }
4543 :
4544 :
4545 : int ASN1CALL
4546 0 : copy_AS_REP(const AS_REP *from, AS_REP *to)
4547 : {
4548 0 : return _asn1_copy_top(asn1_AS_REP, from, to);
4549 : }
4550 :
4551 :
4552 : char * ASN1CALL
4553 0 : print_AS_REP(const AS_REP *data, int flags)
4554 : {
4555 0 : return _asn1_print_top(asn1_AS_REP, flags, data);
4556 : }
4557 :
4558 : /* template_members: TGS_REP exp exp */
4559 : /* generate_template_type: TGS_REP_tag__188 */
4560 : /* generate_template_type: TGS_REP */
4561 : const struct asn1_template asn1_TGS_REP[] = {
4562 : /* 0 */ { 0, sizeof(TGS_REP), ((void *)(uintptr_t)1) },
4563 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,13), 0, asn1_AS_REP_tag__187 }
4564 : };
4565 :
4566 : int ASN1CALL
4567 35635 : decode_TGS_REP(const unsigned char *p, size_t len, TGS_REP *data, size_t *size)
4568 : {
4569 35635 : memset(data, 0, sizeof(*data));
4570 35635 : return _asn1_decode_top(asn1_TGS_REP, 0|0, p, len, data, size);
4571 : }
4572 :
4573 :
4574 : int ASN1CALL
4575 35728 : encode_TGS_REP(unsigned char *p, size_t len, const TGS_REP *data, size_t *size)
4576 : {
4577 35728 : return _asn1_encode(asn1_TGS_REP, p, len, data, size);
4578 : }
4579 :
4580 :
4581 : size_t ASN1CALL
4582 35728 : length_TGS_REP(const TGS_REP *data)
4583 : {
4584 35728 : return _asn1_length(asn1_TGS_REP, data);
4585 : }
4586 :
4587 :
4588 : void ASN1CALL
4589 38595 : free_TGS_REP(TGS_REP *data)
4590 : {
4591 38595 : _asn1_free_top(asn1_TGS_REP, data);
4592 38595 : }
4593 :
4594 :
4595 : int ASN1CALL
4596 0 : copy_TGS_REP(const TGS_REP *from, TGS_REP *to)
4597 : {
4598 0 : return _asn1_copy_top(asn1_TGS_REP, from, to);
4599 : }
4600 :
4601 :
4602 : char * ASN1CALL
4603 0 : print_TGS_REP(const TGS_REP *data, int flags)
4604 : {
4605 0 : return _asn1_print_top(asn1_TGS_REP, flags, data);
4606 : }
4607 :
4608 : /* template_members: EncASRepPart exp exp */
4609 : /* generate_template_type: EncASRepPart_tag__189 */
4610 : /* generate_template_type: EncASRepPart */
4611 : const struct asn1_template asn1_EncASRepPart[] = {
4612 : /* 0 */ { 0, sizeof(EncASRepPart), ((void *)(uintptr_t)1) },
4613 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,25), 0, asn1_EncKDCRepPart_tag__84 }
4614 : };
4615 :
4616 : int ASN1CALL
4617 43616 : decode_EncASRepPart(const unsigned char *p, size_t len, EncASRepPart *data, size_t *size)
4618 : {
4619 43616 : memset(data, 0, sizeof(*data));
4620 43616 : return _asn1_decode_top(asn1_EncASRepPart, 0|0, p, len, data, size);
4621 : }
4622 :
4623 :
4624 : int ASN1CALL
4625 18327 : encode_EncASRepPart(unsigned char *p, size_t len, const EncASRepPart *data, size_t *size)
4626 : {
4627 18327 : return _asn1_encode(asn1_EncASRepPart, p, len, data, size);
4628 : }
4629 :
4630 :
4631 : size_t ASN1CALL
4632 18327 : length_EncASRepPart(const EncASRepPart *data)
4633 : {
4634 18327 : return _asn1_length(asn1_EncASRepPart, data);
4635 : }
4636 :
4637 :
4638 : void ASN1CALL
4639 9228 : free_EncASRepPart(EncASRepPart *data)
4640 : {
4641 9228 : _asn1_free_top(asn1_EncASRepPart, data);
4642 9228 : }
4643 :
4644 :
4645 : int ASN1CALL
4646 0 : copy_EncASRepPart(const EncASRepPart *from, EncASRepPart *to)
4647 : {
4648 0 : return _asn1_copy_top(asn1_EncASRepPart, from, to);
4649 : }
4650 :
4651 :
4652 : char * ASN1CALL
4653 0 : print_EncASRepPart(const EncASRepPart *data, int flags)
4654 : {
4655 0 : return _asn1_print_top(asn1_EncASRepPart, flags, data);
4656 : }
4657 :
4658 : /* template_members: EncTGSRepPart exp exp */
4659 : /* generate_template_type: EncTGSRepPart_tag__190 */
4660 : /* generate_template_type: EncTGSRepPart */
4661 : const struct asn1_template asn1_EncTGSRepPart[] = {
4662 : /* 0 */ { 0, sizeof(EncTGSRepPart), ((void *)(uintptr_t)1) },
4663 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,26), 0, asn1_EncKDCRepPart_tag__84 }
4664 : };
4665 :
4666 : int ASN1CALL
4667 34388 : decode_EncTGSRepPart(const unsigned char *p, size_t len, EncTGSRepPart *data, size_t *size)
4668 : {
4669 34388 : memset(data, 0, sizeof(*data));
4670 34388 : return _asn1_decode_top(asn1_EncTGSRepPart, 0|0, p, len, data, size);
4671 : }
4672 :
4673 :
4674 : int ASN1CALL
4675 35728 : encode_EncTGSRepPart(unsigned char *p, size_t len, const EncTGSRepPart *data, size_t *size)
4676 : {
4677 35728 : return _asn1_encode(asn1_EncTGSRepPart, p, len, data, size);
4678 : }
4679 :
4680 :
4681 : size_t ASN1CALL
4682 35728 : length_EncTGSRepPart(const EncTGSRepPart *data)
4683 : {
4684 35728 : return _asn1_length(asn1_EncTGSRepPart, data);
4685 : }
4686 :
4687 :
4688 : void ASN1CALL
4689 35923 : free_EncTGSRepPart(EncTGSRepPart *data)
4690 : {
4691 35923 : _asn1_free_top(asn1_EncTGSRepPart, data);
4692 35923 : }
4693 :
4694 :
4695 : int ASN1CALL
4696 0 : copy_EncTGSRepPart(const EncTGSRepPart *from, EncTGSRepPart *to)
4697 : {
4698 0 : return _asn1_copy_top(asn1_EncTGSRepPart, from, to);
4699 : }
4700 :
4701 :
4702 : char * ASN1CALL
4703 0 : print_EncTGSRepPart(const EncTGSRepPart *data, int flags)
4704 : {
4705 0 : return _asn1_print_top(asn1_EncTGSRepPart, flags, data);
4706 : }
4707 :
4708 : /* template_members: AP_REQ exp exp */
4709 : /* template_members: AP_REQ exp exp */
4710 : /* tsequence: members isstruct: 1 */
4711 : /* template_members: AP_REQ exp exp */
4712 : /* generate_template_type: AP_REQ_tag_pvno_193 */
4713 : /* template_members: AP_REQ exp exp */
4714 : /* generate_template_type: AP_REQ_tag_msg_type_194 */
4715 : /* template_members: AP_REQ exp exp */
4716 : /* generate_template_type: AP_REQ_tag_ap_options_195 */
4717 : const struct asn1_template asn1_AP_REQ_tag_ap_options_195[] = {
4718 : /* 0 */ { 0, sizeof(APOptions), ((void *)(uintptr_t)1) },
4719 : /* 1 */ { A1_OP_TYPE , 0, asn1_APOptions }
4720 : };
4721 : /* template_members: AP_REQ exp exp */
4722 : /* generate_template_type: AP_REQ_tag_ticket_196 */
4723 : /* template_members: AP_REQ exp exp */
4724 : /* generate_template_type: AP_REQ_tag_authenticator_197 */
4725 : /* generate_template_type: AP_REQ_tag__192 */
4726 : const struct asn1_template asn1_AP_REQ_tag__192[] = {
4727 : /* 0 */ { 0, sizeof(struct AP_REQ), ((void *)(uintptr_t)11) },
4728 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct AP_REQ, pvno), asn1_HostAddress_tag_addr_type_16 },
4729 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct AP_REQ, msg_type), asn1_KDC_REQ_tag_msg_type_157 },
4730 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct AP_REQ, ap_options), asn1_AP_REQ_tag_ap_options_195 },
4731 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct AP_REQ, ticket), asn1_KDC_REQ_BODY_additional_tickets_10 },
4732 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct AP_REQ, authenticator), asn1_Ticket_tag_enc_part_52 },
4733 : /* 6 */ { A1_OP_NAME, 0, "AP_REQ" },
4734 : /* 7 */ { A1_OP_NAME, 0, "pvno" },
4735 : /* 8 */ { A1_OP_NAME, 0, "msg-type" },
4736 : /* 9 */ { A1_OP_NAME, 0, "ap-options" },
4737 : /* 10 */ { A1_OP_NAME, 0, "ticket" },
4738 : /* 11 */ { A1_OP_NAME, 0, "authenticator" }
4739 : };
4740 : /* generate_template_type: AP_REQ_tag__191 */
4741 : const struct asn1_template asn1_AP_REQ_tag__191[] = {
4742 : /* 0 */ { 0, sizeof(struct AP_REQ), ((void *)(uintptr_t)1) },
4743 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_AP_REQ_tag__192 }
4744 : };
4745 : /* generate_template_type: AP_REQ */
4746 : const struct asn1_template asn1_AP_REQ[] = {
4747 : /* 0 */ { 0, sizeof(AP_REQ), ((void *)(uintptr_t)1) },
4748 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,14), 0, asn1_AP_REQ_tag__191 }
4749 : };
4750 :
4751 : int ASN1CALL
4752 58025 : decode_AP_REQ(const unsigned char *p, size_t len, AP_REQ *data, size_t *size)
4753 : {
4754 58025 : memset(data, 0, sizeof(*data));
4755 58025 : return _asn1_decode_top(asn1_AP_REQ, 0|0, p, len, data, size);
4756 : }
4757 :
4758 :
4759 : int ASN1CALL
4760 60588 : encode_AP_REQ(unsigned char *p, size_t len, const AP_REQ *data, size_t *size)
4761 : {
4762 60588 : return _asn1_encode(asn1_AP_REQ, p, len, data, size);
4763 : }
4764 :
4765 :
4766 : size_t ASN1CALL
4767 60588 : length_AP_REQ(const AP_REQ *data)
4768 : {
4769 60588 : return _asn1_length(asn1_AP_REQ, data);
4770 : }
4771 :
4772 :
4773 : void ASN1CALL
4774 118613 : free_AP_REQ(AP_REQ *data)
4775 : {
4776 118613 : _asn1_free_top(asn1_AP_REQ, data);
4777 118613 : }
4778 :
4779 :
4780 : int ASN1CALL
4781 0 : copy_AP_REQ(const AP_REQ *from, AP_REQ *to)
4782 : {
4783 0 : return _asn1_copy_top(asn1_AP_REQ, from, to);
4784 : }
4785 :
4786 :
4787 : char * ASN1CALL
4788 0 : print_AP_REQ(const AP_REQ *data, int flags)
4789 : {
4790 0 : return _asn1_print_top(asn1_AP_REQ, flags, data);
4791 : }
4792 :
4793 : /* template_members: AP_REP exp exp */
4794 : /* template_members: AP_REP exp exp */
4795 : /* tsequence: members isstruct: 1 */
4796 : /* template_members: AP_REP exp exp */
4797 : /* generate_template_type: AP_REP_tag_pvno_200 */
4798 : /* template_members: AP_REP exp exp */
4799 : /* generate_template_type: AP_REP_tag_msg_type_201 */
4800 : /* template_members: AP_REP exp exp */
4801 : /* generate_template_type: AP_REP_tag_enc_part_202 */
4802 : /* generate_template_type: AP_REP_tag__199 */
4803 : const struct asn1_template asn1_AP_REP_tag__199[] = {
4804 : /* 0 */ { 0, sizeof(struct AP_REP), ((void *)(uintptr_t)7) },
4805 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct AP_REP, pvno), asn1_HostAddress_tag_addr_type_16 },
4806 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct AP_REP, msg_type), asn1_KDC_REQ_tag_msg_type_157 },
4807 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct AP_REP, enc_part), asn1_Ticket_tag_enc_part_52 },
4808 : /* 4 */ { A1_OP_NAME, 0, "AP_REP" },
4809 : /* 5 */ { A1_OP_NAME, 0, "pvno" },
4810 : /* 6 */ { A1_OP_NAME, 0, "msg-type" },
4811 : /* 7 */ { A1_OP_NAME, 0, "enc-part" }
4812 : };
4813 : /* generate_template_type: AP_REP_tag__198 */
4814 : const struct asn1_template asn1_AP_REP_tag__198[] = {
4815 : /* 0 */ { 0, sizeof(struct AP_REP), ((void *)(uintptr_t)1) },
4816 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_AP_REP_tag__199 }
4817 : };
4818 : /* generate_template_type: AP_REP */
4819 : const struct asn1_template asn1_AP_REP[] = {
4820 : /* 0 */ { 0, sizeof(AP_REP), ((void *)(uintptr_t)1) },
4821 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,15), 0, asn1_AP_REP_tag__198 }
4822 : };
4823 :
4824 : int ASN1CALL
4825 21402 : decode_AP_REP(const unsigned char *p, size_t len, AP_REP *data, size_t *size)
4826 : {
4827 21402 : memset(data, 0, sizeof(*data));
4828 21402 : return _asn1_decode_top(asn1_AP_REP, 0|0, p, len, data, size);
4829 : }
4830 :
4831 :
4832 : int ASN1CALL
4833 22839 : encode_AP_REP(unsigned char *p, size_t len, const AP_REP *data, size_t *size)
4834 : {
4835 22839 : return _asn1_encode(asn1_AP_REP, p, len, data, size);
4836 : }
4837 :
4838 :
4839 : size_t ASN1CALL
4840 22839 : length_AP_REP(const AP_REP *data)
4841 : {
4842 22839 : return _asn1_length(asn1_AP_REP, data);
4843 : }
4844 :
4845 :
4846 : void ASN1CALL
4847 44241 : free_AP_REP(AP_REP *data)
4848 : {
4849 44241 : _asn1_free_top(asn1_AP_REP, data);
4850 44241 : }
4851 :
4852 :
4853 : int ASN1CALL
4854 0 : copy_AP_REP(const AP_REP *from, AP_REP *to)
4855 : {
4856 0 : return _asn1_copy_top(asn1_AP_REP, from, to);
4857 : }
4858 :
4859 :
4860 : char * ASN1CALL
4861 0 : print_AP_REP(const AP_REP *data, int flags)
4862 : {
4863 0 : return _asn1_print_top(asn1_AP_REP, flags, data);
4864 : }
4865 :
4866 : /* template_members: EncAPRepPart exp exp */
4867 : /* template_members: EncAPRepPart exp exp */
4868 : /* tsequence: members isstruct: 1 */
4869 : /* template_members: EncAPRepPart exp exp */
4870 : /* generate_template_type: EncAPRepPart_tag_ctime_205 */
4871 : /* template_members: EncAPRepPart exp exp */
4872 : /* generate_template_type: EncAPRepPart_tag_cusec_206 */
4873 : /* template_members: EncAPRepPart exp exp */
4874 : /* generate_template_type: EncAPRepPart_tag_subkey_207 */
4875 : /* template_members: EncAPRepPart exp exp */
4876 : /* generate_template_type: EncAPRepPart_tag_seq_number_208 */
4877 : /* generate_template_type: EncAPRepPart_tag__204 */
4878 : const struct asn1_template asn1_EncAPRepPart_tag__204[] = {
4879 : /* 0 */ { 0, sizeof(struct EncAPRepPart), ((void *)(uintptr_t)9) },
4880 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct EncAPRepPart, ctime), asn1_LastReq_val_tag_lr_value_33 },
4881 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct EncAPRepPart, cusec), asn1_HostAddress_tag_addr_type_16 },
4882 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct EncAPRepPart, subkey), asn1_EncTicketPart_tag_key_56 },
4883 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct EncAPRepPart, seq_number), asn1_Authenticator_tag_seq_number_116 },
4884 : /* 5 */ { A1_OP_NAME, 0, "EncAPRepPart" },
4885 : /* 6 */ { A1_OP_NAME, 0, "ctime" },
4886 : /* 7 */ { A1_OP_NAME, 0, "cusec" },
4887 : /* 8 */ { A1_OP_NAME, 0, "subkey" },
4888 : /* 9 */ { A1_OP_NAME, 0, "seq-number" }
4889 : };
4890 : /* generate_template_type: EncAPRepPart_tag__203 */
4891 : const struct asn1_template asn1_EncAPRepPart_tag__203[] = {
4892 : /* 0 */ { 0, sizeof(struct EncAPRepPart), ((void *)(uintptr_t)1) },
4893 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_EncAPRepPart_tag__204 }
4894 : };
4895 : /* generate_template_type: EncAPRepPart */
4896 : const struct asn1_template asn1_EncAPRepPart[] = {
4897 : /* 0 */ { 0, sizeof(EncAPRepPart), ((void *)(uintptr_t)1) },
4898 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,27), 0, asn1_EncAPRepPart_tag__203 }
4899 : };
4900 :
4901 : int ASN1CALL
4902 21402 : decode_EncAPRepPart(const unsigned char *p, size_t len, EncAPRepPart *data, size_t *size)
4903 : {
4904 21402 : memset(data, 0, sizeof(*data));
4905 21402 : return _asn1_decode_top(asn1_EncAPRepPart, 0|0, p, len, data, size);
4906 : }
4907 :
4908 :
4909 : int ASN1CALL
4910 22839 : encode_EncAPRepPart(unsigned char *p, size_t len, const EncAPRepPart *data, size_t *size)
4911 : {
4912 22839 : return _asn1_encode(asn1_EncAPRepPart, p, len, data, size);
4913 : }
4914 :
4915 :
4916 : size_t ASN1CALL
4917 22839 : length_EncAPRepPart(const EncAPRepPart *data)
4918 : {
4919 22839 : return _asn1_length(asn1_EncAPRepPart, data);
4920 : }
4921 :
4922 :
4923 : void ASN1CALL
4924 44241 : free_EncAPRepPart(EncAPRepPart *data)
4925 : {
4926 44241 : _asn1_free_top(asn1_EncAPRepPart, data);
4927 44241 : }
4928 :
4929 :
4930 : int ASN1CALL
4931 0 : copy_EncAPRepPart(const EncAPRepPart *from, EncAPRepPart *to)
4932 : {
4933 0 : return _asn1_copy_top(asn1_EncAPRepPart, from, to);
4934 : }
4935 :
4936 :
4937 : char * ASN1CALL
4938 0 : print_EncAPRepPart(const EncAPRepPart *data, int flags)
4939 : {
4940 0 : return _asn1_print_top(asn1_EncAPRepPart, flags, data);
4941 : }
4942 :
4943 : /* template_members: KRB_SAFE_BODY exp exp */
4944 : /* tsequence: members isstruct: 1 */
4945 : /* template_members: KRB_SAFE_BODY exp exp */
4946 : /* template_members: heim_octet_string exp exp */
4947 : /* generate_template_type: heim_octet_string_tag_user_data_211 */
4948 : /* generate_template_type: KRB_SAFE_BODY_tag_user_data_210 */
4949 : /* template_members: KRB_SAFE_BODY exp exp */
4950 : /* generate_template_type: KRB_SAFE_BODY_tag_timestamp_212 */
4951 : /* template_members: KRB_SAFE_BODY exp exp */
4952 : /* generate_template_type: KRB_SAFE_BODY_tag_usec_213 */
4953 : /* template_members: KRB_SAFE_BODY exp exp */
4954 : /* generate_template_type: KRB_SAFE_BODY_tag_seq_number_214 */
4955 : /* template_members: KRB_SAFE_BODY exp exp */
4956 : /* generate_template_type: KRB_SAFE_BODY_tag_s_address_215 */
4957 : /* template_members: KRB_SAFE_BODY exp exp */
4958 : /* generate_template_type: KRB_SAFE_BODY_tag_r_address_216 */
4959 : /* generate_template_type: KRB_SAFE_BODY_tag__209 */
4960 : const struct asn1_template asn1_KRB_SAFE_BODY_tag__209[] = {
4961 : /* 0 */ { 0, sizeof(struct KRB_SAFE_BODY), ((void *)(uintptr_t)13) },
4962 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KRB_SAFE_BODY, user_data), asn1_HostAddress_tag_address_17 },
4963 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct KRB_SAFE_BODY, timestamp), asn1_LastReq_val_tag_lr_value_33 },
4964 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct KRB_SAFE_BODY, usec), asn1_HostAddress_tag_addr_type_16 },
4965 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct KRB_SAFE_BODY, seq_number), asn1_Authenticator_tag_seq_number_116 },
4966 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct KRB_SAFE_BODY, s_address), asn1_HostAddress_seofTstruct_1 },
4967 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5)|A1_FLAG_OPTIONAL, offsetof(struct KRB_SAFE_BODY, r_address), asn1_HostAddress_seofTstruct_1 },
4968 : /* 7 */ { A1_OP_NAME, 0, "KRB_SAFE_BODY" },
4969 : /* 8 */ { A1_OP_NAME, 0, "user-data" },
4970 : /* 9 */ { A1_OP_NAME, 0, "timestamp" },
4971 : /* 10 */ { A1_OP_NAME, 0, "usec" },
4972 : /* 11 */ { A1_OP_NAME, 0, "seq-number" },
4973 : /* 12 */ { A1_OP_NAME, 0, "s-address" },
4974 : /* 13 */ { A1_OP_NAME, 0, "r-address" }
4975 : };
4976 : /* generate_template_type: KRB_SAFE_BODY */
4977 : const struct asn1_template asn1_KRB_SAFE_BODY[] = {
4978 : /* 0 */ { 0, sizeof(KRB_SAFE_BODY), ((void *)(uintptr_t)1) },
4979 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KRB_SAFE_BODY_tag__209 }
4980 : };
4981 :
4982 : int ASN1CALL
4983 0 : decode_KRB_SAFE_BODY(const unsigned char *p, size_t len, KRB_SAFE_BODY *data, size_t *size)
4984 : {
4985 0 : memset(data, 0, sizeof(*data));
4986 0 : return _asn1_decode_top(asn1_KRB_SAFE_BODY, 0|0, p, len, data, size);
4987 : }
4988 :
4989 :
4990 : int ASN1CALL
4991 0 : encode_KRB_SAFE_BODY(unsigned char *p, size_t len, const KRB_SAFE_BODY *data, size_t *size)
4992 : {
4993 0 : return _asn1_encode(asn1_KRB_SAFE_BODY, p, len, data, size);
4994 : }
4995 :
4996 :
4997 : size_t ASN1CALL
4998 0 : length_KRB_SAFE_BODY(const KRB_SAFE_BODY *data)
4999 : {
5000 0 : return _asn1_length(asn1_KRB_SAFE_BODY, data);
5001 : }
5002 :
5003 :
5004 : void ASN1CALL
5005 0 : free_KRB_SAFE_BODY(KRB_SAFE_BODY *data)
5006 : {
5007 0 : _asn1_free_top(asn1_KRB_SAFE_BODY, data);
5008 0 : }
5009 :
5010 :
5011 : int ASN1CALL
5012 0 : copy_KRB_SAFE_BODY(const KRB_SAFE_BODY *from, KRB_SAFE_BODY *to)
5013 : {
5014 0 : return _asn1_copy_top(asn1_KRB_SAFE_BODY, from, to);
5015 : }
5016 :
5017 :
5018 : char * ASN1CALL
5019 0 : print_KRB_SAFE_BODY(const KRB_SAFE_BODY *data, int flags)
5020 : {
5021 0 : return _asn1_print_top(asn1_KRB_SAFE_BODY, flags, data);
5022 : }
5023 :
5024 : /* template_members: KRB_SAFE exp exp */
5025 : /* template_members: KRB_SAFE exp exp */
5026 : /* tsequence: members isstruct: 1 */
5027 : /* template_members: KRB_SAFE exp exp */
5028 : /* generate_template_type: KRB_SAFE_tag_pvno_219 */
5029 : /* template_members: KRB_SAFE exp exp */
5030 : /* generate_template_type: KRB_SAFE_tag_msg_type_220 */
5031 : /* template_members: KRB_SAFE exp exp */
5032 : /* generate_template_type: KRB_SAFE_tag_safe_body_221 */
5033 : const struct asn1_template asn1_KRB_SAFE_tag_safe_body_221[] = {
5034 : /* 0 */ { 0, sizeof(KRB_SAFE_BODY), ((void *)(uintptr_t)1) },
5035 : /* 1 */ { A1_OP_TYPE , 0, asn1_KRB_SAFE_BODY }
5036 : };
5037 : /* template_members: KRB_SAFE exp exp */
5038 : /* generate_template_type: KRB_SAFE_tag_cksum_222 */
5039 : /* generate_template_type: KRB_SAFE_tag__218 */
5040 : const struct asn1_template asn1_KRB_SAFE_tag__218[] = {
5041 : /* 0 */ { 0, sizeof(struct KRB_SAFE), ((void *)(uintptr_t)9) },
5042 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KRB_SAFE, pvno), asn1_HostAddress_tag_addr_type_16 },
5043 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KRB_SAFE, msg_type), asn1_KDC_REQ_tag_msg_type_157 },
5044 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KRB_SAFE, safe_body), asn1_KRB_SAFE_tag_safe_body_221 },
5045 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KRB_SAFE, cksum), asn1_Authenticator_tag_cksum_112 },
5046 : /* 5 */ { A1_OP_NAME, 0, "KRB_SAFE" },
5047 : /* 6 */ { A1_OP_NAME, 0, "pvno" },
5048 : /* 7 */ { A1_OP_NAME, 0, "msg-type" },
5049 : /* 8 */ { A1_OP_NAME, 0, "safe-body" },
5050 : /* 9 */ { A1_OP_NAME, 0, "cksum" }
5051 : };
5052 : /* generate_template_type: KRB_SAFE_tag__217 */
5053 : const struct asn1_template asn1_KRB_SAFE_tag__217[] = {
5054 : /* 0 */ { 0, sizeof(struct KRB_SAFE), ((void *)(uintptr_t)1) },
5055 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KRB_SAFE_tag__218 }
5056 : };
5057 : /* generate_template_type: KRB_SAFE */
5058 : const struct asn1_template asn1_KRB_SAFE[] = {
5059 : /* 0 */ { 0, sizeof(KRB_SAFE), ((void *)(uintptr_t)1) },
5060 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,20), 0, asn1_KRB_SAFE_tag__217 }
5061 : };
5062 :
5063 : int ASN1CALL
5064 0 : decode_KRB_SAFE(const unsigned char *p, size_t len, KRB_SAFE *data, size_t *size)
5065 : {
5066 0 : memset(data, 0, sizeof(*data));
5067 0 : return _asn1_decode_top(asn1_KRB_SAFE, 0|0, p, len, data, size);
5068 : }
5069 :
5070 :
5071 : int ASN1CALL
5072 0 : encode_KRB_SAFE(unsigned char *p, size_t len, const KRB_SAFE *data, size_t *size)
5073 : {
5074 0 : return _asn1_encode(asn1_KRB_SAFE, p, len, data, size);
5075 : }
5076 :
5077 :
5078 : size_t ASN1CALL
5079 0 : length_KRB_SAFE(const KRB_SAFE *data)
5080 : {
5081 0 : return _asn1_length(asn1_KRB_SAFE, data);
5082 : }
5083 :
5084 :
5085 : void ASN1CALL
5086 0 : free_KRB_SAFE(KRB_SAFE *data)
5087 : {
5088 0 : _asn1_free_top(asn1_KRB_SAFE, data);
5089 0 : }
5090 :
5091 :
5092 : int ASN1CALL
5093 0 : copy_KRB_SAFE(const KRB_SAFE *from, KRB_SAFE *to)
5094 : {
5095 0 : return _asn1_copy_top(asn1_KRB_SAFE, from, to);
5096 : }
5097 :
5098 :
5099 : char * ASN1CALL
5100 0 : print_KRB_SAFE(const KRB_SAFE *data, int flags)
5101 : {
5102 0 : return _asn1_print_top(asn1_KRB_SAFE, flags, data);
5103 : }
5104 :
5105 : /* template_members: KRB_PRIV exp exp */
5106 : /* template_members: KRB_PRIV exp exp */
5107 : /* tsequence: members isstruct: 1 */
5108 : /* template_members: KRB_PRIV exp exp */
5109 : /* generate_template_type: KRB_PRIV_tag_pvno_225 */
5110 : /* template_members: KRB_PRIV exp exp */
5111 : /* generate_template_type: KRB_PRIV_tag_msg_type_226 */
5112 : /* template_members: KRB_PRIV exp exp */
5113 : /* generate_template_type: KRB_PRIV_tag_enc_part_227 */
5114 : /* generate_template_type: KRB_PRIV_tag__224 */
5115 : const struct asn1_template asn1_KRB_PRIV_tag__224[] = {
5116 : /* 0 */ { 0, sizeof(struct KRB_PRIV), ((void *)(uintptr_t)7) },
5117 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KRB_PRIV, pvno), asn1_HostAddress_tag_addr_type_16 },
5118 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KRB_PRIV, msg_type), asn1_KDC_REQ_tag_msg_type_157 },
5119 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KRB_PRIV, enc_part), asn1_Ticket_tag_enc_part_52 },
5120 : /* 4 */ { A1_OP_NAME, 0, "KRB_PRIV" },
5121 : /* 5 */ { A1_OP_NAME, 0, "pvno" },
5122 : /* 6 */ { A1_OP_NAME, 0, "msg-type" },
5123 : /* 7 */ { A1_OP_NAME, 0, "enc-part" }
5124 : };
5125 : /* generate_template_type: KRB_PRIV_tag__223 */
5126 : const struct asn1_template asn1_KRB_PRIV_tag__223[] = {
5127 : /* 0 */ { 0, sizeof(struct KRB_PRIV), ((void *)(uintptr_t)1) },
5128 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KRB_PRIV_tag__224 }
5129 : };
5130 : /* generate_template_type: KRB_PRIV */
5131 : const struct asn1_template asn1_KRB_PRIV[] = {
5132 : /* 0 */ { 0, sizeof(KRB_PRIV), ((void *)(uintptr_t)1) },
5133 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,21), 0, asn1_KRB_PRIV_tag__223 }
5134 : };
5135 :
5136 : int ASN1CALL
5137 63 : decode_KRB_PRIV(const unsigned char *p, size_t len, KRB_PRIV *data, size_t *size)
5138 : {
5139 63 : memset(data, 0, sizeof(*data));
5140 63 : return _asn1_decode_top(asn1_KRB_PRIV, 0|0, p, len, data, size);
5141 : }
5142 :
5143 :
5144 : int ASN1CALL
5145 63 : encode_KRB_PRIV(unsigned char *p, size_t len, const KRB_PRIV *data, size_t *size)
5146 : {
5147 63 : return _asn1_encode(asn1_KRB_PRIV, p, len, data, size);
5148 : }
5149 :
5150 :
5151 : size_t ASN1CALL
5152 63 : length_KRB_PRIV(const KRB_PRIV *data)
5153 : {
5154 63 : return _asn1_length(asn1_KRB_PRIV, data);
5155 : }
5156 :
5157 :
5158 : void ASN1CALL
5159 63 : free_KRB_PRIV(KRB_PRIV *data)
5160 : {
5161 63 : _asn1_free_top(asn1_KRB_PRIV, data);
5162 63 : }
5163 :
5164 :
5165 : int ASN1CALL
5166 0 : copy_KRB_PRIV(const KRB_PRIV *from, KRB_PRIV *to)
5167 : {
5168 0 : return _asn1_copy_top(asn1_KRB_PRIV, from, to);
5169 : }
5170 :
5171 :
5172 : char * ASN1CALL
5173 0 : print_KRB_PRIV(const KRB_PRIV *data, int flags)
5174 : {
5175 0 : return _asn1_print_top(asn1_KRB_PRIV, flags, data);
5176 : }
5177 :
5178 : /* template_members: EncKrbPrivPart exp exp */
5179 : /* template_members: EncKrbPrivPart exp exp */
5180 : /* tsequence: members isstruct: 1 */
5181 : /* template_members: EncKrbPrivPart exp exp */
5182 : /* template_members: heim_octet_string exp exp */
5183 : /* generate_template_type: heim_octet_string_tag_user_data_231 */
5184 : /* generate_template_type: EncKrbPrivPart_tag_user_data_230 */
5185 : /* template_members: EncKrbPrivPart exp exp */
5186 : /* generate_template_type: EncKrbPrivPart_tag_timestamp_232 */
5187 : /* template_members: EncKrbPrivPart exp exp */
5188 : /* generate_template_type: EncKrbPrivPart_tag_usec_233 */
5189 : /* template_members: EncKrbPrivPart exp exp */
5190 : /* generate_template_type: EncKrbPrivPart_tag_seq_number_234 */
5191 : /* template_members: EncKrbPrivPart exp exp */
5192 : /* generate_template_type: EncKrbPrivPart_tag_s_address_235 */
5193 : /* template_members: EncKrbPrivPart exp exp */
5194 : /* generate_template_type: EncKrbPrivPart_tag_r_address_236 */
5195 : /* generate_template_type: EncKrbPrivPart_tag__229 */
5196 : const struct asn1_template asn1_EncKrbPrivPart_tag__229[] = {
5197 : /* 0 */ { 0, sizeof(struct EncKrbPrivPart), ((void *)(uintptr_t)13) },
5198 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct EncKrbPrivPart, user_data), asn1_HostAddress_tag_address_17 },
5199 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbPrivPart, timestamp), asn1_LastReq_val_tag_lr_value_33 },
5200 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbPrivPart, usec), asn1_HostAddress_tag_addr_type_16 },
5201 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbPrivPart, seq_number), asn1_Authenticator_tag_seq_number_116 },
5202 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbPrivPart, s_address), asn1_HostAddress_seofTstruct_1 },
5203 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbPrivPart, r_address), asn1_HostAddress_seofTstruct_1 },
5204 : /* 7 */ { A1_OP_NAME, 0, "EncKrbPrivPart" },
5205 : /* 8 */ { A1_OP_NAME, 0, "user-data" },
5206 : /* 9 */ { A1_OP_NAME, 0, "timestamp" },
5207 : /* 10 */ { A1_OP_NAME, 0, "usec" },
5208 : /* 11 */ { A1_OP_NAME, 0, "seq-number" },
5209 : /* 12 */ { A1_OP_NAME, 0, "s-address" },
5210 : /* 13 */ { A1_OP_NAME, 0, "r-address" }
5211 : };
5212 : /* generate_template_type: EncKrbPrivPart_tag__228 */
5213 : const struct asn1_template asn1_EncKrbPrivPart_tag__228[] = {
5214 : /* 0 */ { 0, sizeof(struct EncKrbPrivPart), ((void *)(uintptr_t)1) },
5215 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_EncKrbPrivPart_tag__229 }
5216 : };
5217 : /* generate_template_type: EncKrbPrivPart */
5218 : const struct asn1_template asn1_EncKrbPrivPart[] = {
5219 : /* 0 */ { 0, sizeof(EncKrbPrivPart), ((void *)(uintptr_t)1) },
5220 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,28), 0, asn1_EncKrbPrivPart_tag__228 }
5221 : };
5222 :
5223 : int ASN1CALL
5224 63 : decode_EncKrbPrivPart(const unsigned char *p, size_t len, EncKrbPrivPart *data, size_t *size)
5225 : {
5226 63 : memset(data, 0, sizeof(*data));
5227 63 : return _asn1_decode_top(asn1_EncKrbPrivPart, 0|0, p, len, data, size);
5228 : }
5229 :
5230 :
5231 : int ASN1CALL
5232 63 : encode_EncKrbPrivPart(unsigned char *p, size_t len, const EncKrbPrivPart *data, size_t *size)
5233 : {
5234 63 : return _asn1_encode(asn1_EncKrbPrivPart, p, len, data, size);
5235 : }
5236 :
5237 :
5238 : size_t ASN1CALL
5239 63 : length_EncKrbPrivPart(const EncKrbPrivPart *data)
5240 : {
5241 63 : return _asn1_length(asn1_EncKrbPrivPart, data);
5242 : }
5243 :
5244 :
5245 : void ASN1CALL
5246 63 : free_EncKrbPrivPart(EncKrbPrivPart *data)
5247 : {
5248 63 : _asn1_free_top(asn1_EncKrbPrivPart, data);
5249 63 : }
5250 :
5251 :
5252 : int ASN1CALL
5253 0 : copy_EncKrbPrivPart(const EncKrbPrivPart *from, EncKrbPrivPart *to)
5254 : {
5255 0 : return _asn1_copy_top(asn1_EncKrbPrivPart, from, to);
5256 : }
5257 :
5258 :
5259 : char * ASN1CALL
5260 0 : print_EncKrbPrivPart(const EncKrbPrivPart *data, int flags)
5261 : {
5262 0 : return _asn1_print_top(asn1_EncKrbPrivPart, flags, data);
5263 : }
5264 :
5265 : /* template_members: KRB_CRED exp exp */
5266 : /* template_members: KRB_CRED exp exp */
5267 : /* tsequence: members isstruct: 1 */
5268 : /* template_members: KRB_CRED exp exp */
5269 : /* generate_template_type: KRB_CRED_tag_pvno_239 */
5270 : /* template_members: KRB_CRED exp exp */
5271 : /* generate_template_type: KRB_CRED_tag_msg_type_240 */
5272 : /* template_members: KRB_CRED exp exp */
5273 : /* template_members: KRB_CRED exp exp */
5274 : /* generate_template_type: KRB_CRED_tickets_13 */
5275 : /* generate_template_type: KRB_CRED_tag_tickets_242 */
5276 : const struct asn1_template asn1_KRB_CRED_tag_tickets_242[] = {
5277 : /* 0 */ { 0, sizeof(struct KRB_CRED_tickets), ((void *)(uintptr_t)1) },
5278 : /* 1 */ { A1_OP_SEQOF, 0, asn1_KDC_REQ_BODY_additional_tickets_10 }
5279 : };
5280 : /* generate_template_type: KRB_CRED_tag_tickets_241 */
5281 : const struct asn1_template asn1_KRB_CRED_tag_tickets_241[] = {
5282 : /* 0 */ { 0, sizeof(struct KRB_CRED_tickets), ((void *)(uintptr_t)1) },
5283 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KRB_CRED_tag_tickets_242 }
5284 : };
5285 : /* template_members: KRB_CRED exp exp */
5286 : /* generate_template_type: KRB_CRED_tag_enc_part_243 */
5287 : /* generate_template_type: KRB_CRED_tag__238 */
5288 : const struct asn1_template asn1_KRB_CRED_tag__238[] = {
5289 : /* 0 */ { 0, sizeof(struct KRB_CRED), ((void *)(uintptr_t)9) },
5290 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KRB_CRED, pvno), asn1_HostAddress_tag_addr_type_16 },
5291 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KRB_CRED, msg_type), asn1_KDC_REQ_tag_msg_type_157 },
5292 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KRB_CRED, tickets), asn1_KRB_CRED_tag_tickets_241 },
5293 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KRB_CRED, enc_part), asn1_Ticket_tag_enc_part_52 },
5294 : /* 5 */ { A1_OP_NAME, 0, "KRB_CRED" },
5295 : /* 6 */ { A1_OP_NAME, 0, "pvno" },
5296 : /* 7 */ { A1_OP_NAME, 0, "msg-type" },
5297 : /* 8 */ { A1_OP_NAME, 0, "tickets" },
5298 : /* 9 */ { A1_OP_NAME, 0, "enc-part" }
5299 : };
5300 : /* generate_template_type: KRB_CRED_tag__237 */
5301 : const struct asn1_template asn1_KRB_CRED_tag__237[] = {
5302 : /* 0 */ { 0, sizeof(struct KRB_CRED), ((void *)(uintptr_t)1) },
5303 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KRB_CRED_tag__238 }
5304 : };
5305 : /* generate_template_type: KRB_CRED */
5306 : const struct asn1_template asn1_KRB_CRED[] = {
5307 : /* 0 */ { 0, sizeof(KRB_CRED), ((void *)(uintptr_t)1) },
5308 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,22), 0, asn1_KRB_CRED_tag__237 }
5309 : };
5310 :
5311 : int ASN1CALL
5312 17107 : decode_KRB_CRED(const unsigned char *p, size_t len, KRB_CRED *data, size_t *size)
5313 : {
5314 17107 : memset(data, 0, sizeof(*data));
5315 17107 : return _asn1_decode_top(asn1_KRB_CRED, 0|0, p, len, data, size);
5316 : }
5317 :
5318 :
5319 : int ASN1CALL
5320 17096 : encode_KRB_CRED(unsigned char *p, size_t len, const KRB_CRED *data, size_t *size)
5321 : {
5322 17096 : return _asn1_encode(asn1_KRB_CRED, p, len, data, size);
5323 : }
5324 :
5325 :
5326 : size_t ASN1CALL
5327 17096 : length_KRB_CRED(const KRB_CRED *data)
5328 : {
5329 17096 : return _asn1_length(asn1_KRB_CRED, data);
5330 : }
5331 :
5332 :
5333 : void ASN1CALL
5334 34203 : free_KRB_CRED(KRB_CRED *data)
5335 : {
5336 34203 : _asn1_free_top(asn1_KRB_CRED, data);
5337 34203 : }
5338 :
5339 :
5340 : int ASN1CALL
5341 0 : copy_KRB_CRED(const KRB_CRED *from, KRB_CRED *to)
5342 : {
5343 0 : return _asn1_copy_top(asn1_KRB_CRED, from, to);
5344 : }
5345 :
5346 :
5347 : char * ASN1CALL
5348 0 : print_KRB_CRED(const KRB_CRED *data, int flags)
5349 : {
5350 0 : return _asn1_print_top(asn1_KRB_CRED, flags, data);
5351 : }
5352 :
5353 : /* template_members: KrbCredInfo exp exp */
5354 : /* tsequence: members isstruct: 1 */
5355 : /* template_members: KrbCredInfo exp exp */
5356 : /* generate_template_type: KrbCredInfo_tag_key_245 */
5357 : /* template_members: KrbCredInfo exp exp */
5358 : /* generate_template_type: KrbCredInfo_tag_prealm_246 */
5359 : /* template_members: KrbCredInfo exp exp */
5360 : /* generate_template_type: KrbCredInfo_tag_pname_247 */
5361 : /* template_members: KrbCredInfo exp exp */
5362 : /* generate_template_type: KrbCredInfo_tag_flags_248 */
5363 : /* template_members: KrbCredInfo exp exp */
5364 : /* generate_template_type: KrbCredInfo_tag_authtime_249 */
5365 : /* template_members: KrbCredInfo exp exp */
5366 : /* generate_template_type: KrbCredInfo_tag_starttime_250 */
5367 : /* template_members: KrbCredInfo exp exp */
5368 : /* generate_template_type: KrbCredInfo_tag_endtime_251 */
5369 : /* template_members: KrbCredInfo exp exp */
5370 : /* generate_template_type: KrbCredInfo_tag_renew_till_252 */
5371 : /* template_members: KrbCredInfo exp exp */
5372 : /* generate_template_type: KrbCredInfo_tag_srealm_253 */
5373 : /* template_members: KrbCredInfo exp exp */
5374 : /* generate_template_type: KrbCredInfo_tag_sname_254 */
5375 : /* template_members: KrbCredInfo exp exp */
5376 : /* generate_template_type: KrbCredInfo_tag_caddr_255 */
5377 : /* generate_template_type: KrbCredInfo_tag__244 */
5378 : const struct asn1_template asn1_KrbCredInfo_tag__244[] = {
5379 : /* 0 */ { 0, sizeof(struct KrbCredInfo), ((void *)(uintptr_t)23) },
5380 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KrbCredInfo, key), asn1_EncTicketPart_tag_key_56 },
5381 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, prealm), asn1_Ticket_tag_realm_50 },
5382 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, pname), asn1_Ticket_tag_sname_51 },
5383 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, flags), asn1_EncTicketPart_tag_flags_55 },
5384 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, authtime), asn1_LastReq_val_tag_lr_value_33 },
5385 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, starttime), asn1_LastReq_val_tag_lr_value_33 },
5386 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, endtime), asn1_LastReq_val_tag_lr_value_33 },
5387 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, renew_till), asn1_LastReq_val_tag_lr_value_33 },
5388 : /* 9 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,8)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, srealm), asn1_Ticket_tag_realm_50 },
5389 : /* 10 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,9)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, sname), asn1_Ticket_tag_sname_51 },
5390 : /* 11 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,10)|A1_FLAG_OPTIONAL, offsetof(struct KrbCredInfo, caddr), asn1_EncTicketPart_tag_caddr_64 },
5391 : /* 12 */ { A1_OP_NAME, 0, "KrbCredInfo" },
5392 : /* 13 */ { A1_OP_NAME, 0, "key" },
5393 : /* 14 */ { A1_OP_NAME, 0, "prealm" },
5394 : /* 15 */ { A1_OP_NAME, 0, "pname" },
5395 : /* 16 */ { A1_OP_NAME, 0, "flags" },
5396 : /* 17 */ { A1_OP_NAME, 0, "authtime" },
5397 : /* 18 */ { A1_OP_NAME, 0, "starttime" },
5398 : /* 19 */ { A1_OP_NAME, 0, "endtime" },
5399 : /* 20 */ { A1_OP_NAME, 0, "renew-till" },
5400 : /* 21 */ { A1_OP_NAME, 0, "srealm" },
5401 : /* 22 */ { A1_OP_NAME, 0, "sname" },
5402 : /* 23 */ { A1_OP_NAME, 0, "caddr" }
5403 : };
5404 : /* generate_template_type: KrbCredInfo */
5405 : const struct asn1_template asn1_KrbCredInfo[] = {
5406 : /* 0 */ { 0, sizeof(KrbCredInfo), ((void *)(uintptr_t)1) },
5407 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KrbCredInfo_tag__244 }
5408 : };
5409 :
5410 : int ASN1CALL
5411 0 : decode_KrbCredInfo(const unsigned char *p, size_t len, KrbCredInfo *data, size_t *size)
5412 : {
5413 0 : memset(data, 0, sizeof(*data));
5414 0 : return _asn1_decode_top(asn1_KrbCredInfo, 0|0, p, len, data, size);
5415 : }
5416 :
5417 :
5418 : int ASN1CALL
5419 0 : encode_KrbCredInfo(unsigned char *p, size_t len, const KrbCredInfo *data, size_t *size)
5420 : {
5421 0 : return _asn1_encode(asn1_KrbCredInfo, p, len, data, size);
5422 : }
5423 :
5424 :
5425 : size_t ASN1CALL
5426 0 : length_KrbCredInfo(const KrbCredInfo *data)
5427 : {
5428 0 : return _asn1_length(asn1_KrbCredInfo, data);
5429 : }
5430 :
5431 :
5432 : void ASN1CALL
5433 0 : free_KrbCredInfo(KrbCredInfo *data)
5434 : {
5435 0 : _asn1_free_top(asn1_KrbCredInfo, data);
5436 0 : }
5437 :
5438 :
5439 : int ASN1CALL
5440 0 : copy_KrbCredInfo(const KrbCredInfo *from, KrbCredInfo *to)
5441 : {
5442 0 : return _asn1_copy_top(asn1_KrbCredInfo, from, to);
5443 : }
5444 :
5445 :
5446 : char * ASN1CALL
5447 0 : print_KrbCredInfo(const KrbCredInfo *data, int flags)
5448 : {
5449 0 : return _asn1_print_top(asn1_KrbCredInfo, flags, data);
5450 : }
5451 :
5452 : /* template_members: EncKrbCredPart exp exp */
5453 : /* template_members: EncKrbCredPart exp exp */
5454 : /* tsequence: members isstruct: 1 */
5455 : /* template_members: EncKrbCredPart exp exp */
5456 : /* template_members: EncKrbCredPart exp exp */
5457 : /* generate_template_type: EncKrbCredPart_ticket_info_14 */
5458 : const struct asn1_template asn1_EncKrbCredPart_ticket_info_14[] = {
5459 : /* 0 */ { 0, sizeof(KrbCredInfo), ((void *)(uintptr_t)1) },
5460 : /* 1 */ { A1_OP_TYPE , 0, asn1_KrbCredInfo }
5461 : };
5462 : /* generate_template_type: EncKrbCredPart_tag_ticket_info_259 */
5463 : const struct asn1_template asn1_EncKrbCredPart_tag_ticket_info_259[] = {
5464 : /* 0 */ { 0, sizeof(struct EncKrbCredPart_ticket_info), ((void *)(uintptr_t)1) },
5465 : /* 1 */ { A1_OP_SEQOF, 0, asn1_EncKrbCredPart_ticket_info_14 }
5466 : };
5467 : /* generate_template_type: EncKrbCredPart_tag_ticket_info_258 */
5468 : const struct asn1_template asn1_EncKrbCredPart_tag_ticket_info_258[] = {
5469 : /* 0 */ { 0, sizeof(struct EncKrbCredPart_ticket_info), ((void *)(uintptr_t)1) },
5470 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_EncKrbCredPart_tag_ticket_info_259 }
5471 : };
5472 : /* template_members: EncKrbCredPart exp exp */
5473 : /* generate_template_type: EncKrbCredPart_tag_nonce_260 */
5474 : /* template_members: EncKrbCredPart exp exp */
5475 : /* generate_template_type: EncKrbCredPart_tag_timestamp_261 */
5476 : /* template_members: EncKrbCredPart exp exp */
5477 : /* generate_template_type: EncKrbCredPart_tag_usec_262 */
5478 : /* template_members: EncKrbCredPart exp exp */
5479 : /* generate_template_type: EncKrbCredPart_tag_s_address_263 */
5480 : /* template_members: EncKrbCredPart exp exp */
5481 : /* generate_template_type: EncKrbCredPart_tag_r_address_264 */
5482 : /* generate_template_type: EncKrbCredPart_tag__257 */
5483 : const struct asn1_template asn1_EncKrbCredPart_tag__257[] = {
5484 : /* 0 */ { 0, sizeof(struct EncKrbCredPart), ((void *)(uintptr_t)13) },
5485 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct EncKrbCredPart, ticket_info), asn1_EncKrbCredPart_tag_ticket_info_258 },
5486 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbCredPart, nonce), asn1_HostAddress_tag_addr_type_16 },
5487 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbCredPart, timestamp), asn1_LastReq_val_tag_lr_value_33 },
5488 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbCredPart, usec), asn1_HostAddress_tag_addr_type_16 },
5489 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbCredPart, s_address), asn1_HostAddress_seofTstruct_1 },
5490 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5)|A1_FLAG_OPTIONAL, offsetof(struct EncKrbCredPart, r_address), asn1_HostAddress_seofTstruct_1 },
5491 : /* 7 */ { A1_OP_NAME, 0, "EncKrbCredPart" },
5492 : /* 8 */ { A1_OP_NAME, 0, "ticket-info" },
5493 : /* 9 */ { A1_OP_NAME, 0, "nonce" },
5494 : /* 10 */ { A1_OP_NAME, 0, "timestamp" },
5495 : /* 11 */ { A1_OP_NAME, 0, "usec" },
5496 : /* 12 */ { A1_OP_NAME, 0, "s-address" },
5497 : /* 13 */ { A1_OP_NAME, 0, "r-address" }
5498 : };
5499 : /* generate_template_type: EncKrbCredPart_tag__256 */
5500 : const struct asn1_template asn1_EncKrbCredPart_tag__256[] = {
5501 : /* 0 */ { 0, sizeof(struct EncKrbCredPart), ((void *)(uintptr_t)1) },
5502 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_EncKrbCredPart_tag__257 }
5503 : };
5504 : /* generate_template_type: EncKrbCredPart */
5505 : const struct asn1_template asn1_EncKrbCredPart[] = {
5506 : /* 0 */ { 0, sizeof(EncKrbCredPart), ((void *)(uintptr_t)1) },
5507 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,29), 0, asn1_EncKrbCredPart_tag__256 }
5508 : };
5509 :
5510 : int ASN1CALL
5511 17107 : decode_EncKrbCredPart(const unsigned char *p, size_t len, EncKrbCredPart *data, size_t *size)
5512 : {
5513 17107 : memset(data, 0, sizeof(*data));
5514 17107 : return _asn1_decode_top(asn1_EncKrbCredPart, 0|0, p, len, data, size);
5515 : }
5516 :
5517 :
5518 : int ASN1CALL
5519 17096 : encode_EncKrbCredPart(unsigned char *p, size_t len, const EncKrbCredPart *data, size_t *size)
5520 : {
5521 17096 : return _asn1_encode(asn1_EncKrbCredPart, p, len, data, size);
5522 : }
5523 :
5524 :
5525 : size_t ASN1CALL
5526 17096 : length_EncKrbCredPart(const EncKrbCredPart *data)
5527 : {
5528 17096 : return _asn1_length(asn1_EncKrbCredPart, data);
5529 : }
5530 :
5531 :
5532 : void ASN1CALL
5533 34203 : free_EncKrbCredPart(EncKrbCredPart *data)
5534 : {
5535 34203 : _asn1_free_top(asn1_EncKrbCredPart, data);
5536 34203 : }
5537 :
5538 :
5539 : int ASN1CALL
5540 0 : copy_EncKrbCredPart(const EncKrbCredPart *from, EncKrbCredPart *to)
5541 : {
5542 0 : return _asn1_copy_top(asn1_EncKrbCredPart, from, to);
5543 : }
5544 :
5545 :
5546 : char * ASN1CALL
5547 0 : print_EncKrbCredPart(const EncKrbCredPart *data, int flags)
5548 : {
5549 0 : return _asn1_print_top(asn1_EncKrbCredPart, flags, data);
5550 : }
5551 :
5552 : /* template_members: KRB_ERROR exp exp */
5553 : /* template_members: KRB_ERROR exp exp */
5554 : /* tsequence: members isstruct: 1 */
5555 : /* template_members: KRB_ERROR exp exp */
5556 : /* generate_template_type: KRB_ERROR_tag_pvno_267 */
5557 : /* template_members: KRB_ERROR exp exp */
5558 : /* generate_template_type: KRB_ERROR_tag_msg_type_268 */
5559 : /* template_members: KRB_ERROR exp exp */
5560 : /* generate_template_type: KRB_ERROR_tag_ctime_269 */
5561 : /* template_members: KRB_ERROR exp exp */
5562 : /* generate_template_type: KRB_ERROR_tag_cusec_270 */
5563 : /* template_members: KRB_ERROR exp exp */
5564 : /* generate_template_type: KRB_ERROR_tag_stime_271 */
5565 : /* template_members: KRB_ERROR exp exp */
5566 : /* generate_template_type: KRB_ERROR_tag_susec_272 */
5567 : /* template_members: KRB_ERROR exp exp */
5568 : /* generate_template_type: KRB_ERROR_tag_error_code_273 */
5569 : /* template_members: KRB_ERROR exp exp */
5570 : /* generate_template_type: KRB_ERROR_tag_crealm_274 */
5571 : /* template_members: KRB_ERROR exp exp */
5572 : /* generate_template_type: KRB_ERROR_tag_cname_275 */
5573 : /* template_members: KRB_ERROR exp exp */
5574 : /* generate_template_type: KRB_ERROR_tag_realm_276 */
5575 : /* template_members: KRB_ERROR exp exp */
5576 : /* generate_template_type: KRB_ERROR_tag_sname_277 */
5577 : /* template_members: KRB_ERROR exp exp */
5578 : /* template_members: heim_general_string exp exp */
5579 : /* generate_template_type: heim_general_string_tag_e_text_279 */
5580 : /* generate_template_type: KRB_ERROR_tag_e_text_278 */
5581 : /* template_members: KRB_ERROR exp exp */
5582 : /* template_members: heim_octet_string exp exp */
5583 : /* generate_template_type: heim_octet_string_tag_e_data_281 */
5584 : /* generate_template_type: KRB_ERROR_tag_e_data_280 */
5585 : /* generate_template_type: KRB_ERROR_tag__266 */
5586 : const struct asn1_template asn1_KRB_ERROR_tag__266[] = {
5587 : /* 0 */ { 0, sizeof(struct KRB_ERROR), ((void *)(uintptr_t)27) },
5588 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KRB_ERROR, pvno), asn1_HostAddress_tag_addr_type_16 },
5589 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KRB_ERROR, msg_type), asn1_KDC_REQ_tag_msg_type_157 },
5590 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct KRB_ERROR, ctime), asn1_LastReq_val_tag_lr_value_33 },
5591 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct KRB_ERROR, cusec), asn1_HostAddress_tag_addr_type_16 },
5592 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct KRB_ERROR, stime), asn1_LastReq_val_tag_lr_value_33 },
5593 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5), offsetof(struct KRB_ERROR, susec), asn1_HostAddress_tag_addr_type_16 },
5594 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6), offsetof(struct KRB_ERROR, error_code), asn1_HostAddress_tag_addr_type_16 },
5595 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7)|A1_FLAG_OPTIONAL, offsetof(struct KRB_ERROR, crealm), asn1_Ticket_tag_realm_50 },
5596 : /* 9 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,8)|A1_FLAG_OPTIONAL, offsetof(struct KRB_ERROR, cname), asn1_Ticket_tag_sname_51 },
5597 : /* 10 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,9), offsetof(struct KRB_ERROR, realm), asn1_Ticket_tag_realm_50 },
5598 : /* 11 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,10), offsetof(struct KRB_ERROR, sname), asn1_Ticket_tag_sname_51 },
5599 : /* 12 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,11)|A1_FLAG_OPTIONAL, offsetof(struct KRB_ERROR, e_text), asn1_PrincipalName_name_string_0 },
5600 : /* 13 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,12)|A1_FLAG_OPTIONAL, offsetof(struct KRB_ERROR, e_data), asn1_HostAddress_tag_address_17 },
5601 : /* 14 */ { A1_OP_NAME, 0, "KRB_ERROR" },
5602 : /* 15 */ { A1_OP_NAME, 0, "pvno" },
5603 : /* 16 */ { A1_OP_NAME, 0, "msg-type" },
5604 : /* 17 */ { A1_OP_NAME, 0, "ctime" },
5605 : /* 18 */ { A1_OP_NAME, 0, "cusec" },
5606 : /* 19 */ { A1_OP_NAME, 0, "stime" },
5607 : /* 20 */ { A1_OP_NAME, 0, "susec" },
5608 : /* 21 */ { A1_OP_NAME, 0, "error-code" },
5609 : /* 22 */ { A1_OP_NAME, 0, "crealm" },
5610 : /* 23 */ { A1_OP_NAME, 0, "cname" },
5611 : /* 24 */ { A1_OP_NAME, 0, "realm" },
5612 : /* 25 */ { A1_OP_NAME, 0, "sname" },
5613 : /* 26 */ { A1_OP_NAME, 0, "e-text" },
5614 : /* 27 */ { A1_OP_NAME, 0, "e-data" }
5615 : };
5616 : /* generate_template_type: KRB_ERROR_tag__265 */
5617 : const struct asn1_template asn1_KRB_ERROR_tag__265[] = {
5618 : /* 0 */ { 0, sizeof(struct KRB_ERROR), ((void *)(uintptr_t)1) },
5619 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KRB_ERROR_tag__266 }
5620 : };
5621 : /* generate_template_type: KRB_ERROR */
5622 : const struct asn1_template asn1_KRB_ERROR[] = {
5623 : /* 0 */ { 0, sizeof(KRB_ERROR), ((void *)(uintptr_t)1) },
5624 : /* 1 */ { A1_TAG_T(ASN1_C_APPL,CONS,30), 0, asn1_KRB_ERROR_tag__265 }
5625 : };
5626 :
5627 : int ASN1CALL
5628 63814 : decode_KRB_ERROR(const unsigned char *p, size_t len, KRB_ERROR *data, size_t *size)
5629 : {
5630 63814 : memset(data, 0, sizeof(*data));
5631 63814 : return _asn1_decode_top(asn1_KRB_ERROR, 0|0, p, len, data, size);
5632 : }
5633 :
5634 :
5635 : int ASN1CALL
5636 22825 : encode_KRB_ERROR(unsigned char *p, size_t len, const KRB_ERROR *data, size_t *size)
5637 : {
5638 22825 : return _asn1_encode(asn1_KRB_ERROR, p, len, data, size);
5639 : }
5640 :
5641 :
5642 : size_t ASN1CALL
5643 22825 : length_KRB_ERROR(const KRB_ERROR *data)
5644 : {
5645 22825 : return _asn1_length(asn1_KRB_ERROR, data);
5646 : }
5647 :
5648 :
5649 : void ASN1CALL
5650 75824 : free_KRB_ERROR(KRB_ERROR *data)
5651 : {
5652 75824 : _asn1_free_top(asn1_KRB_ERROR, data);
5653 75824 : }
5654 :
5655 :
5656 : int ASN1CALL
5657 0 : copy_KRB_ERROR(const KRB_ERROR *from, KRB_ERROR *to)
5658 : {
5659 0 : return _asn1_copy_top(asn1_KRB_ERROR, from, to);
5660 : }
5661 :
5662 :
5663 : char * ASN1CALL
5664 0 : print_KRB_ERROR(const KRB_ERROR *data, int flags)
5665 : {
5666 0 : return _asn1_print_top(asn1_KRB_ERROR, flags, data);
5667 : }
5668 :
5669 : /* template_members: ChangePasswdDataMS exp exp */
5670 : /* tsequence: members isstruct: 1 */
5671 : /* template_members: ChangePasswdDataMS exp exp */
5672 : /* template_members: heim_octet_string exp exp */
5673 : /* generate_template_type: heim_octet_string_tag_newpasswd_284 */
5674 : /* generate_template_type: ChangePasswdDataMS_tag_newpasswd_283 */
5675 : /* template_members: ChangePasswdDataMS exp exp */
5676 : /* generate_template_type: ChangePasswdDataMS_tag_targname_285 */
5677 : /* template_members: ChangePasswdDataMS exp exp */
5678 : /* generate_template_type: ChangePasswdDataMS_tag_targrealm_286 */
5679 : /* generate_template_type: ChangePasswdDataMS_tag__282 */
5680 : const struct asn1_template asn1_ChangePasswdDataMS_tag__282[] = {
5681 : /* 0 */ { 0, sizeof(struct ChangePasswdDataMS), ((void *)(uintptr_t)7) },
5682 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct ChangePasswdDataMS, newpasswd), asn1_HostAddress_tag_address_17 },
5683 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct ChangePasswdDataMS, targname), asn1_Ticket_tag_sname_51 },
5684 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct ChangePasswdDataMS, targrealm), asn1_Ticket_tag_realm_50 },
5685 : /* 4 */ { A1_OP_NAME, 0, "ChangePasswdDataMS" },
5686 : /* 5 */ { A1_OP_NAME, 0, "newpasswd" },
5687 : /* 6 */ { A1_OP_NAME, 0, "targname" },
5688 : /* 7 */ { A1_OP_NAME, 0, "targrealm" }
5689 : };
5690 : /* generate_template_type: ChangePasswdDataMS */
5691 : const struct asn1_template asn1_ChangePasswdDataMS[] = {
5692 : /* 0 */ { 0, sizeof(ChangePasswdDataMS), ((void *)(uintptr_t)1) },
5693 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_ChangePasswdDataMS_tag__282 }
5694 : };
5695 :
5696 : int ASN1CALL
5697 20 : decode_ChangePasswdDataMS(const unsigned char *p, size_t len, ChangePasswdDataMS *data, size_t *size)
5698 : {
5699 20 : memset(data, 0, sizeof(*data));
5700 20 : return _asn1_decode_top(asn1_ChangePasswdDataMS, 0|0, p, len, data, size);
5701 : }
5702 :
5703 :
5704 : int ASN1CALL
5705 20 : encode_ChangePasswdDataMS(unsigned char *p, size_t len, const ChangePasswdDataMS *data, size_t *size)
5706 : {
5707 20 : return _asn1_encode(asn1_ChangePasswdDataMS, p, len, data, size);
5708 : }
5709 :
5710 :
5711 : size_t ASN1CALL
5712 20 : length_ChangePasswdDataMS(const ChangePasswdDataMS *data)
5713 : {
5714 20 : return _asn1_length(asn1_ChangePasswdDataMS, data);
5715 : }
5716 :
5717 :
5718 : void ASN1CALL
5719 20 : free_ChangePasswdDataMS(ChangePasswdDataMS *data)
5720 : {
5721 20 : _asn1_free_top(asn1_ChangePasswdDataMS, data);
5722 20 : }
5723 :
5724 :
5725 : int ASN1CALL
5726 0 : copy_ChangePasswdDataMS(const ChangePasswdDataMS *from, ChangePasswdDataMS *to)
5727 : {
5728 0 : return _asn1_copy_top(asn1_ChangePasswdDataMS, from, to);
5729 : }
5730 :
5731 :
5732 : char * ASN1CALL
5733 0 : print_ChangePasswdDataMS(const ChangePasswdDataMS *data, int flags)
5734 : {
5735 0 : return _asn1_print_top(asn1_ChangePasswdDataMS, flags, data);
5736 : }
5737 :
5738 : /* template_members: EtypeList exp exp */
5739 : /* generate_template_type: ENCTYPE_seofTstruct_15 */
5740 : /* generate_template_type: EtypeList_tag__287 */
5741 : /* generate_template_type: EtypeList */
5742 : const struct asn1_template asn1_EtypeList[] = {
5743 : /* 0 */ { 0, sizeof(EtypeList), ((void *)(uintptr_t)1) },
5744 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_KERB_KEY_LIST_REQ_tag__176 }
5745 : };
5746 :
5747 : int ASN1CALL
5748 17983 : decode_EtypeList(const unsigned char *p, size_t len, EtypeList *data, size_t *size)
5749 : {
5750 17983 : memset(data, 0, sizeof(*data));
5751 17983 : return _asn1_decode_top(asn1_EtypeList, 0|0, p, len, data, size);
5752 : }
5753 :
5754 :
5755 : int ASN1CALL
5756 18295 : encode_EtypeList(unsigned char *p, size_t len, const EtypeList *data, size_t *size)
5757 : {
5758 18295 : return _asn1_encode(asn1_EtypeList, p, len, data, size);
5759 : }
5760 :
5761 :
5762 : size_t ASN1CALL
5763 18295 : length_EtypeList(const EtypeList *data)
5764 : {
5765 18295 : return _asn1_length(asn1_EtypeList, data);
5766 : }
5767 :
5768 :
5769 : void ASN1CALL
5770 74975 : free_EtypeList(EtypeList *data)
5771 : {
5772 74975 : _asn1_free_top(asn1_EtypeList, data);
5773 74975 : }
5774 :
5775 :
5776 : int ASN1CALL
5777 0 : copy_EtypeList(const EtypeList *from, EtypeList *to)
5778 : {
5779 0 : return _asn1_copy_top(asn1_EtypeList, from, to);
5780 : }
5781 :
5782 :
5783 : char * ASN1CALL
5784 0 : print_EtypeList(const EtypeList *data, int flags)
5785 : {
5786 0 : return _asn1_print_top(asn1_EtypeList, flags, data);
5787 : }
5788 :
5789 : /* generate_template_type: AD_IF_RELEVANT */
5790 : const struct asn1_template asn1_AD_IF_RELEVANT[] = {
5791 : /* 0 */ { 0, sizeof(AD_IF_RELEVANT), ((void *)(uintptr_t)1) },
5792 : /* 1 */ { A1_OP_TYPE , 0, asn1_AuthorizationData }
5793 : };
5794 :
5795 : int ASN1CALL
5796 0 : decode_AD_IF_RELEVANT(const unsigned char *p, size_t len, AD_IF_RELEVANT *data, size_t *size)
5797 : {
5798 0 : memset(data, 0, sizeof(*data));
5799 0 : return _asn1_decode_top(asn1_AD_IF_RELEVANT, 0|0, p, len, data, size);
5800 : }
5801 :
5802 :
5803 : int ASN1CALL
5804 0 : encode_AD_IF_RELEVANT(unsigned char *p, size_t len, const AD_IF_RELEVANT *data, size_t *size)
5805 : {
5806 0 : return _asn1_encode(asn1_AD_IF_RELEVANT, p, len, data, size);
5807 : }
5808 :
5809 :
5810 : size_t ASN1CALL
5811 0 : length_AD_IF_RELEVANT(const AD_IF_RELEVANT *data)
5812 : {
5813 0 : return _asn1_length(asn1_AD_IF_RELEVANT, data);
5814 : }
5815 :
5816 :
5817 : void ASN1CALL
5818 0 : free_AD_IF_RELEVANT(AD_IF_RELEVANT *data)
5819 : {
5820 0 : _asn1_free_top(asn1_AD_IF_RELEVANT, data);
5821 0 : }
5822 :
5823 :
5824 : int ASN1CALL
5825 0 : copy_AD_IF_RELEVANT(const AD_IF_RELEVANT *from, AD_IF_RELEVANT *to)
5826 : {
5827 0 : return _asn1_copy_top(asn1_AD_IF_RELEVANT, from, to);
5828 : }
5829 :
5830 :
5831 : char * ASN1CALL
5832 0 : print_AD_IF_RELEVANT(const AD_IF_RELEVANT *data, int flags)
5833 : {
5834 0 : return _asn1_print_top(asn1_AD_IF_RELEVANT, flags, data);
5835 : }
5836 :
5837 : /* template_members: AD_KDCIssued exp exp */
5838 : /* tsequence: members isstruct: 1 */
5839 : /* template_members: AD_KDCIssued exp exp */
5840 : /* generate_template_type: AD_KDCIssued_tag_ad_checksum_289 */
5841 : /* template_members: AD_KDCIssued exp exp */
5842 : /* generate_template_type: AD_KDCIssued_tag_i_realm_290 */
5843 : /* template_members: AD_KDCIssued exp exp */
5844 : /* generate_template_type: AD_KDCIssued_tag_i_sname_291 */
5845 : /* template_members: AD_KDCIssued exp exp */
5846 : /* generate_template_type: AD_KDCIssued_tag_elements_292 */
5847 : /* generate_template_type: AD_KDCIssued_tag__288 */
5848 : const struct asn1_template asn1_AD_KDCIssued_tag__288[] = {
5849 : /* 0 */ { 0, sizeof(struct AD_KDCIssued), ((void *)(uintptr_t)9) },
5850 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct AD_KDCIssued, ad_checksum), asn1_Authenticator_tag_cksum_112 },
5851 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct AD_KDCIssued, i_realm), asn1_Ticket_tag_realm_50 },
5852 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct AD_KDCIssued, i_sname), asn1_Ticket_tag_sname_51 },
5853 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct AD_KDCIssued, elements), asn1_EncTicketPart_tag_authorization_data_65 },
5854 : /* 5 */ { A1_OP_NAME, 0, "AD_KDCIssued" },
5855 : /* 6 */ { A1_OP_NAME, 0, "ad-checksum" },
5856 : /* 7 */ { A1_OP_NAME, 0, "i-realm" },
5857 : /* 8 */ { A1_OP_NAME, 0, "i-sname" },
5858 : /* 9 */ { A1_OP_NAME, 0, "elements" }
5859 : };
5860 : /* generate_template_type: AD_KDCIssued */
5861 : const struct asn1_template asn1_AD_KDCIssued[] = {
5862 : /* 0 */ { 0, sizeof(AD_KDCIssued), ((void *)(uintptr_t)1) },
5863 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_AD_KDCIssued_tag__288 }
5864 : };
5865 :
5866 : int ASN1CALL
5867 0 : decode_AD_KDCIssued(const unsigned char *p, size_t len, AD_KDCIssued *data, size_t *size)
5868 : {
5869 0 : memset(data, 0, sizeof(*data));
5870 0 : return _asn1_decode_top(asn1_AD_KDCIssued, 0|0, p, len, data, size);
5871 : }
5872 :
5873 :
5874 : int ASN1CALL
5875 0 : encode_AD_KDCIssued(unsigned char *p, size_t len, const AD_KDCIssued *data, size_t *size)
5876 : {
5877 0 : return _asn1_encode(asn1_AD_KDCIssued, p, len, data, size);
5878 : }
5879 :
5880 :
5881 : size_t ASN1CALL
5882 0 : length_AD_KDCIssued(const AD_KDCIssued *data)
5883 : {
5884 0 : return _asn1_length(asn1_AD_KDCIssued, data);
5885 : }
5886 :
5887 :
5888 : void ASN1CALL
5889 0 : free_AD_KDCIssued(AD_KDCIssued *data)
5890 : {
5891 0 : _asn1_free_top(asn1_AD_KDCIssued, data);
5892 0 : }
5893 :
5894 :
5895 : int ASN1CALL
5896 0 : copy_AD_KDCIssued(const AD_KDCIssued *from, AD_KDCIssued *to)
5897 : {
5898 0 : return _asn1_copy_top(asn1_AD_KDCIssued, from, to);
5899 : }
5900 :
5901 :
5902 : char * ASN1CALL
5903 0 : print_AD_KDCIssued(const AD_KDCIssued *data, int flags)
5904 : {
5905 0 : return _asn1_print_top(asn1_AD_KDCIssued, flags, data);
5906 : }
5907 :
5908 : /* template_members: AD_AND_OR exp exp */
5909 : /* tsequence: members isstruct: 1 */
5910 : /* template_members: AD_AND_OR exp exp */
5911 : /* generate_template_type: AD_AND_OR_tag_condition_count_294 */
5912 : /* template_members: AD_AND_OR exp exp */
5913 : /* generate_template_type: AD_AND_OR_tag_elements_295 */
5914 : /* generate_template_type: AD_AND_OR_tag__293 */
5915 : const struct asn1_template asn1_AD_AND_OR_tag__293[] = {
5916 : /* 0 */ { 0, sizeof(struct AD_AND_OR), ((void *)(uintptr_t)5) },
5917 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct AD_AND_OR, condition_count), asn1_HostAddress_tag_addr_type_16 },
5918 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct AD_AND_OR, elements), asn1_EncTicketPart_tag_authorization_data_65 },
5919 : /* 3 */ { A1_OP_NAME, 0, "AD_AND_OR" },
5920 : /* 4 */ { A1_OP_NAME, 0, "condition-count" },
5921 : /* 5 */ { A1_OP_NAME, 0, "elements" }
5922 : };
5923 : /* generate_template_type: AD_AND_OR */
5924 : const struct asn1_template asn1_AD_AND_OR[] = {
5925 : /* 0 */ { 0, sizeof(AD_AND_OR), ((void *)(uintptr_t)1) },
5926 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_AD_AND_OR_tag__293 }
5927 : };
5928 :
5929 : int ASN1CALL
5930 0 : decode_AD_AND_OR(const unsigned char *p, size_t len, AD_AND_OR *data, size_t *size)
5931 : {
5932 0 : memset(data, 0, sizeof(*data));
5933 0 : return _asn1_decode_top(asn1_AD_AND_OR, 0|0, p, len, data, size);
5934 : }
5935 :
5936 :
5937 : int ASN1CALL
5938 0 : encode_AD_AND_OR(unsigned char *p, size_t len, const AD_AND_OR *data, size_t *size)
5939 : {
5940 0 : return _asn1_encode(asn1_AD_AND_OR, p, len, data, size);
5941 : }
5942 :
5943 :
5944 : size_t ASN1CALL
5945 0 : length_AD_AND_OR(const AD_AND_OR *data)
5946 : {
5947 0 : return _asn1_length(asn1_AD_AND_OR, data);
5948 : }
5949 :
5950 :
5951 : void ASN1CALL
5952 0 : free_AD_AND_OR(AD_AND_OR *data)
5953 : {
5954 0 : _asn1_free_top(asn1_AD_AND_OR, data);
5955 0 : }
5956 :
5957 :
5958 : int ASN1CALL
5959 0 : copy_AD_AND_OR(const AD_AND_OR *from, AD_AND_OR *to)
5960 : {
5961 0 : return _asn1_copy_top(asn1_AD_AND_OR, from, to);
5962 : }
5963 :
5964 :
5965 : char * ASN1CALL
5966 0 : print_AD_AND_OR(const AD_AND_OR *data, int flags)
5967 : {
5968 0 : return _asn1_print_top(asn1_AD_AND_OR, flags, data);
5969 : }
5970 :
5971 : /* generate_template_type: AD_MANDATORY_FOR_KDC */
5972 : const struct asn1_template asn1_AD_MANDATORY_FOR_KDC[] = {
5973 : /* 0 */ { 0, sizeof(AD_MANDATORY_FOR_KDC), ((void *)(uintptr_t)1) },
5974 : /* 1 */ { A1_OP_TYPE , 0, asn1_AuthorizationData }
5975 : };
5976 :
5977 : int ASN1CALL
5978 0 : decode_AD_MANDATORY_FOR_KDC(const unsigned char *p, size_t len, AD_MANDATORY_FOR_KDC *data, size_t *size)
5979 : {
5980 0 : memset(data, 0, sizeof(*data));
5981 0 : return _asn1_decode_top(asn1_AD_MANDATORY_FOR_KDC, 0|0, p, len, data, size);
5982 : }
5983 :
5984 :
5985 : int ASN1CALL
5986 0 : encode_AD_MANDATORY_FOR_KDC(unsigned char *p, size_t len, const AD_MANDATORY_FOR_KDC *data, size_t *size)
5987 : {
5988 0 : return _asn1_encode(asn1_AD_MANDATORY_FOR_KDC, p, len, data, size);
5989 : }
5990 :
5991 :
5992 : size_t ASN1CALL
5993 0 : length_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *data)
5994 : {
5995 0 : return _asn1_length(asn1_AD_MANDATORY_FOR_KDC, data);
5996 : }
5997 :
5998 :
5999 : void ASN1CALL
6000 0 : free_AD_MANDATORY_FOR_KDC(AD_MANDATORY_FOR_KDC *data)
6001 : {
6002 0 : _asn1_free_top(asn1_AD_MANDATORY_FOR_KDC, data);
6003 0 : }
6004 :
6005 :
6006 : int ASN1CALL
6007 0 : copy_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *from, AD_MANDATORY_FOR_KDC *to)
6008 : {
6009 0 : return _asn1_copy_top(asn1_AD_MANDATORY_FOR_KDC, from, to);
6010 : }
6011 :
6012 :
6013 : char * ASN1CALL
6014 0 : print_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *data, int flags)
6015 : {
6016 0 : return _asn1_print_top(asn1_AD_MANDATORY_FOR_KDC, flags, data);
6017 : }
6018 :
6019 : /* template_members: PA_SAM_TYPE exp exp */
6020 : const struct asn1_template asn1_PA_SAM_TYPE_enum_names[] = {
6021 : /* 0 */ { 0, 0, ((void *)(uintptr_t)6) },
6022 : /* 1 */ { A1_OP_NAME, 1, "PA_SAM_TYPE_ENIGMA" },
6023 : /* 2 */ { A1_OP_NAME, 2, "PA_SAM_TYPE_DIGI_PATH" },
6024 : /* 3 */ { A1_OP_NAME, 3, "PA_SAM_TYPE_SKEY_K0" },
6025 : /* 4 */ { A1_OP_NAME, 4, "PA_SAM_TYPE_SKEY" },
6026 : /* 5 */ { A1_OP_NAME, 5, "PA_SAM_TYPE_SECURID" },
6027 : /* 6 */ { A1_OP_NAME, 6, "PA_SAM_TYPE_CRYPTOCARD" }
6028 : };
6029 : /* generate_template_type: PA_SAM_TYPE_tag__296 */
6030 : const struct asn1_template asn1_PA_SAM_TYPE_tag__296[] = {
6031 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
6032 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_PA_SAM_TYPE_enum_names }
6033 : };
6034 : /* generate_template_type: PA_SAM_TYPE */
6035 : const struct asn1_template asn1_PA_SAM_TYPE[] = {
6036 : /* 0 */ { 0, sizeof(PA_SAM_TYPE), ((void *)(uintptr_t)1) },
6037 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_PA_SAM_TYPE_tag__296 }
6038 : };
6039 :
6040 : int ASN1CALL
6041 0 : decode_PA_SAM_TYPE(const unsigned char *p, size_t len, PA_SAM_TYPE *data, size_t *size)
6042 : {
6043 0 : memset(data, 0, sizeof(*data));
6044 0 : return _asn1_decode_top(asn1_PA_SAM_TYPE, 0|0, p, len, data, size);
6045 : }
6046 :
6047 :
6048 : int ASN1CALL
6049 0 : encode_PA_SAM_TYPE(unsigned char *p, size_t len, const PA_SAM_TYPE *data, size_t *size)
6050 : {
6051 0 : return _asn1_encode(asn1_PA_SAM_TYPE, p, len, data, size);
6052 : }
6053 :
6054 :
6055 : size_t ASN1CALL
6056 0 : length_PA_SAM_TYPE(const PA_SAM_TYPE *data)
6057 : {
6058 0 : return _asn1_length(asn1_PA_SAM_TYPE, data);
6059 : }
6060 :
6061 :
6062 : void ASN1CALL
6063 0 : free_PA_SAM_TYPE(PA_SAM_TYPE *data)
6064 : {
6065 0 : _asn1_free_top(asn1_PA_SAM_TYPE, data);
6066 0 : }
6067 :
6068 :
6069 : int ASN1CALL
6070 0 : copy_PA_SAM_TYPE(const PA_SAM_TYPE *from, PA_SAM_TYPE *to)
6071 : {
6072 0 : return _asn1_copy_top(asn1_PA_SAM_TYPE, from, to);
6073 : }
6074 :
6075 :
6076 : char * ASN1CALL
6077 0 : print_PA_SAM_TYPE(const PA_SAM_TYPE *data, int flags)
6078 : {
6079 0 : return _asn1_print_top(asn1_PA_SAM_TYPE, flags, data);
6080 : }
6081 :
6082 : /* generate_template_type: PA_SAM_REDIRECT */
6083 : const struct asn1_template asn1_PA_SAM_REDIRECT[] = {
6084 : /* 0 */ { 0, sizeof(PA_SAM_REDIRECT), ((void *)(uintptr_t)1) },
6085 : /* 1 */ { A1_OP_TYPE , 0, asn1_HostAddresses }
6086 : };
6087 :
6088 : int ASN1CALL
6089 0 : decode_PA_SAM_REDIRECT(const unsigned char *p, size_t len, PA_SAM_REDIRECT *data, size_t *size)
6090 : {
6091 0 : memset(data, 0, sizeof(*data));
6092 0 : return _asn1_decode_top(asn1_PA_SAM_REDIRECT, 0|0, p, len, data, size);
6093 : }
6094 :
6095 :
6096 : int ASN1CALL
6097 0 : encode_PA_SAM_REDIRECT(unsigned char *p, size_t len, const PA_SAM_REDIRECT *data, size_t *size)
6098 : {
6099 0 : return _asn1_encode(asn1_PA_SAM_REDIRECT, p, len, data, size);
6100 : }
6101 :
6102 :
6103 : size_t ASN1CALL
6104 0 : length_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *data)
6105 : {
6106 0 : return _asn1_length(asn1_PA_SAM_REDIRECT, data);
6107 : }
6108 :
6109 :
6110 : void ASN1CALL
6111 0 : free_PA_SAM_REDIRECT(PA_SAM_REDIRECT *data)
6112 : {
6113 0 : _asn1_free_top(asn1_PA_SAM_REDIRECT, data);
6114 0 : }
6115 :
6116 :
6117 : int ASN1CALL
6118 0 : copy_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *from, PA_SAM_REDIRECT *to)
6119 : {
6120 0 : return _asn1_copy_top(asn1_PA_SAM_REDIRECT, from, to);
6121 : }
6122 :
6123 :
6124 : char * ASN1CALL
6125 0 : print_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *data, int flags)
6126 : {
6127 0 : return _asn1_print_top(asn1_PA_SAM_REDIRECT, flags, data);
6128 : }
6129 :
6130 : /* template_members: SAMFlags exp exp */
6131 : static const struct asn1_template asn1_SAMFlags_bmember__4[] = {
6132 : /* 0 */ { 0|A1_HBF_RFC1510, sizeof(SAMFlags), ((void *)(uintptr_t)3) },
6133 : /* 1 */ { 0, 0, "use_sad_as_key" },
6134 : /* 2 */ { 0, 1, "send_encrypted_sad" },
6135 : /* 3 */ { 0, 2, "must_pk_encrypt_sad" }
6136 : };
6137 : /* generate_template_type: SAMFlags_tag__297 */
6138 : const struct asn1_template asn1_SAMFlags_tag__297[] = {
6139 : /* 0 */ { 0, sizeof(SAMFlags), ((void *)(uintptr_t)1) },
6140 : /* 1 */ { A1_OP_BMEMBER, 0, asn1_SAMFlags_bmember__4 }
6141 : };
6142 : /* generate_template_type: SAMFlags */
6143 : const struct asn1_template asn1_SAMFlags[] = {
6144 : /* 0 */ { 0, sizeof(SAMFlags), ((void *)(uintptr_t)1) },
6145 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_BitString), 0, asn1_SAMFlags_tag__297 }
6146 : };
6147 :
6148 : int ASN1CALL
6149 0 : decode_SAMFlags(const unsigned char *p, size_t len, SAMFlags *data, size_t *size)
6150 : {
6151 0 : memset(data, 0, sizeof(*data));
6152 0 : return _asn1_decode_top(asn1_SAMFlags, 0|0, p, len, data, size);
6153 : }
6154 :
6155 :
6156 : int ASN1CALL
6157 0 : encode_SAMFlags(unsigned char *p, size_t len, const SAMFlags *data, size_t *size)
6158 : {
6159 0 : return _asn1_encode(asn1_SAMFlags, p, len, data, size);
6160 : }
6161 :
6162 :
6163 : size_t ASN1CALL
6164 0 : length_SAMFlags(const SAMFlags *data)
6165 : {
6166 0 : return _asn1_length(asn1_SAMFlags, data);
6167 : }
6168 :
6169 :
6170 : void ASN1CALL
6171 0 : free_SAMFlags(SAMFlags *data)
6172 : {
6173 0 : _asn1_free_top(asn1_SAMFlags, data);
6174 0 : }
6175 :
6176 :
6177 : int ASN1CALL
6178 0 : copy_SAMFlags(const SAMFlags *from, SAMFlags *to)
6179 : {
6180 0 : return _asn1_copy_top(asn1_SAMFlags, from, to);
6181 : }
6182 :
6183 :
6184 : char * ASN1CALL
6185 0 : print_SAMFlags(const SAMFlags *data, int flags)
6186 : {
6187 0 : return _asn1_print_top(asn1_SAMFlags, flags, data);
6188 : }
6189 :
6190 0 : uint64_t SAMFlags2int(SAMFlags f)
6191 : {
6192 0 : uint64_t r = 0;
6193 0 : if(f.use_sad_as_key) r |= (1ULL << 0);
6194 0 : if(f.send_encrypted_sad) r |= (1ULL << 1);
6195 0 : if(f.must_pk_encrypt_sad) r |= (1ULL << 2);
6196 0 : return r;
6197 : }
6198 :
6199 0 : SAMFlags int2SAMFlags(uint64_t n)
6200 : {
6201 : SAMFlags flags;
6202 :
6203 0 : memset(&flags, 0, sizeof(flags));
6204 :
6205 0 : flags.use_sad_as_key = (n >> 0) & 1;
6206 0 : flags.send_encrypted_sad = (n >> 1) & 1;
6207 0 : flags.must_pk_encrypt_sad = (n >> 2) & 1;
6208 0 : return flags;
6209 : }
6210 :
6211 : static struct units SAMFlags_units[] = {
6212 : {"must-pk-encrypt-sad", 1ULL << 2},
6213 : {"send-encrypted-sad", 1ULL << 1},
6214 : {"use-sad-as-key", 1ULL << 0},
6215 : {NULL, 0}
6216 : };
6217 :
6218 0 : const struct units * asn1_SAMFlags_units(void){
6219 0 : return SAMFlags_units;
6220 : }
6221 :
6222 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6223 : /* tsequence: members isstruct: 1 */
6224 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6225 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_type_299 */
6226 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6227 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_flags_300 */
6228 : const struct asn1_template asn1_PA_SAM_CHALLENGE_2_BODY_tag_sam_flags_300[] = {
6229 : /* 0 */ { 0, sizeof(SAMFlags), ((void *)(uintptr_t)1) },
6230 : /* 1 */ { A1_OP_TYPE , 0, asn1_SAMFlags }
6231 : };
6232 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6233 : /* template_members: heim_general_string exp exp */
6234 : /* generate_template_type: heim_general_string_tag_sam_type_name_302 */
6235 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_type_name_301 */
6236 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6237 : /* template_members: heim_general_string exp exp */
6238 : /* generate_template_type: heim_general_string_tag_sam_track_id_304 */
6239 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_track_id_303 */
6240 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6241 : /* template_members: heim_general_string exp exp */
6242 : /* generate_template_type: heim_general_string_tag_sam_challenge_label_306 */
6243 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_challenge_label_305 */
6244 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6245 : /* template_members: heim_general_string exp exp */
6246 : /* generate_template_type: heim_general_string_tag_sam_challenge_308 */
6247 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_challenge_307 */
6248 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6249 : /* template_members: heim_general_string exp exp */
6250 : /* generate_template_type: heim_general_string_tag_sam_response_prompt_310 */
6251 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_response_prompt_309 */
6252 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6253 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_pk_for_sad_311 */
6254 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6255 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_nonce_312 */
6256 : /* template_members: PA_SAM_CHALLENGE_2_BODY exp exp */
6257 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag_sam_etype_313 */
6258 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY_tag__298 */
6259 : const struct asn1_template asn1_PA_SAM_CHALLENGE_2_BODY_tag__298[] = {
6260 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct PA_SAM_CHALLENGE_2_BODY), ((void *)(uintptr_t)22) },
6261 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_type), asn1_HostAddress_tag_addr_type_16 },
6262 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_flags), asn1_PA_SAM_CHALLENGE_2_BODY_tag_sam_flags_300 },
6263 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_type_name), asn1_PrincipalName_name_string_0 },
6264 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_track_id), asn1_PrincipalName_name_string_0 },
6265 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_challenge_label), asn1_PrincipalName_name_string_0 },
6266 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5)|A1_FLAG_OPTIONAL, offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_challenge), asn1_PrincipalName_name_string_0 },
6267 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6)|A1_FLAG_OPTIONAL, offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_response_prompt), asn1_PrincipalName_name_string_0 },
6268 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7)|A1_FLAG_OPTIONAL, offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_pk_for_sad), asn1_EncTicketPart_tag_key_56 },
6269 : /* 9 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,8), offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_nonce), asn1_HostAddress_tag_addr_type_16 },
6270 : /* 10 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,9), offsetof(struct PA_SAM_CHALLENGE_2_BODY, sam_etype), asn1_HostAddress_tag_addr_type_16 },
6271 : /* 11 */ { A1_OP_NAME, 0, "PA_SAM_CHALLENGE_2_BODY" },
6272 : /* 12 */ { A1_OP_NAME, 0, "sam-type" },
6273 : /* 13 */ { A1_OP_NAME, 0, "sam-flags" },
6274 : /* 14 */ { A1_OP_NAME, 0, "sam-type-name" },
6275 : /* 15 */ { A1_OP_NAME, 0, "sam-track-id" },
6276 : /* 16 */ { A1_OP_NAME, 0, "sam-challenge-label" },
6277 : /* 17 */ { A1_OP_NAME, 0, "sam-challenge" },
6278 : /* 18 */ { A1_OP_NAME, 0, "sam-response-prompt" },
6279 : /* 19 */ { A1_OP_NAME, 0, "sam-pk-for-sad" },
6280 : /* 20 */ { A1_OP_NAME, 0, "sam-nonce" },
6281 : /* 21 */ { A1_OP_NAME, 0, "sam-etype" },
6282 : /* 22 */ { A1_OP_NAME, 0, "..." }
6283 : };
6284 : /* generate_template_type: PA_SAM_CHALLENGE_2_BODY */
6285 : const struct asn1_template asn1_PA_SAM_CHALLENGE_2_BODY[] = {
6286 : /* 0 */ { 0, sizeof(PA_SAM_CHALLENGE_2_BODY), ((void *)(uintptr_t)1) },
6287 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_SAM_CHALLENGE_2_BODY_tag__298 }
6288 : };
6289 :
6290 : int ASN1CALL
6291 0 : decode_PA_SAM_CHALLENGE_2_BODY(const unsigned char *p, size_t len, PA_SAM_CHALLENGE_2_BODY *data, size_t *size)
6292 : {
6293 0 : memset(data, 0, sizeof(*data));
6294 0 : return _asn1_decode_top(asn1_PA_SAM_CHALLENGE_2_BODY, 0|0, p, len, data, size);
6295 : }
6296 :
6297 :
6298 : int ASN1CALL
6299 0 : encode_PA_SAM_CHALLENGE_2_BODY(unsigned char *p, size_t len, const PA_SAM_CHALLENGE_2_BODY *data, size_t *size)
6300 : {
6301 0 : return _asn1_encode(asn1_PA_SAM_CHALLENGE_2_BODY, p, len, data, size);
6302 : }
6303 :
6304 :
6305 : size_t ASN1CALL
6306 0 : length_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *data)
6307 : {
6308 0 : return _asn1_length(asn1_PA_SAM_CHALLENGE_2_BODY, data);
6309 : }
6310 :
6311 :
6312 : void ASN1CALL
6313 0 : free_PA_SAM_CHALLENGE_2_BODY(PA_SAM_CHALLENGE_2_BODY *data)
6314 : {
6315 0 : _asn1_free_top(asn1_PA_SAM_CHALLENGE_2_BODY, data);
6316 0 : }
6317 :
6318 :
6319 : int ASN1CALL
6320 0 : copy_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *from, PA_SAM_CHALLENGE_2_BODY *to)
6321 : {
6322 0 : return _asn1_copy_top(asn1_PA_SAM_CHALLENGE_2_BODY, from, to);
6323 : }
6324 :
6325 :
6326 : char * ASN1CALL
6327 0 : print_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *data, int flags)
6328 : {
6329 0 : return _asn1_print_top(asn1_PA_SAM_CHALLENGE_2_BODY, flags, data);
6330 : }
6331 :
6332 : /* template_members: PA_SAM_CHALLENGE_2 exp exp */
6333 : /* tsequence: members isstruct: 1 */
6334 : /* template_members: PA_SAM_CHALLENGE_2 exp exp */
6335 : /* generate_template_type: PA_SAM_CHALLENGE_2_tag_sam_body_315 */
6336 : const struct asn1_template asn1_PA_SAM_CHALLENGE_2_tag_sam_body_315[] = {
6337 : /* 0 */ { 0, sizeof(PA_SAM_CHALLENGE_2_BODY), ((void *)(uintptr_t)1) },
6338 : /* 1 */ { A1_OP_TYPE , 0, asn1_PA_SAM_CHALLENGE_2_BODY }
6339 : };
6340 : /* template_members: PA_SAM_CHALLENGE_2 exp exp */
6341 : /* template_members: PA_SAM_CHALLENGE_2 exp exp */
6342 : /* generate_template_type: PA_SAM_CHALLENGE_2_sam_cksum_16 */
6343 : /* generate_template_type: PA_SAM_CHALLENGE_2_tag_sam_cksum_317 */
6344 : const struct asn1_template asn1_PA_SAM_CHALLENGE_2_tag_sam_cksum_317[] = {
6345 : /* 0 */ { 0, sizeof(struct PA_SAM_CHALLENGE_2_sam_cksum), ((void *)(uintptr_t)1) },
6346 : /* 1 */ { A1_OP_SEQOF, 0, asn1_Authenticator_tag_cksum_112 }
6347 : };
6348 : /* generate_template_type: PA_SAM_CHALLENGE_2_tag_sam_cksum_316 */
6349 : const struct asn1_template asn1_PA_SAM_CHALLENGE_2_tag_sam_cksum_316[] = {
6350 : /* 0 */ { 0, sizeof(struct PA_SAM_CHALLENGE_2_sam_cksum), ((void *)(uintptr_t)1) },
6351 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_SAM_CHALLENGE_2_tag_sam_cksum_317 }
6352 : };
6353 : /* generate_template_type: PA_SAM_CHALLENGE_2_tag__314 */
6354 : const struct asn1_template asn1_PA_SAM_CHALLENGE_2_tag__314[] = {
6355 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct PA_SAM_CHALLENGE_2), ((void *)(uintptr_t)6) },
6356 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_SAM_CHALLENGE_2, sam_body), asn1_PA_SAM_CHALLENGE_2_tag_sam_body_315 },
6357 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct PA_SAM_CHALLENGE_2, sam_cksum), asn1_PA_SAM_CHALLENGE_2_tag_sam_cksum_316 },
6358 : /* 3 */ { A1_OP_NAME, 0, "PA_SAM_CHALLENGE_2" },
6359 : /* 4 */ { A1_OP_NAME, 0, "sam-body" },
6360 : /* 5 */ { A1_OP_NAME, 0, "sam-cksum" },
6361 : /* 6 */ { A1_OP_NAME, 0, "..." }
6362 : };
6363 : /* generate_template_type: PA_SAM_CHALLENGE_2 */
6364 : const struct asn1_template asn1_PA_SAM_CHALLENGE_2[] = {
6365 : /* 0 */ { 0, sizeof(PA_SAM_CHALLENGE_2), ((void *)(uintptr_t)1) },
6366 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_SAM_CHALLENGE_2_tag__314 }
6367 : };
6368 :
6369 : int ASN1CALL
6370 0 : decode_PA_SAM_CHALLENGE_2(const unsigned char *p, size_t len, PA_SAM_CHALLENGE_2 *data, size_t *size)
6371 : {
6372 0 : memset(data, 0, sizeof(*data));
6373 0 : return _asn1_decode_top(asn1_PA_SAM_CHALLENGE_2, 0|0, p, len, data, size);
6374 : }
6375 :
6376 :
6377 : int ASN1CALL
6378 0 : encode_PA_SAM_CHALLENGE_2(unsigned char *p, size_t len, const PA_SAM_CHALLENGE_2 *data, size_t *size)
6379 : {
6380 0 : return _asn1_encode(asn1_PA_SAM_CHALLENGE_2, p, len, data, size);
6381 : }
6382 :
6383 :
6384 : size_t ASN1CALL
6385 0 : length_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *data)
6386 : {
6387 0 : return _asn1_length(asn1_PA_SAM_CHALLENGE_2, data);
6388 : }
6389 :
6390 :
6391 : void ASN1CALL
6392 0 : free_PA_SAM_CHALLENGE_2(PA_SAM_CHALLENGE_2 *data)
6393 : {
6394 0 : _asn1_free_top(asn1_PA_SAM_CHALLENGE_2, data);
6395 0 : }
6396 :
6397 :
6398 : int ASN1CALL
6399 0 : copy_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *from, PA_SAM_CHALLENGE_2 *to)
6400 : {
6401 0 : return _asn1_copy_top(asn1_PA_SAM_CHALLENGE_2, from, to);
6402 : }
6403 :
6404 :
6405 : char * ASN1CALL
6406 0 : print_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *data, int flags)
6407 : {
6408 0 : return _asn1_print_top(asn1_PA_SAM_CHALLENGE_2, flags, data);
6409 : }
6410 :
6411 : /* template_members: PA_SAM_RESPONSE_2 exp exp */
6412 : /* tsequence: members isstruct: 1 */
6413 : /* template_members: PA_SAM_RESPONSE_2 exp exp */
6414 : /* generate_template_type: PA_SAM_RESPONSE_2_tag_sam_type_319 */
6415 : /* template_members: PA_SAM_RESPONSE_2 exp exp */
6416 : /* generate_template_type: PA_SAM_RESPONSE_2_tag_sam_flags_320 */
6417 : /* template_members: PA_SAM_RESPONSE_2 exp exp */
6418 : /* template_members: heim_general_string exp exp */
6419 : /* generate_template_type: heim_general_string_tag_sam_track_id_322 */
6420 : /* generate_template_type: PA_SAM_RESPONSE_2_tag_sam_track_id_321 */
6421 : /* template_members: PA_SAM_RESPONSE_2 exp exp */
6422 : /* generate_template_type: PA_SAM_RESPONSE_2_tag_sam_enc_nonce_or_sad_323 */
6423 : /* template_members: PA_SAM_RESPONSE_2 exp exp */
6424 : /* generate_template_type: PA_SAM_RESPONSE_2_tag_sam_nonce_324 */
6425 : /* generate_template_type: PA_SAM_RESPONSE_2_tag__318 */
6426 : const struct asn1_template asn1_PA_SAM_RESPONSE_2_tag__318[] = {
6427 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct PA_SAM_RESPONSE_2), ((void *)(uintptr_t)12) },
6428 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_SAM_RESPONSE_2, sam_type), asn1_HostAddress_tag_addr_type_16 },
6429 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct PA_SAM_RESPONSE_2, sam_flags), asn1_PA_SAM_CHALLENGE_2_BODY_tag_sam_flags_300 },
6430 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct PA_SAM_RESPONSE_2, sam_track_id), asn1_PrincipalName_name_string_0 },
6431 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct PA_SAM_RESPONSE_2, sam_enc_nonce_or_sad), asn1_Ticket_tag_enc_part_52 },
6432 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct PA_SAM_RESPONSE_2, sam_nonce), asn1_HostAddress_tag_addr_type_16 },
6433 : /* 6 */ { A1_OP_NAME, 0, "PA_SAM_RESPONSE_2" },
6434 : /* 7 */ { A1_OP_NAME, 0, "sam-type" },
6435 : /* 8 */ { A1_OP_NAME, 0, "sam-flags" },
6436 : /* 9 */ { A1_OP_NAME, 0, "sam-track-id" },
6437 : /* 10 */ { A1_OP_NAME, 0, "sam-enc-nonce-or-sad" },
6438 : /* 11 */ { A1_OP_NAME, 0, "sam-nonce" },
6439 : /* 12 */ { A1_OP_NAME, 0, "..." }
6440 : };
6441 : /* generate_template_type: PA_SAM_RESPONSE_2 */
6442 : const struct asn1_template asn1_PA_SAM_RESPONSE_2[] = {
6443 : /* 0 */ { 0, sizeof(PA_SAM_RESPONSE_2), ((void *)(uintptr_t)1) },
6444 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_SAM_RESPONSE_2_tag__318 }
6445 : };
6446 :
6447 : int ASN1CALL
6448 0 : decode_PA_SAM_RESPONSE_2(const unsigned char *p, size_t len, PA_SAM_RESPONSE_2 *data, size_t *size)
6449 : {
6450 0 : memset(data, 0, sizeof(*data));
6451 0 : return _asn1_decode_top(asn1_PA_SAM_RESPONSE_2, 0|0, p, len, data, size);
6452 : }
6453 :
6454 :
6455 : int ASN1CALL
6456 0 : encode_PA_SAM_RESPONSE_2(unsigned char *p, size_t len, const PA_SAM_RESPONSE_2 *data, size_t *size)
6457 : {
6458 0 : return _asn1_encode(asn1_PA_SAM_RESPONSE_2, p, len, data, size);
6459 : }
6460 :
6461 :
6462 : size_t ASN1CALL
6463 0 : length_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *data)
6464 : {
6465 0 : return _asn1_length(asn1_PA_SAM_RESPONSE_2, data);
6466 : }
6467 :
6468 :
6469 : void ASN1CALL
6470 0 : free_PA_SAM_RESPONSE_2(PA_SAM_RESPONSE_2 *data)
6471 : {
6472 0 : _asn1_free_top(asn1_PA_SAM_RESPONSE_2, data);
6473 0 : }
6474 :
6475 :
6476 : int ASN1CALL
6477 0 : copy_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *from, PA_SAM_RESPONSE_2 *to)
6478 : {
6479 0 : return _asn1_copy_top(asn1_PA_SAM_RESPONSE_2, from, to);
6480 : }
6481 :
6482 :
6483 : char * ASN1CALL
6484 0 : print_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *data, int flags)
6485 : {
6486 0 : return _asn1_print_top(asn1_PA_SAM_RESPONSE_2, flags, data);
6487 : }
6488 :
6489 : /* template_members: PA_ENC_SAM_RESPONSE_ENC exp exp */
6490 : /* tsequence: members isstruct: 1 */
6491 : /* template_members: PA_ENC_SAM_RESPONSE_ENC exp exp */
6492 : /* generate_template_type: PA_ENC_SAM_RESPONSE_ENC_tag_sam_nonce_326 */
6493 : /* template_members: PA_ENC_SAM_RESPONSE_ENC exp exp */
6494 : /* template_members: heim_general_string exp exp */
6495 : /* generate_template_type: heim_general_string_tag_sam_sad_328 */
6496 : /* generate_template_type: PA_ENC_SAM_RESPONSE_ENC_tag_sam_sad_327 */
6497 : /* generate_template_type: PA_ENC_SAM_RESPONSE_ENC_tag__325 */
6498 : const struct asn1_template asn1_PA_ENC_SAM_RESPONSE_ENC_tag__325[] = {
6499 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct PA_ENC_SAM_RESPONSE_ENC), ((void *)(uintptr_t)6) },
6500 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_ENC_SAM_RESPONSE_ENC, sam_nonce), asn1_HostAddress_tag_addr_type_16 },
6501 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct PA_ENC_SAM_RESPONSE_ENC, sam_sad), asn1_PrincipalName_name_string_0 },
6502 : /* 3 */ { A1_OP_NAME, 0, "PA_ENC_SAM_RESPONSE_ENC" },
6503 : /* 4 */ { A1_OP_NAME, 0, "sam-nonce" },
6504 : /* 5 */ { A1_OP_NAME, 0, "sam-sad" },
6505 : /* 6 */ { A1_OP_NAME, 0, "..." }
6506 : };
6507 : /* generate_template_type: PA_ENC_SAM_RESPONSE_ENC */
6508 : const struct asn1_template asn1_PA_ENC_SAM_RESPONSE_ENC[] = {
6509 : /* 0 */ { 0, sizeof(PA_ENC_SAM_RESPONSE_ENC), ((void *)(uintptr_t)1) },
6510 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_ENC_SAM_RESPONSE_ENC_tag__325 }
6511 : };
6512 :
6513 : int ASN1CALL
6514 0 : decode_PA_ENC_SAM_RESPONSE_ENC(const unsigned char *p, size_t len, PA_ENC_SAM_RESPONSE_ENC *data, size_t *size)
6515 : {
6516 0 : memset(data, 0, sizeof(*data));
6517 0 : return _asn1_decode_top(asn1_PA_ENC_SAM_RESPONSE_ENC, 0|0, p, len, data, size);
6518 : }
6519 :
6520 :
6521 : int ASN1CALL
6522 0 : encode_PA_ENC_SAM_RESPONSE_ENC(unsigned char *p, size_t len, const PA_ENC_SAM_RESPONSE_ENC *data, size_t *size)
6523 : {
6524 0 : return _asn1_encode(asn1_PA_ENC_SAM_RESPONSE_ENC, p, len, data, size);
6525 : }
6526 :
6527 :
6528 : size_t ASN1CALL
6529 0 : length_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *data)
6530 : {
6531 0 : return _asn1_length(asn1_PA_ENC_SAM_RESPONSE_ENC, data);
6532 : }
6533 :
6534 :
6535 : void ASN1CALL
6536 0 : free_PA_ENC_SAM_RESPONSE_ENC(PA_ENC_SAM_RESPONSE_ENC *data)
6537 : {
6538 0 : _asn1_free_top(asn1_PA_ENC_SAM_RESPONSE_ENC, data);
6539 0 : }
6540 :
6541 :
6542 : int ASN1CALL
6543 0 : copy_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *from, PA_ENC_SAM_RESPONSE_ENC *to)
6544 : {
6545 0 : return _asn1_copy_top(asn1_PA_ENC_SAM_RESPONSE_ENC, from, to);
6546 : }
6547 :
6548 :
6549 : char * ASN1CALL
6550 0 : print_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *data, int flags)
6551 : {
6552 0 : return _asn1_print_top(asn1_PA_ENC_SAM_RESPONSE_ENC, flags, data);
6553 : }
6554 :
6555 : /* template_members: PA_S4U2Self exp exp */
6556 : /* tsequence: members isstruct: 1 */
6557 : /* template_members: PA_S4U2Self exp exp */
6558 : /* generate_template_type: PA_S4U2Self_tag_name_330 */
6559 : /* template_members: PA_S4U2Self exp exp */
6560 : /* generate_template_type: PA_S4U2Self_tag_realm_331 */
6561 : /* template_members: PA_S4U2Self exp exp */
6562 : /* generate_template_type: PA_S4U2Self_tag_cksum_332 */
6563 : /* template_members: PA_S4U2Self exp exp */
6564 : /* template_members: heim_general_string exp exp */
6565 : /* generate_template_type: heim_general_string_tag_auth_334 */
6566 : /* generate_template_type: PA_S4U2Self_tag_auth_333 */
6567 : /* generate_template_type: PA_S4U2Self_tag__329 */
6568 : const struct asn1_template asn1_PA_S4U2Self_tag__329[] = {
6569 : /* 0 */ { 0, sizeof(struct PA_S4U2Self), ((void *)(uintptr_t)9) },
6570 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_S4U2Self, name), asn1_Ticket_tag_sname_51 },
6571 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct PA_S4U2Self, realm), asn1_Ticket_tag_realm_50 },
6572 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct PA_S4U2Self, cksum), asn1_Authenticator_tag_cksum_112 },
6573 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct PA_S4U2Self, auth), asn1_PrincipalName_name_string_0 },
6574 : /* 5 */ { A1_OP_NAME, 0, "PA_S4U2Self" },
6575 : /* 6 */ { A1_OP_NAME, 0, "name" },
6576 : /* 7 */ { A1_OP_NAME, 0, "realm" },
6577 : /* 8 */ { A1_OP_NAME, 0, "cksum" },
6578 : /* 9 */ { A1_OP_NAME, 0, "auth" }
6579 : };
6580 : /* generate_template_type: PA_S4U2Self */
6581 : const struct asn1_template asn1_PA_S4U2Self[] = {
6582 : /* 0 */ { 0, sizeof(PA_S4U2Self), ((void *)(uintptr_t)1) },
6583 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_S4U2Self_tag__329 }
6584 : };
6585 :
6586 : int ASN1CALL
6587 642 : decode_PA_S4U2Self(const unsigned char *p, size_t len, PA_S4U2Self *data, size_t *size)
6588 : {
6589 642 : memset(data, 0, sizeof(*data));
6590 642 : return _asn1_decode_top(asn1_PA_S4U2Self, 0|0, p, len, data, size);
6591 : }
6592 :
6593 :
6594 : int ASN1CALL
6595 896 : encode_PA_S4U2Self(unsigned char *p, size_t len, const PA_S4U2Self *data, size_t *size)
6596 : {
6597 896 : return _asn1_encode(asn1_PA_S4U2Self, p, len, data, size);
6598 : }
6599 :
6600 :
6601 : size_t ASN1CALL
6602 896 : length_PA_S4U2Self(const PA_S4U2Self *data)
6603 : {
6604 896 : return _asn1_length(asn1_PA_S4U2Self, data);
6605 : }
6606 :
6607 :
6608 : void ASN1CALL
6609 642 : free_PA_S4U2Self(PA_S4U2Self *data)
6610 : {
6611 642 : _asn1_free_top(asn1_PA_S4U2Self, data);
6612 642 : }
6613 :
6614 :
6615 : int ASN1CALL
6616 0 : copy_PA_S4U2Self(const PA_S4U2Self *from, PA_S4U2Self *to)
6617 : {
6618 0 : return _asn1_copy_top(asn1_PA_S4U2Self, from, to);
6619 : }
6620 :
6621 :
6622 : char * ASN1CALL
6623 0 : print_PA_S4U2Self(const PA_S4U2Self *data, int flags)
6624 : {
6625 0 : return _asn1_print_top(asn1_PA_S4U2Self, flags, data);
6626 : }
6627 :
6628 : /* template_members: S4UUserID exp exp */
6629 : /* tsequence: members isstruct: 1 */
6630 : /* template_members: S4UUserID exp exp */
6631 : /* generate_template_type: S4UUserID_tag_nonce_336 */
6632 : /* template_members: S4UUserID exp exp */
6633 : /* generate_template_type: S4UUserID_tag_cname_337 */
6634 : /* template_members: S4UUserID exp exp */
6635 : /* generate_template_type: S4UUserID_tag_crealm_338 */
6636 : /* template_members: S4UUserID exp exp */
6637 : /* template_members: heim_octet_string exp exp */
6638 : /* generate_template_type: heim_octet_string_tag_subject_certificate_340 */
6639 : /* generate_template_type: S4UUserID_tag_subject_certificate_339 */
6640 : /* template_members: S4UUserID exp exp */
6641 : /* template_members: S4UUserID exp exp */
6642 : /* generate_template_type: S4UUserID_tag_options_342 */
6643 : const struct asn1_template asn1_S4UUserID_tag_options_342[] = {
6644 : /* 0 */ { 0, sizeof(S4UUserID), ((void *)(uintptr_t)1) },
6645 : /* 1 */ { A1_PARSE_T(A1T_HEIM_BIT_STRING), 0, NULL }
6646 : };
6647 : /* generate_template_type: S4UUserID_tag_options_341 */
6648 : const struct asn1_template asn1_S4UUserID_tag_options_341[] = {
6649 : /* 0 */ { 0, sizeof(S4UUserID), ((void *)(uintptr_t)1) },
6650 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_BitString), 0, asn1_S4UUserID_tag_options_342 }
6651 : };
6652 : /* generate_template_type: S4UUserID_tag__335 */
6653 : const struct asn1_template asn1_S4UUserID_tag__335[] = {
6654 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct S4UUserID), ((void *)(uintptr_t)12) },
6655 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct S4UUserID, nonce), asn1_Authenticator_tag_seq_number_116 },
6656 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct S4UUserID, cname), asn1_Ticket_tag_sname_51 },
6657 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct S4UUserID, crealm), asn1_Ticket_tag_realm_50 },
6658 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct S4UUserID, subject_certificate), asn1_HostAddress_tag_address_17 },
6659 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct S4UUserID, options), asn1_S4UUserID_tag_options_341 },
6660 : /* 6 */ { A1_OP_NAME, 0, "S4UUserID" },
6661 : /* 7 */ { A1_OP_NAME, 0, "nonce" },
6662 : /* 8 */ { A1_OP_NAME, 0, "cname" },
6663 : /* 9 */ { A1_OP_NAME, 0, "crealm" },
6664 : /* 10 */ { A1_OP_NAME, 0, "subject-certificate" },
6665 : /* 11 */ { A1_OP_NAME, 0, "options" },
6666 : /* 12 */ { A1_OP_NAME, 0, "..." }
6667 : };
6668 : /* generate_template_type: S4UUserID */
6669 : const struct asn1_template asn1_S4UUserID[] = {
6670 : /* 0 */ { 0, sizeof(S4UUserID), ((void *)(uintptr_t)1) },
6671 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_S4UUserID_tag__335 }
6672 : };
6673 :
6674 : int ASN1CALL
6675 0 : decode_S4UUserID(const unsigned char *p, size_t len, S4UUserID *data, size_t *size)
6676 : {
6677 0 : memset(data, 0, sizeof(*data));
6678 0 : return _asn1_decode_top(asn1_S4UUserID, 0|0, p, len, data, size);
6679 : }
6680 :
6681 :
6682 : int ASN1CALL
6683 0 : encode_S4UUserID(unsigned char *p, size_t len, const S4UUserID *data, size_t *size)
6684 : {
6685 0 : return _asn1_encode(asn1_S4UUserID, p, len, data, size);
6686 : }
6687 :
6688 :
6689 : size_t ASN1CALL
6690 0 : length_S4UUserID(const S4UUserID *data)
6691 : {
6692 0 : return _asn1_length(asn1_S4UUserID, data);
6693 : }
6694 :
6695 :
6696 : void ASN1CALL
6697 0 : free_S4UUserID(S4UUserID *data)
6698 : {
6699 0 : _asn1_free_top(asn1_S4UUserID, data);
6700 0 : }
6701 :
6702 :
6703 : int ASN1CALL
6704 0 : copy_S4UUserID(const S4UUserID *from, S4UUserID *to)
6705 : {
6706 0 : return _asn1_copy_top(asn1_S4UUserID, from, to);
6707 : }
6708 :
6709 :
6710 : char * ASN1CALL
6711 0 : print_S4UUserID(const S4UUserID *data, int flags)
6712 : {
6713 0 : return _asn1_print_top(asn1_S4UUserID, flags, data);
6714 : }
6715 :
6716 : /* template_members: PA_S4U_X509_USER exp exp */
6717 : /* tsequence: members isstruct: 1 */
6718 : /* template_members: PA_S4U_X509_USER exp exp */
6719 : /* generate_template_type: PA_S4U_X509_USER_tag_user_id_344 */
6720 : const struct asn1_template asn1_PA_S4U_X509_USER_tag_user_id_344[] = {
6721 : /* 0 */ { 0, sizeof(S4UUserID), ((void *)(uintptr_t)1) },
6722 : /* 1 */ { A1_OP_TYPE , 0, asn1_S4UUserID }
6723 : };
6724 : /* template_members: PA_S4U_X509_USER exp exp */
6725 : /* generate_template_type: PA_S4U_X509_USER_tag_checksum_345 */
6726 : /* generate_template_type: PA_S4U_X509_USER_tag__343 */
6727 : const struct asn1_template asn1_PA_S4U_X509_USER_tag__343[] = {
6728 : /* 0 */ { 0, sizeof(struct PA_S4U_X509_USER), ((void *)(uintptr_t)5) },
6729 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_S4U_X509_USER, user_id), asn1_PA_S4U_X509_USER_tag_user_id_344 },
6730 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct PA_S4U_X509_USER, checksum), asn1_Authenticator_tag_cksum_112 },
6731 : /* 3 */ { A1_OP_NAME, 0, "PA_S4U_X509_USER" },
6732 : /* 4 */ { A1_OP_NAME, 0, "user-id" },
6733 : /* 5 */ { A1_OP_NAME, 0, "checksum" }
6734 : };
6735 : /* generate_template_type: PA_S4U_X509_USER */
6736 : const struct asn1_template asn1_PA_S4U_X509_USER[] = {
6737 : /* 0 */ { 0, sizeof(PA_S4U_X509_USER), ((void *)(uintptr_t)1) },
6738 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_S4U_X509_USER_tag__343 }
6739 : };
6740 :
6741 : int ASN1CALL
6742 0 : decode_PA_S4U_X509_USER(const unsigned char *p, size_t len, PA_S4U_X509_USER *data, size_t *size)
6743 : {
6744 0 : memset(data, 0, sizeof(*data));
6745 0 : return _asn1_decode_top(asn1_PA_S4U_X509_USER, 0|0, p, len, data, size);
6746 : }
6747 :
6748 :
6749 : int ASN1CALL
6750 0 : encode_PA_S4U_X509_USER(unsigned char *p, size_t len, const PA_S4U_X509_USER *data, size_t *size)
6751 : {
6752 0 : return _asn1_encode(asn1_PA_S4U_X509_USER, p, len, data, size);
6753 : }
6754 :
6755 :
6756 : size_t ASN1CALL
6757 0 : length_PA_S4U_X509_USER(const PA_S4U_X509_USER *data)
6758 : {
6759 0 : return _asn1_length(asn1_PA_S4U_X509_USER, data);
6760 : }
6761 :
6762 :
6763 : void ASN1CALL
6764 0 : free_PA_S4U_X509_USER(PA_S4U_X509_USER *data)
6765 : {
6766 0 : _asn1_free_top(asn1_PA_S4U_X509_USER, data);
6767 0 : }
6768 :
6769 :
6770 : int ASN1CALL
6771 0 : copy_PA_S4U_X509_USER(const PA_S4U_X509_USER *from, PA_S4U_X509_USER *to)
6772 : {
6773 0 : return _asn1_copy_top(asn1_PA_S4U_X509_USER, from, to);
6774 : }
6775 :
6776 :
6777 : char * ASN1CALL
6778 0 : print_PA_S4U_X509_USER(const PA_S4U_X509_USER *data, int flags)
6779 : {
6780 0 : return _asn1_print_top(asn1_PA_S4U_X509_USER, flags, data);
6781 : }
6782 :
6783 : /* template_members: AD_LoginAlias exp exp */
6784 : /* tsequence: members isstruct: 1 */
6785 : /* template_members: AD_LoginAlias exp exp */
6786 : /* generate_template_type: AD_LoginAlias_tag_login_alias_347 */
6787 : /* template_members: AD_LoginAlias exp exp */
6788 : /* generate_template_type: AD_LoginAlias_tag_checksum_348 */
6789 : /* generate_template_type: AD_LoginAlias_tag__346 */
6790 : const struct asn1_template asn1_AD_LoginAlias_tag__346[] = {
6791 : /* 0 */ { 0, sizeof(struct AD_LoginAlias), ((void *)(uintptr_t)5) },
6792 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct AD_LoginAlias, login_alias), asn1_Ticket_tag_sname_51 },
6793 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct AD_LoginAlias, checksum), asn1_Authenticator_tag_cksum_112 },
6794 : /* 3 */ { A1_OP_NAME, 0, "AD_LoginAlias" },
6795 : /* 4 */ { A1_OP_NAME, 0, "login-alias" },
6796 : /* 5 */ { A1_OP_NAME, 0, "checksum" }
6797 : };
6798 : /* generate_template_type: AD_LoginAlias */
6799 : const struct asn1_template asn1_AD_LoginAlias[] = {
6800 : /* 0 */ { 0, sizeof(AD_LoginAlias), ((void *)(uintptr_t)1) },
6801 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_AD_LoginAlias_tag__346 }
6802 : };
6803 :
6804 : int ASN1CALL
6805 0 : decode_AD_LoginAlias(const unsigned char *p, size_t len, AD_LoginAlias *data, size_t *size)
6806 : {
6807 0 : memset(data, 0, sizeof(*data));
6808 0 : return _asn1_decode_top(asn1_AD_LoginAlias, 0|0, p, len, data, size);
6809 : }
6810 :
6811 :
6812 : int ASN1CALL
6813 0 : encode_AD_LoginAlias(unsigned char *p, size_t len, const AD_LoginAlias *data, size_t *size)
6814 : {
6815 0 : return _asn1_encode(asn1_AD_LoginAlias, p, len, data, size);
6816 : }
6817 :
6818 :
6819 : size_t ASN1CALL
6820 0 : length_AD_LoginAlias(const AD_LoginAlias *data)
6821 : {
6822 0 : return _asn1_length(asn1_AD_LoginAlias, data);
6823 : }
6824 :
6825 :
6826 : void ASN1CALL
6827 0 : free_AD_LoginAlias(AD_LoginAlias *data)
6828 : {
6829 0 : _asn1_free_top(asn1_AD_LoginAlias, data);
6830 0 : }
6831 :
6832 :
6833 : int ASN1CALL
6834 0 : copy_AD_LoginAlias(const AD_LoginAlias *from, AD_LoginAlias *to)
6835 : {
6836 0 : return _asn1_copy_top(asn1_AD_LoginAlias, from, to);
6837 : }
6838 :
6839 :
6840 : char * ASN1CALL
6841 0 : print_AD_LoginAlias(const AD_LoginAlias *data, int flags)
6842 : {
6843 0 : return _asn1_print_top(asn1_AD_LoginAlias, flags, data);
6844 : }
6845 :
6846 : /* template_members: PA_SvrReferralData exp exp */
6847 : /* tsequence: members isstruct: 1 */
6848 : /* template_members: PA_SvrReferralData exp exp */
6849 : /* generate_template_type: PA_SvrReferralData_tag_referred_name_350 */
6850 : /* template_members: PA_SvrReferralData exp exp */
6851 : /* generate_template_type: PA_SvrReferralData_tag_referred_realm_351 */
6852 : /* generate_template_type: PA_SvrReferralData_tag__349 */
6853 : const struct asn1_template asn1_PA_SvrReferralData_tag__349[] = {
6854 : /* 0 */ { 0, sizeof(struct PA_SvrReferralData), ((void *)(uintptr_t)5) },
6855 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct PA_SvrReferralData, referred_name), asn1_Ticket_tag_sname_51 },
6856 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct PA_SvrReferralData, referred_realm), asn1_Ticket_tag_realm_50 },
6857 : /* 3 */ { A1_OP_NAME, 0, "PA_SvrReferralData" },
6858 : /* 4 */ { A1_OP_NAME, 0, "referred-name" },
6859 : /* 5 */ { A1_OP_NAME, 0, "referred-realm" }
6860 : };
6861 : /* generate_template_type: PA_SvrReferralData */
6862 : const struct asn1_template asn1_PA_SvrReferralData[] = {
6863 : /* 0 */ { 0, sizeof(PA_SvrReferralData), ((void *)(uintptr_t)1) },
6864 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_SvrReferralData_tag__349 }
6865 : };
6866 :
6867 : int ASN1CALL
6868 0 : decode_PA_SvrReferralData(const unsigned char *p, size_t len, PA_SvrReferralData *data, size_t *size)
6869 : {
6870 0 : memset(data, 0, sizeof(*data));
6871 0 : return _asn1_decode_top(asn1_PA_SvrReferralData, 0|0, p, len, data, size);
6872 : }
6873 :
6874 :
6875 : int ASN1CALL
6876 0 : encode_PA_SvrReferralData(unsigned char *p, size_t len, const PA_SvrReferralData *data, size_t *size)
6877 : {
6878 0 : return _asn1_encode(asn1_PA_SvrReferralData, p, len, data, size);
6879 : }
6880 :
6881 :
6882 : size_t ASN1CALL
6883 0 : length_PA_SvrReferralData(const PA_SvrReferralData *data)
6884 : {
6885 0 : return _asn1_length(asn1_PA_SvrReferralData, data);
6886 : }
6887 :
6888 :
6889 : void ASN1CALL
6890 0 : free_PA_SvrReferralData(PA_SvrReferralData *data)
6891 : {
6892 0 : _asn1_free_top(asn1_PA_SvrReferralData, data);
6893 0 : }
6894 :
6895 :
6896 : int ASN1CALL
6897 0 : copy_PA_SvrReferralData(const PA_SvrReferralData *from, PA_SvrReferralData *to)
6898 : {
6899 0 : return _asn1_copy_top(asn1_PA_SvrReferralData, from, to);
6900 : }
6901 :
6902 :
6903 : char * ASN1CALL
6904 0 : print_PA_SvrReferralData(const PA_SvrReferralData *data, int flags)
6905 : {
6906 0 : return _asn1_print_top(asn1_PA_SvrReferralData, flags, data);
6907 : }
6908 :
6909 : /* generate_template_type: PA_SERVER_REFERRAL_DATA */
6910 : const struct asn1_template asn1_PA_SERVER_REFERRAL_DATA[] = {
6911 : /* 0 */ { 0, sizeof(PA_SERVER_REFERRAL_DATA), ((void *)(uintptr_t)1) },
6912 : /* 1 */ { A1_OP_TYPE , 0, asn1_EncryptedData }
6913 : };
6914 :
6915 : int ASN1CALL
6916 0 : decode_PA_SERVER_REFERRAL_DATA(const unsigned char *p, size_t len, PA_SERVER_REFERRAL_DATA *data, size_t *size)
6917 : {
6918 0 : memset(data, 0, sizeof(*data));
6919 0 : return _asn1_decode_top(asn1_PA_SERVER_REFERRAL_DATA, 0|0, p, len, data, size);
6920 : }
6921 :
6922 :
6923 : int ASN1CALL
6924 0 : encode_PA_SERVER_REFERRAL_DATA(unsigned char *p, size_t len, const PA_SERVER_REFERRAL_DATA *data, size_t *size)
6925 : {
6926 0 : return _asn1_encode(asn1_PA_SERVER_REFERRAL_DATA, p, len, data, size);
6927 : }
6928 :
6929 :
6930 : size_t ASN1CALL
6931 0 : length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *data)
6932 : {
6933 0 : return _asn1_length(asn1_PA_SERVER_REFERRAL_DATA, data);
6934 : }
6935 :
6936 :
6937 : void ASN1CALL
6938 0 : free_PA_SERVER_REFERRAL_DATA(PA_SERVER_REFERRAL_DATA *data)
6939 : {
6940 0 : _asn1_free_top(asn1_PA_SERVER_REFERRAL_DATA, data);
6941 0 : }
6942 :
6943 :
6944 : int ASN1CALL
6945 0 : copy_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *from, PA_SERVER_REFERRAL_DATA *to)
6946 : {
6947 0 : return _asn1_copy_top(asn1_PA_SERVER_REFERRAL_DATA, from, to);
6948 : }
6949 :
6950 :
6951 : char * ASN1CALL
6952 0 : print_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *data, int flags)
6953 : {
6954 0 : return _asn1_print_top(asn1_PA_SERVER_REFERRAL_DATA, flags, data);
6955 : }
6956 :
6957 : /* template_members: PA_ServerReferralData exp exp */
6958 : /* tsequence: members isstruct: 1 */
6959 : /* template_members: PA_ServerReferralData exp exp */
6960 : /* generate_template_type: PA_ServerReferralData_tag_referred_realm_353 */
6961 : /* template_members: PA_ServerReferralData exp exp */
6962 : /* generate_template_type: PA_ServerReferralData_tag_true_principal_name_354 */
6963 : /* template_members: PA_ServerReferralData exp exp */
6964 : /* generate_template_type: PA_ServerReferralData_tag_requested_principal_name_355 */
6965 : /* template_members: PA_ServerReferralData exp exp */
6966 : /* generate_template_type: PA_ServerReferralData_tag_referral_valid_until_356 */
6967 : /* generate_template_type: PA_ServerReferralData_tag__352 */
6968 : const struct asn1_template asn1_PA_ServerReferralData_tag__352[] = {
6969 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct PA_ServerReferralData), ((void *)(uintptr_t)10) },
6970 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0)|A1_FLAG_OPTIONAL, offsetof(struct PA_ServerReferralData, referred_realm), asn1_Ticket_tag_realm_50 },
6971 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct PA_ServerReferralData, true_principal_name), asn1_Ticket_tag_sname_51 },
6972 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct PA_ServerReferralData, requested_principal_name), asn1_Ticket_tag_sname_51 },
6973 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct PA_ServerReferralData, referral_valid_until), asn1_LastReq_val_tag_lr_value_33 },
6974 : /* 5 */ { A1_OP_NAME, 0, "PA_ServerReferralData" },
6975 : /* 6 */ { A1_OP_NAME, 0, "referred-realm" },
6976 : /* 7 */ { A1_OP_NAME, 0, "true-principal-name" },
6977 : /* 8 */ { A1_OP_NAME, 0, "requested-principal-name" },
6978 : /* 9 */ { A1_OP_NAME, 0, "referral-valid-until" },
6979 : /* 10 */ { A1_OP_NAME, 0, "..." }
6980 : };
6981 : /* generate_template_type: PA_ServerReferralData */
6982 : const struct asn1_template asn1_PA_ServerReferralData[] = {
6983 : /* 0 */ { 0, sizeof(PA_ServerReferralData), ((void *)(uintptr_t)1) },
6984 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_PA_ServerReferralData_tag__352 }
6985 : };
6986 :
6987 : int ASN1CALL
6988 576 : decode_PA_ServerReferralData(const unsigned char *p, size_t len, PA_ServerReferralData *data, size_t *size)
6989 : {
6990 576 : memset(data, 0, sizeof(*data));
6991 576 : return _asn1_decode_top(asn1_PA_ServerReferralData, 0|0, p, len, data, size);
6992 : }
6993 :
6994 :
6995 : int ASN1CALL
6996 576 : encode_PA_ServerReferralData(unsigned char *p, size_t len, const PA_ServerReferralData *data, size_t *size)
6997 : {
6998 576 : return _asn1_encode(asn1_PA_ServerReferralData, p, len, data, size);
6999 : }
7000 :
7001 :
7002 : size_t ASN1CALL
7003 576 : length_PA_ServerReferralData(const PA_ServerReferralData *data)
7004 : {
7005 576 : return _asn1_length(asn1_PA_ServerReferralData, data);
7006 : }
7007 :
7008 :
7009 : void ASN1CALL
7010 1152 : free_PA_ServerReferralData(PA_ServerReferralData *data)
7011 : {
7012 1152 : _asn1_free_top(asn1_PA_ServerReferralData, data);
7013 1152 : }
7014 :
7015 :
7016 : int ASN1CALL
7017 0 : copy_PA_ServerReferralData(const PA_ServerReferralData *from, PA_ServerReferralData *to)
7018 : {
7019 0 : return _asn1_copy_top(asn1_PA_ServerReferralData, from, to);
7020 : }
7021 :
7022 :
7023 : char * ASN1CALL
7024 0 : print_PA_ServerReferralData(const PA_ServerReferralData *data, int flags)
7025 : {
7026 0 : return _asn1_print_top(asn1_PA_ServerReferralData, flags, data);
7027 : }
7028 :
7029 : /* template_members: FastOptions exp exp */
7030 : static const struct asn1_template asn1_FastOptions_bmember__5[] = {
7031 : /* 0 */ { 0|A1_HBF_RFC1510, sizeof(FastOptions), ((void *)(uintptr_t)17) },
7032 : /* 1 */ { 0, 0, "reserved" },
7033 : /* 2 */ { 0, 1, "hide_client_names" },
7034 : /* 3 */ { 0, 2, "critical2" },
7035 : /* 4 */ { 0, 3, "critical3" },
7036 : /* 5 */ { 0, 4, "critical4" },
7037 : /* 6 */ { 0, 5, "critical5" },
7038 : /* 7 */ { 0, 6, "critical6" },
7039 : /* 8 */ { 0, 7, "critical7" },
7040 : /* 9 */ { 0, 8, "critical8" },
7041 : /* 10 */ { 0, 9, "critical9" },
7042 : /* 11 */ { 0, 10, "critical10" },
7043 : /* 12 */ { 0, 11, "critical11" },
7044 : /* 13 */ { 0, 12, "critical12" },
7045 : /* 14 */ { 0, 13, "critical13" },
7046 : /* 15 */ { 0, 14, "critical14" },
7047 : /* 16 */ { 0, 15, "critical15" },
7048 : /* 17 */ { 0, 16, "kdc_follow_referrals" }
7049 : };
7050 : /* generate_template_type: FastOptions_tag__357 */
7051 : const struct asn1_template asn1_FastOptions_tag__357[] = {
7052 : /* 0 */ { 0, sizeof(FastOptions), ((void *)(uintptr_t)1) },
7053 : /* 1 */ { A1_OP_BMEMBER, 0, asn1_FastOptions_bmember__5 }
7054 : };
7055 : /* generate_template_type: FastOptions */
7056 : const struct asn1_template asn1_FastOptions[] = {
7057 : /* 0 */ { 0, sizeof(FastOptions), ((void *)(uintptr_t)1) },
7058 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_BitString), 0, asn1_FastOptions_tag__357 }
7059 : };
7060 :
7061 : int ASN1CALL
7062 0 : decode_FastOptions(const unsigned char *p, size_t len, FastOptions *data, size_t *size)
7063 : {
7064 0 : memset(data, 0, sizeof(*data));
7065 0 : return _asn1_decode_top(asn1_FastOptions, 0|0, p, len, data, size);
7066 : }
7067 :
7068 :
7069 : int ASN1CALL
7070 0 : encode_FastOptions(unsigned char *p, size_t len, const FastOptions *data, size_t *size)
7071 : {
7072 0 : return _asn1_encode(asn1_FastOptions, p, len, data, size);
7073 : }
7074 :
7075 :
7076 : size_t ASN1CALL
7077 0 : length_FastOptions(const FastOptions *data)
7078 : {
7079 0 : return _asn1_length(asn1_FastOptions, data);
7080 : }
7081 :
7082 :
7083 : void ASN1CALL
7084 0 : free_FastOptions(FastOptions *data)
7085 : {
7086 0 : _asn1_free_top(asn1_FastOptions, data);
7087 0 : }
7088 :
7089 :
7090 : int ASN1CALL
7091 0 : copy_FastOptions(const FastOptions *from, FastOptions *to)
7092 : {
7093 0 : return _asn1_copy_top(asn1_FastOptions, from, to);
7094 : }
7095 :
7096 :
7097 : char * ASN1CALL
7098 0 : print_FastOptions(const FastOptions *data, int flags)
7099 : {
7100 0 : return _asn1_print_top(asn1_FastOptions, flags, data);
7101 : }
7102 :
7103 32155 : uint64_t FastOptions2int(FastOptions f)
7104 : {
7105 32155 : uint64_t r = 0;
7106 32155 : if(f.reserved) r |= (1ULL << 0);
7107 32155 : if(f.hide_client_names) r |= (1ULL << 1);
7108 32155 : if(f.critical2) r |= (1ULL << 2);
7109 32155 : if(f.critical3) r |= (1ULL << 3);
7110 32155 : if(f.critical4) r |= (1ULL << 4);
7111 32155 : if(f.critical5) r |= (1ULL << 5);
7112 32155 : if(f.critical6) r |= (1ULL << 6);
7113 32155 : if(f.critical7) r |= (1ULL << 7);
7114 32155 : if(f.critical8) r |= (1ULL << 8);
7115 32155 : if(f.critical9) r |= (1ULL << 9);
7116 32155 : if(f.critical10) r |= (1ULL << 10);
7117 32155 : if(f.critical11) r |= (1ULL << 11);
7118 32155 : if(f.critical12) r |= (1ULL << 12);
7119 32155 : if(f.critical13) r |= (1ULL << 13);
7120 32155 : if(f.critical14) r |= (1ULL << 14);
7121 32155 : if(f.critical15) r |= (1ULL << 15);
7122 32155 : if(f.kdc_follow_referrals) r |= (1ULL << 16);
7123 32155 : return r;
7124 : }
7125 :
7126 0 : FastOptions int2FastOptions(uint64_t n)
7127 : {
7128 : FastOptions flags;
7129 :
7130 0 : memset(&flags, 0, sizeof(flags));
7131 :
7132 0 : flags.reserved = (n >> 0) & 1;
7133 0 : flags.hide_client_names = (n >> 1) & 1;
7134 0 : flags.critical2 = (n >> 2) & 1;
7135 0 : flags.critical3 = (n >> 3) & 1;
7136 0 : flags.critical4 = (n >> 4) & 1;
7137 0 : flags.critical5 = (n >> 5) & 1;
7138 0 : flags.critical6 = (n >> 6) & 1;
7139 0 : flags.critical7 = (n >> 7) & 1;
7140 0 : flags.critical8 = (n >> 8) & 1;
7141 0 : flags.critical9 = (n >> 9) & 1;
7142 0 : flags.critical10 = (n >> 10) & 1;
7143 0 : flags.critical11 = (n >> 11) & 1;
7144 0 : flags.critical12 = (n >> 12) & 1;
7145 0 : flags.critical13 = (n >> 13) & 1;
7146 0 : flags.critical14 = (n >> 14) & 1;
7147 0 : flags.critical15 = (n >> 15) & 1;
7148 0 : flags.kdc_follow_referrals = (n >> 16) & 1;
7149 0 : return flags;
7150 : }
7151 :
7152 : static struct units FastOptions_units[] = {
7153 : {"kdc-follow-referrals", 1ULL << 16},
7154 : {"critical15", 1ULL << 15},
7155 : {"critical14", 1ULL << 14},
7156 : {"critical13", 1ULL << 13},
7157 : {"critical12", 1ULL << 12},
7158 : {"critical11", 1ULL << 11},
7159 : {"critical10", 1ULL << 10},
7160 : {"critical9", 1ULL << 9},
7161 : {"critical8", 1ULL << 8},
7162 : {"critical7", 1ULL << 7},
7163 : {"critical6", 1ULL << 6},
7164 : {"critical5", 1ULL << 5},
7165 : {"critical4", 1ULL << 4},
7166 : {"critical3", 1ULL << 3},
7167 : {"critical2", 1ULL << 2},
7168 : {"hide-client-names", 1ULL << 1},
7169 : {"reserved", 1ULL << 0},
7170 : {NULL, 0}
7171 : };
7172 :
7173 0 : const struct units * asn1_FastOptions_units(void){
7174 0 : return FastOptions_units;
7175 : }
7176 :
7177 : /* template_members: KrbFastReq exp exp */
7178 : /* tsequence: members isstruct: 1 */
7179 : /* template_members: KrbFastReq exp exp */
7180 : /* generate_template_type: KrbFastReq_tag_fast_options_359 */
7181 : const struct asn1_template asn1_KrbFastReq_tag_fast_options_359[] = {
7182 : /* 0 */ { 0, sizeof(FastOptions), ((void *)(uintptr_t)1) },
7183 : /* 1 */ { A1_OP_TYPE , 0, asn1_FastOptions }
7184 : };
7185 : /* template_members: KrbFastReq exp exp */
7186 : /* generate_template_type: KrbFastReq_tag_padata_360 */
7187 : /* template_members: KrbFastReq exp exp */
7188 : /* generate_template_type: KrbFastReq_tag_req_body_361 */
7189 : /* generate_template_type: KrbFastReq_tag__358 */
7190 : const struct asn1_template asn1_KrbFastReq_tag__358[] = {
7191 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct KrbFastReq), ((void *)(uintptr_t)8) },
7192 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KrbFastReq, fast_options), asn1_KrbFastReq_tag_fast_options_359 },
7193 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KrbFastReq, padata), asn1_EncKDCRepPart_tag_encrypted_pa_data_83 },
7194 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KrbFastReq, req_body), asn1_KDC_REQ_tag_req_body_159 },
7195 : /* 4 */ { A1_OP_NAME, 0, "KrbFastReq" },
7196 : /* 5 */ { A1_OP_NAME, 0, "fast-options" },
7197 : /* 6 */ { A1_OP_NAME, 0, "padata" },
7198 : /* 7 */ { A1_OP_NAME, 0, "req-body" },
7199 : /* 8 */ { A1_OP_NAME, 0, "..." }
7200 : };
7201 : /* generate_template_type: KrbFastReq */
7202 : const struct asn1_template asn1_KrbFastReq[] = {
7203 : /* 0 */ { 0, sizeof(KrbFastReq), ((void *)(uintptr_t)1) },
7204 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KrbFastReq_tag__358 }
7205 : };
7206 :
7207 : int ASN1CALL
7208 32155 : decode_KrbFastReq(const unsigned char *p, size_t len, KrbFastReq *data, size_t *size)
7209 : {
7210 32155 : memset(data, 0, sizeof(*data));
7211 32155 : return _asn1_decode_top(asn1_KrbFastReq, 0|0, p, len, data, size);
7212 : }
7213 :
7214 :
7215 : int ASN1CALL
7216 35923 : encode_KrbFastReq(unsigned char *p, size_t len, const KrbFastReq *data, size_t *size)
7217 : {
7218 35923 : return _asn1_encode(asn1_KrbFastReq, p, len, data, size);
7219 : }
7220 :
7221 :
7222 : size_t ASN1CALL
7223 35923 : length_KrbFastReq(const KrbFastReq *data)
7224 : {
7225 35923 : return _asn1_length(asn1_KrbFastReq, data);
7226 : }
7227 :
7228 :
7229 : void ASN1CALL
7230 68078 : free_KrbFastReq(KrbFastReq *data)
7231 : {
7232 68078 : _asn1_free_top(asn1_KrbFastReq, data);
7233 68078 : }
7234 :
7235 :
7236 : int ASN1CALL
7237 0 : copy_KrbFastReq(const KrbFastReq *from, KrbFastReq *to)
7238 : {
7239 0 : return _asn1_copy_top(asn1_KrbFastReq, from, to);
7240 : }
7241 :
7242 :
7243 : char * ASN1CALL
7244 0 : print_KrbFastReq(const KrbFastReq *data, int flags)
7245 : {
7246 0 : return _asn1_print_top(asn1_KrbFastReq, flags, data);
7247 : }
7248 :
7249 : /* template_members: KrbFastArmor exp exp */
7250 : /* tsequence: members isstruct: 1 */
7251 : /* template_members: KrbFastArmor exp exp */
7252 : /* generate_template_type: KrbFastArmor_tag_armor_type_363 */
7253 : /* template_members: KrbFastArmor exp exp */
7254 : /* template_members: heim_octet_string exp exp */
7255 : /* generate_template_type: heim_octet_string_tag_armor_value_365 */
7256 : /* generate_template_type: KrbFastArmor_tag_armor_value_364 */
7257 : /* generate_template_type: KrbFastArmor_tag__362 */
7258 : const struct asn1_template asn1_KrbFastArmor_tag__362[] = {
7259 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct KrbFastArmor), ((void *)(uintptr_t)6) },
7260 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KrbFastArmor, armor_type), asn1_HostAddress_tag_addr_type_16 },
7261 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KrbFastArmor, armor_value), asn1_HostAddress_tag_address_17 },
7262 : /* 3 */ { A1_OP_NAME, 0, "KrbFastArmor" },
7263 : /* 4 */ { A1_OP_NAME, 0, "armor-type" },
7264 : /* 5 */ { A1_OP_NAME, 0, "armor-value" },
7265 : /* 6 */ { A1_OP_NAME, 0, "..." }
7266 : };
7267 : /* generate_template_type: KrbFastArmor */
7268 : const struct asn1_template asn1_KrbFastArmor[] = {
7269 : /* 0 */ { 0, sizeof(KrbFastArmor), ((void *)(uintptr_t)1) },
7270 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KrbFastArmor_tag__362 }
7271 : };
7272 :
7273 : int ASN1CALL
7274 0 : decode_KrbFastArmor(const unsigned char *p, size_t len, KrbFastArmor *data, size_t *size)
7275 : {
7276 0 : memset(data, 0, sizeof(*data));
7277 0 : return _asn1_decode_top(asn1_KrbFastArmor, 0|0, p, len, data, size);
7278 : }
7279 :
7280 :
7281 : int ASN1CALL
7282 0 : encode_KrbFastArmor(unsigned char *p, size_t len, const KrbFastArmor *data, size_t *size)
7283 : {
7284 0 : return _asn1_encode(asn1_KrbFastArmor, p, len, data, size);
7285 : }
7286 :
7287 :
7288 : size_t ASN1CALL
7289 0 : length_KrbFastArmor(const KrbFastArmor *data)
7290 : {
7291 0 : return _asn1_length(asn1_KrbFastArmor, data);
7292 : }
7293 :
7294 :
7295 : void ASN1CALL
7296 0 : free_KrbFastArmor(KrbFastArmor *data)
7297 : {
7298 0 : _asn1_free_top(asn1_KrbFastArmor, data);
7299 0 : }
7300 :
7301 :
7302 : int ASN1CALL
7303 0 : copy_KrbFastArmor(const KrbFastArmor *from, KrbFastArmor *to)
7304 : {
7305 0 : return _asn1_copy_top(asn1_KrbFastArmor, from, to);
7306 : }
7307 :
7308 :
7309 : char * ASN1CALL
7310 0 : print_KrbFastArmor(const KrbFastArmor *data, int flags)
7311 : {
7312 0 : return _asn1_print_top(asn1_KrbFastArmor, flags, data);
7313 : }
7314 :
7315 : /* template_members: KrbFastArmoredReq exp exp */
7316 : /* tsequence: members isstruct: 1 */
7317 : /* template_members: KrbFastArmoredReq exp exp */
7318 : /* generate_template_type: KrbFastArmoredReq_tag_armor_367 */
7319 : const struct asn1_template asn1_KrbFastArmoredReq_tag_armor_367[] = {
7320 : /* 0 */ { 0, sizeof(KrbFastArmor), ((void *)(uintptr_t)1) },
7321 : /* 1 */ { A1_OP_TYPE , 0, asn1_KrbFastArmor }
7322 : };
7323 : /* template_members: KrbFastArmoredReq exp exp */
7324 : /* generate_template_type: KrbFastArmoredReq_tag_req_checksum_368 */
7325 : /* template_members: KrbFastArmoredReq exp exp */
7326 : /* generate_template_type: KrbFastArmoredReq_tag_enc_fast_req_369 */
7327 : /* generate_template_type: KrbFastArmoredReq_tag__366 */
7328 : const struct asn1_template asn1_KrbFastArmoredReq_tag__366[] = {
7329 : /* 0 */ { 0, sizeof(struct KrbFastArmoredReq), ((void *)(uintptr_t)7) },
7330 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0)|A1_FLAG_OPTIONAL, offsetof(struct KrbFastArmoredReq, armor), asn1_KrbFastArmoredReq_tag_armor_367 },
7331 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KrbFastArmoredReq, req_checksum), asn1_Authenticator_tag_cksum_112 },
7332 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KrbFastArmoredReq, enc_fast_req), asn1_Ticket_tag_enc_part_52 },
7333 : /* 4 */ { A1_OP_NAME, 0, "KrbFastArmoredReq" },
7334 : /* 5 */ { A1_OP_NAME, 0, "armor" },
7335 : /* 6 */ { A1_OP_NAME, 0, "req-checksum" },
7336 : /* 7 */ { A1_OP_NAME, 0, "enc-fast-req" }
7337 : };
7338 : /* generate_template_type: KrbFastArmoredReq */
7339 : const struct asn1_template asn1_KrbFastArmoredReq[] = {
7340 : /* 0 */ { 0, sizeof(KrbFastArmoredReq), ((void *)(uintptr_t)1) },
7341 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KrbFastArmoredReq_tag__366 }
7342 : };
7343 :
7344 : int ASN1CALL
7345 0 : decode_KrbFastArmoredReq(const unsigned char *p, size_t len, KrbFastArmoredReq *data, size_t *size)
7346 : {
7347 0 : memset(data, 0, sizeof(*data));
7348 0 : return _asn1_decode_top(asn1_KrbFastArmoredReq, 0|0, p, len, data, size);
7349 : }
7350 :
7351 :
7352 : int ASN1CALL
7353 0 : encode_KrbFastArmoredReq(unsigned char *p, size_t len, const KrbFastArmoredReq *data, size_t *size)
7354 : {
7355 0 : return _asn1_encode(asn1_KrbFastArmoredReq, p, len, data, size);
7356 : }
7357 :
7358 :
7359 : size_t ASN1CALL
7360 0 : length_KrbFastArmoredReq(const KrbFastArmoredReq *data)
7361 : {
7362 0 : return _asn1_length(asn1_KrbFastArmoredReq, data);
7363 : }
7364 :
7365 :
7366 : void ASN1CALL
7367 0 : free_KrbFastArmoredReq(KrbFastArmoredReq *data)
7368 : {
7369 0 : _asn1_free_top(asn1_KrbFastArmoredReq, data);
7370 0 : }
7371 :
7372 :
7373 : int ASN1CALL
7374 0 : copy_KrbFastArmoredReq(const KrbFastArmoredReq *from, KrbFastArmoredReq *to)
7375 : {
7376 0 : return _asn1_copy_top(asn1_KrbFastArmoredReq, from, to);
7377 : }
7378 :
7379 :
7380 : char * ASN1CALL
7381 0 : print_KrbFastArmoredReq(const KrbFastArmoredReq *data, int flags)
7382 : {
7383 0 : return _asn1_print_top(asn1_KrbFastArmoredReq, flags, data);
7384 : }
7385 :
7386 : /* template_members: KrbFastArmoredReq exp exp */
7387 : /* generate_template_type: KrbFastArmoredReq_tag__370 */
7388 : const struct asn1_template asn1_KrbFastArmoredReq_tag__370[] = {
7389 : /* 0 */ { 0, sizeof(KrbFastArmoredReq), ((void *)(uintptr_t)1) },
7390 : /* 1 */ { A1_OP_TYPE , 0, asn1_KrbFastArmoredReq }
7391 : };
7392 : /* generate_template_type: PA_FX_FAST_REQUEST_choice_armored_data */
7393 : const struct asn1_template asn1_PA_FX_FAST_REQUEST_choice_armored_data[] = {
7394 : /* 0 */ { 0, sizeof(KrbFastArmoredReq), ((void *)(uintptr_t)1) },
7395 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), 0, asn1_KrbFastArmoredReq_tag__370 }
7396 : };
7397 : static const struct asn1_template asn1_choice_PA_FX_FAST_REQUEST_1[] = {
7398 : /* 0 */ { offsetof(PA_FX_FAST_REQUEST, u.asn1_ellipsis), offsetof(PA_FX_FAST_REQUEST, element), ((void *)(uintptr_t)3) },
7399 : /* 1 */ { choice_PA_FX_FAST_REQUEST_armored_data, offsetof(PA_FX_FAST_REQUEST, u.armored_data), asn1_PA_FX_FAST_REQUEST_choice_armored_data },
7400 : /* 2 */ { 0, 0, "armored-data" },
7401 : /* 3 */ { 0, 0, "..." }
7402 : };
7403 : /* generate_template_type: PA_FX_FAST_REQUEST */
7404 : const struct asn1_template asn1_PA_FX_FAST_REQUEST[] = {
7405 : /* 0 */ { 0, sizeof(PA_FX_FAST_REQUEST), ((void *)(uintptr_t)1) },
7406 : /* 1 */ { A1_OP_CHOICE, 0, asn1_choice_PA_FX_FAST_REQUEST_1 }
7407 : };
7408 :
7409 : int ASN1CALL
7410 32155 : decode_PA_FX_FAST_REQUEST(const unsigned char *p, size_t len, PA_FX_FAST_REQUEST *data, size_t *size)
7411 : {
7412 32155 : memset(data, 0, sizeof(*data));
7413 32155 : return _asn1_decode_top(asn1_PA_FX_FAST_REQUEST, 0|0, p, len, data, size);
7414 : }
7415 :
7416 :
7417 : int ASN1CALL
7418 35923 : encode_PA_FX_FAST_REQUEST(unsigned char *p, size_t len, const PA_FX_FAST_REQUEST *data, size_t *size)
7419 : {
7420 35923 : return _asn1_encode(asn1_PA_FX_FAST_REQUEST, p, len, data, size);
7421 : }
7422 :
7423 :
7424 : size_t ASN1CALL
7425 35923 : length_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *data)
7426 : {
7427 35923 : return _asn1_length(asn1_PA_FX_FAST_REQUEST, data);
7428 : }
7429 :
7430 :
7431 : void ASN1CALL
7432 68078 : free_PA_FX_FAST_REQUEST(PA_FX_FAST_REQUEST *data)
7433 : {
7434 68078 : _asn1_free_top(asn1_PA_FX_FAST_REQUEST, data);
7435 68078 : }
7436 :
7437 :
7438 : int ASN1CALL
7439 0 : copy_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *from, PA_FX_FAST_REQUEST *to)
7440 : {
7441 0 : return _asn1_copy_top(asn1_PA_FX_FAST_REQUEST, from, to);
7442 : }
7443 :
7444 :
7445 : char * ASN1CALL
7446 0 : print_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *data, int flags)
7447 : {
7448 0 : return _asn1_print_top(asn1_PA_FX_FAST_REQUEST, flags, data);
7449 : }
7450 :
7451 : /* template_members: KrbFastFinished exp exp */
7452 : /* tsequence: members isstruct: 1 */
7453 : /* template_members: KrbFastFinished exp exp */
7454 : /* generate_template_type: KrbFastFinished_tag_timestamp_372 */
7455 : /* template_members: KrbFastFinished exp exp */
7456 : /* generate_template_type: KrbFastFinished_tag_usec_373 */
7457 : /* template_members: KrbFastFinished exp exp */
7458 : /* generate_template_type: KrbFastFinished_tag_crealm_374 */
7459 : /* template_members: KrbFastFinished exp exp */
7460 : /* generate_template_type: KrbFastFinished_tag_cname_375 */
7461 : /* template_members: KrbFastFinished exp exp */
7462 : /* generate_template_type: KrbFastFinished_tag_ticket_checksum_376 */
7463 : /* generate_template_type: KrbFastFinished_tag__371 */
7464 : const struct asn1_template asn1_KrbFastFinished_tag__371[] = {
7465 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct KrbFastFinished), ((void *)(uintptr_t)12) },
7466 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KrbFastFinished, timestamp), asn1_LastReq_val_tag_lr_value_33 },
7467 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KrbFastFinished, usec), asn1_HostAddress_tag_addr_type_16 },
7468 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KrbFastFinished, crealm), asn1_Ticket_tag_realm_50 },
7469 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KrbFastFinished, cname), asn1_Ticket_tag_sname_51 },
7470 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct KrbFastFinished, ticket_checksum), asn1_Authenticator_tag_cksum_112 },
7471 : /* 6 */ { A1_OP_NAME, 0, "KrbFastFinished" },
7472 : /* 7 */ { A1_OP_NAME, 0, "timestamp" },
7473 : /* 8 */ { A1_OP_NAME, 0, "usec" },
7474 : /* 9 */ { A1_OP_NAME, 0, "crealm" },
7475 : /* 10 */ { A1_OP_NAME, 0, "cname" },
7476 : /* 11 */ { A1_OP_NAME, 0, "ticket-checksum" },
7477 : /* 12 */ { A1_OP_NAME, 0, "..." }
7478 : };
7479 : /* generate_template_type: KrbFastFinished */
7480 : const struct asn1_template asn1_KrbFastFinished[] = {
7481 : /* 0 */ { 0, sizeof(KrbFastFinished), ((void *)(uintptr_t)1) },
7482 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KrbFastFinished_tag__371 }
7483 : };
7484 :
7485 : int ASN1CALL
7486 0 : decode_KrbFastFinished(const unsigned char *p, size_t len, KrbFastFinished *data, size_t *size)
7487 : {
7488 0 : memset(data, 0, sizeof(*data));
7489 0 : return _asn1_decode_top(asn1_KrbFastFinished, 0|0, p, len, data, size);
7490 : }
7491 :
7492 :
7493 : int ASN1CALL
7494 0 : encode_KrbFastFinished(unsigned char *p, size_t len, const KrbFastFinished *data, size_t *size)
7495 : {
7496 0 : return _asn1_encode(asn1_KrbFastFinished, p, len, data, size);
7497 : }
7498 :
7499 :
7500 : size_t ASN1CALL
7501 0 : length_KrbFastFinished(const KrbFastFinished *data)
7502 : {
7503 0 : return _asn1_length(asn1_KrbFastFinished, data);
7504 : }
7505 :
7506 :
7507 : void ASN1CALL
7508 0 : free_KrbFastFinished(KrbFastFinished *data)
7509 : {
7510 0 : _asn1_free_top(asn1_KrbFastFinished, data);
7511 0 : }
7512 :
7513 :
7514 : int ASN1CALL
7515 0 : copy_KrbFastFinished(const KrbFastFinished *from, KrbFastFinished *to)
7516 : {
7517 0 : return _asn1_copy_top(asn1_KrbFastFinished, from, to);
7518 : }
7519 :
7520 :
7521 : char * ASN1CALL
7522 0 : print_KrbFastFinished(const KrbFastFinished *data, int flags)
7523 : {
7524 0 : return _asn1_print_top(asn1_KrbFastFinished, flags, data);
7525 : }
7526 :
7527 : /* template_members: KrbFastResponse exp exp */
7528 : /* tsequence: members isstruct: 1 */
7529 : /* template_members: KrbFastResponse exp exp */
7530 : /* generate_template_type: KrbFastResponse_tag_padata_378 */
7531 : /* template_members: KrbFastResponse exp exp */
7532 : /* generate_template_type: KrbFastResponse_tag_strengthen_key_379 */
7533 : /* template_members: KrbFastResponse exp exp */
7534 : /* generate_template_type: KrbFastResponse_tag_finished_380 */
7535 : const struct asn1_template asn1_KrbFastResponse_tag_finished_380[] = {
7536 : /* 0 */ { 0, sizeof(KrbFastFinished), ((void *)(uintptr_t)1) },
7537 : /* 1 */ { A1_OP_TYPE , 0, asn1_KrbFastFinished }
7538 : };
7539 : /* template_members: KrbFastResponse exp exp */
7540 : /* generate_template_type: KrbFastResponse_tag_nonce_381 */
7541 : /* generate_template_type: KrbFastResponse_tag__377 */
7542 : const struct asn1_template asn1_KrbFastResponse_tag__377[] = {
7543 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct KrbFastResponse), ((void *)(uintptr_t)10) },
7544 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KrbFastResponse, padata), asn1_EncKDCRepPart_tag_encrypted_pa_data_83 },
7545 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct KrbFastResponse, strengthen_key), asn1_EncTicketPart_tag_key_56 },
7546 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct KrbFastResponse, finished), asn1_KrbFastResponse_tag_finished_380 },
7547 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KrbFastResponse, nonce), asn1_Authenticator_tag_seq_number_116 },
7548 : /* 5 */ { A1_OP_NAME, 0, "KrbFastResponse" },
7549 : /* 6 */ { A1_OP_NAME, 0, "padata" },
7550 : /* 7 */ { A1_OP_NAME, 0, "strengthen-key" },
7551 : /* 8 */ { A1_OP_NAME, 0, "finished" },
7552 : /* 9 */ { A1_OP_NAME, 0, "nonce" },
7553 : /* 10 */ { A1_OP_NAME, 0, "..." }
7554 : };
7555 : /* generate_template_type: KrbFastResponse */
7556 : const struct asn1_template asn1_KrbFastResponse[] = {
7557 : /* 0 */ { 0, sizeof(KrbFastResponse), ((void *)(uintptr_t)1) },
7558 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KrbFastResponse_tag__377 }
7559 : };
7560 :
7561 : int ASN1CALL
7562 32014 : decode_KrbFastResponse(const unsigned char *p, size_t len, KrbFastResponse *data, size_t *size)
7563 : {
7564 32014 : memset(data, 0, sizeof(*data));
7565 32014 : return _asn1_decode_top(asn1_KrbFastResponse, 0|0, p, len, data, size);
7566 : }
7567 :
7568 :
7569 : int ASN1CALL
7570 32108 : encode_KrbFastResponse(unsigned char *p, size_t len, const KrbFastResponse *data, size_t *size)
7571 : {
7572 32108 : return _asn1_encode(asn1_KrbFastResponse, p, len, data, size);
7573 : }
7574 :
7575 :
7576 : size_t ASN1CALL
7577 32108 : length_KrbFastResponse(const KrbFastResponse *data)
7578 : {
7579 32108 : return _asn1_length(asn1_KrbFastResponse, data);
7580 : }
7581 :
7582 :
7583 : void ASN1CALL
7584 32088 : free_KrbFastResponse(KrbFastResponse *data)
7585 : {
7586 32088 : _asn1_free_top(asn1_KrbFastResponse, data);
7587 32088 : }
7588 :
7589 :
7590 : int ASN1CALL
7591 0 : copy_KrbFastResponse(const KrbFastResponse *from, KrbFastResponse *to)
7592 : {
7593 0 : return _asn1_copy_top(asn1_KrbFastResponse, from, to);
7594 : }
7595 :
7596 :
7597 : char * ASN1CALL
7598 0 : print_KrbFastResponse(const KrbFastResponse *data, int flags)
7599 : {
7600 0 : return _asn1_print_top(asn1_KrbFastResponse, flags, data);
7601 : }
7602 :
7603 : /* template_members: KrbFastArmoredRep exp exp */
7604 : /* tsequence: members isstruct: 1 */
7605 : /* template_members: KrbFastArmoredRep exp exp */
7606 : /* generate_template_type: KrbFastArmoredRep_tag_enc_fast_rep_383 */
7607 : /* generate_template_type: KrbFastArmoredRep_tag__382 */
7608 : const struct asn1_template asn1_KrbFastArmoredRep_tag__382[] = {
7609 : /* 0 */ { 0|A1_HF_ELLIPSIS, sizeof(struct KrbFastArmoredRep), ((void *)(uintptr_t)4) },
7610 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KrbFastArmoredRep, enc_fast_rep), asn1_Ticket_tag_enc_part_52 },
7611 : /* 2 */ { A1_OP_NAME, 0, "KrbFastArmoredRep" },
7612 : /* 3 */ { A1_OP_NAME, 0, "enc-fast-rep" },
7613 : /* 4 */ { A1_OP_NAME, 0, "..." }
7614 : };
7615 : /* generate_template_type: KrbFastArmoredRep */
7616 : const struct asn1_template asn1_KrbFastArmoredRep[] = {
7617 : /* 0 */ { 0, sizeof(KrbFastArmoredRep), ((void *)(uintptr_t)1) },
7618 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KrbFastArmoredRep_tag__382 }
7619 : };
7620 :
7621 : int ASN1CALL
7622 0 : decode_KrbFastArmoredRep(const unsigned char *p, size_t len, KrbFastArmoredRep *data, size_t *size)
7623 : {
7624 0 : memset(data, 0, sizeof(*data));
7625 0 : return _asn1_decode_top(asn1_KrbFastArmoredRep, 0|0, p, len, data, size);
7626 : }
7627 :
7628 :
7629 : int ASN1CALL
7630 0 : encode_KrbFastArmoredRep(unsigned char *p, size_t len, const KrbFastArmoredRep *data, size_t *size)
7631 : {
7632 0 : return _asn1_encode(asn1_KrbFastArmoredRep, p, len, data, size);
7633 : }
7634 :
7635 :
7636 : size_t ASN1CALL
7637 0 : length_KrbFastArmoredRep(const KrbFastArmoredRep *data)
7638 : {
7639 0 : return _asn1_length(asn1_KrbFastArmoredRep, data);
7640 : }
7641 :
7642 :
7643 : void ASN1CALL
7644 0 : free_KrbFastArmoredRep(KrbFastArmoredRep *data)
7645 : {
7646 0 : _asn1_free_top(asn1_KrbFastArmoredRep, data);
7647 0 : }
7648 :
7649 :
7650 : int ASN1CALL
7651 0 : copy_KrbFastArmoredRep(const KrbFastArmoredRep *from, KrbFastArmoredRep *to)
7652 : {
7653 0 : return _asn1_copy_top(asn1_KrbFastArmoredRep, from, to);
7654 : }
7655 :
7656 :
7657 : char * ASN1CALL
7658 0 : print_KrbFastArmoredRep(const KrbFastArmoredRep *data, int flags)
7659 : {
7660 0 : return _asn1_print_top(asn1_KrbFastArmoredRep, flags, data);
7661 : }
7662 :
7663 : /* template_members: KrbFastArmoredRep exp exp */
7664 : /* generate_template_type: KrbFastArmoredRep_tag__384 */
7665 : const struct asn1_template asn1_KrbFastArmoredRep_tag__384[] = {
7666 : /* 0 */ { 0, sizeof(KrbFastArmoredRep), ((void *)(uintptr_t)1) },
7667 : /* 1 */ { A1_OP_TYPE , 0, asn1_KrbFastArmoredRep }
7668 : };
7669 : /* generate_template_type: PA_FX_FAST_REPLY_choice_armored_data */
7670 : const struct asn1_template asn1_PA_FX_FAST_REPLY_choice_armored_data[] = {
7671 : /* 0 */ { 0, sizeof(KrbFastArmoredRep), ((void *)(uintptr_t)1) },
7672 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), 0, asn1_KrbFastArmoredRep_tag__384 }
7673 : };
7674 : static const struct asn1_template asn1_choice_PA_FX_FAST_REPLY_2[] = {
7675 : /* 0 */ { offsetof(PA_FX_FAST_REPLY, u.asn1_ellipsis), offsetof(PA_FX_FAST_REPLY, element), ((void *)(uintptr_t)3) },
7676 : /* 1 */ { choice_PA_FX_FAST_REPLY_armored_data, offsetof(PA_FX_FAST_REPLY, u.armored_data), asn1_PA_FX_FAST_REPLY_choice_armored_data },
7677 : /* 2 */ { 0, 0, "armored-data" },
7678 : /* 3 */ { 0, 0, "..." }
7679 : };
7680 : /* generate_template_type: PA_FX_FAST_REPLY */
7681 : const struct asn1_template asn1_PA_FX_FAST_REPLY[] = {
7682 : /* 0 */ { 0, sizeof(PA_FX_FAST_REPLY), ((void *)(uintptr_t)1) },
7683 : /* 1 */ { A1_OP_CHOICE, 0, asn1_choice_PA_FX_FAST_REPLY_2 }
7684 : };
7685 :
7686 : int ASN1CALL
7687 32014 : decode_PA_FX_FAST_REPLY(const unsigned char *p, size_t len, PA_FX_FAST_REPLY *data, size_t *size)
7688 : {
7689 32014 : memset(data, 0, sizeof(*data));
7690 32014 : return _asn1_decode_top(asn1_PA_FX_FAST_REPLY, 0|0, p, len, data, size);
7691 : }
7692 :
7693 :
7694 : int ASN1CALL
7695 32108 : encode_PA_FX_FAST_REPLY(unsigned char *p, size_t len, const PA_FX_FAST_REPLY *data, size_t *size)
7696 : {
7697 32108 : return _asn1_encode(asn1_PA_FX_FAST_REPLY, p, len, data, size);
7698 : }
7699 :
7700 :
7701 : size_t ASN1CALL
7702 32108 : length_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *data)
7703 : {
7704 32108 : return _asn1_length(asn1_PA_FX_FAST_REPLY, data);
7705 : }
7706 :
7707 :
7708 : void ASN1CALL
7709 64122 : free_PA_FX_FAST_REPLY(PA_FX_FAST_REPLY *data)
7710 : {
7711 64122 : _asn1_free_top(asn1_PA_FX_FAST_REPLY, data);
7712 64122 : }
7713 :
7714 :
7715 : int ASN1CALL
7716 0 : copy_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *from, PA_FX_FAST_REPLY *to)
7717 : {
7718 0 : return _asn1_copy_top(asn1_PA_FX_FAST_REPLY, from, to);
7719 : }
7720 :
7721 :
7722 : char * ASN1CALL
7723 0 : print_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *data, int flags)
7724 : {
7725 0 : return _asn1_print_top(asn1_PA_FX_FAST_REPLY, flags, data);
7726 : }
7727 :
7728 : /* template_members: KDCFastFlags exp exp */
7729 : static const struct asn1_template asn1_KDCFastFlags_bmember__6[] = {
7730 : /* 0 */ { 0|A1_HBF_RFC1510, sizeof(KDCFastFlags), ((void *)(uintptr_t)5) },
7731 : /* 1 */ { 0, 0, "use_reply_key" },
7732 : /* 2 */ { 0, 1, "reply_key_used" },
7733 : /* 3 */ { 0, 2, "reply_key_replaced" },
7734 : /* 4 */ { 0, 3, "kdc_verified" },
7735 : /* 5 */ { 0, 4, "requested_hidden_names" }
7736 : };
7737 : /* generate_template_type: KDCFastFlags_tag__385 */
7738 : const struct asn1_template asn1_KDCFastFlags_tag__385[] = {
7739 : /* 0 */ { 0, sizeof(KDCFastFlags), ((void *)(uintptr_t)1) },
7740 : /* 1 */ { A1_OP_BMEMBER, 0, asn1_KDCFastFlags_bmember__6 }
7741 : };
7742 : /* generate_template_type: KDCFastFlags */
7743 : const struct asn1_template asn1_KDCFastFlags[] = {
7744 : /* 0 */ { 0, sizeof(KDCFastFlags), ((void *)(uintptr_t)1) },
7745 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_BitString), 0, asn1_KDCFastFlags_tag__385 }
7746 : };
7747 :
7748 : int ASN1CALL
7749 0 : decode_KDCFastFlags(const unsigned char *p, size_t len, KDCFastFlags *data, size_t *size)
7750 : {
7751 0 : memset(data, 0, sizeof(*data));
7752 0 : return _asn1_decode_top(asn1_KDCFastFlags, 0|0, p, len, data, size);
7753 : }
7754 :
7755 :
7756 : int ASN1CALL
7757 0 : encode_KDCFastFlags(unsigned char *p, size_t len, const KDCFastFlags *data, size_t *size)
7758 : {
7759 0 : return _asn1_encode(asn1_KDCFastFlags, p, len, data, size);
7760 : }
7761 :
7762 :
7763 : size_t ASN1CALL
7764 0 : length_KDCFastFlags(const KDCFastFlags *data)
7765 : {
7766 0 : return _asn1_length(asn1_KDCFastFlags, data);
7767 : }
7768 :
7769 :
7770 : void ASN1CALL
7771 0 : free_KDCFastFlags(KDCFastFlags *data)
7772 : {
7773 0 : _asn1_free_top(asn1_KDCFastFlags, data);
7774 0 : }
7775 :
7776 :
7777 : int ASN1CALL
7778 0 : copy_KDCFastFlags(const KDCFastFlags *from, KDCFastFlags *to)
7779 : {
7780 0 : return _asn1_copy_top(asn1_KDCFastFlags, from, to);
7781 : }
7782 :
7783 :
7784 : char * ASN1CALL
7785 0 : print_KDCFastFlags(const KDCFastFlags *data, int flags)
7786 : {
7787 0 : return _asn1_print_top(asn1_KDCFastFlags, flags, data);
7788 : }
7789 :
7790 0 : uint64_t KDCFastFlags2int(KDCFastFlags f)
7791 : {
7792 0 : uint64_t r = 0;
7793 0 : if(f.use_reply_key) r |= (1ULL << 0);
7794 0 : if(f.reply_key_used) r |= (1ULL << 1);
7795 0 : if(f.reply_key_replaced) r |= (1ULL << 2);
7796 0 : if(f.kdc_verified) r |= (1ULL << 3);
7797 0 : if(f.requested_hidden_names) r |= (1ULL << 4);
7798 0 : return r;
7799 : }
7800 :
7801 0 : KDCFastFlags int2KDCFastFlags(uint64_t n)
7802 : {
7803 : KDCFastFlags flags;
7804 :
7805 0 : memset(&flags, 0, sizeof(flags));
7806 :
7807 0 : flags.use_reply_key = (n >> 0) & 1;
7808 0 : flags.reply_key_used = (n >> 1) & 1;
7809 0 : flags.reply_key_replaced = (n >> 2) & 1;
7810 0 : flags.kdc_verified = (n >> 3) & 1;
7811 0 : flags.requested_hidden_names = (n >> 4) & 1;
7812 0 : return flags;
7813 : }
7814 :
7815 : static struct units KDCFastFlags_units[] = {
7816 : {"requested-hidden-names", 1ULL << 4},
7817 : {"kdc-verified", 1ULL << 3},
7818 : {"reply-key-replaced", 1ULL << 2},
7819 : {"reply-key-used", 1ULL << 1},
7820 : {"use-reply-key", 1ULL << 0},
7821 : {NULL, 0}
7822 : };
7823 :
7824 0 : const struct units * asn1_KDCFastFlags_units(void){
7825 0 : return KDCFastFlags_units;
7826 : }
7827 :
7828 : /* template_members: KDCFastState exp exp */
7829 : /* tsequence: members isstruct: 1 */
7830 : /* template_members: KDCFastState exp exp */
7831 : /* generate_template_type: KDCFastState_tag_flags_387 */
7832 : const struct asn1_template asn1_KDCFastState_tag_flags_387[] = {
7833 : /* 0 */ { 0, sizeof(KDCFastFlags), ((void *)(uintptr_t)1) },
7834 : /* 1 */ { A1_OP_TYPE , 0, asn1_KDCFastFlags }
7835 : };
7836 : /* template_members: KDCFastState exp exp */
7837 : /* template_members: time_t exp exp */
7838 : /* generate_template_type: time_t_tag_expiration_389 */
7839 : /* generate_template_type: KDCFastState_tag_expiration_388 */
7840 : const struct asn1_template asn1_KDCFastState_tag_expiration_388[] = {
7841 : /* 0 */ { 0, sizeof(time_t), ((void *)(uintptr_t)1) },
7842 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_GeneralizedTime), 0, asn1_KerberosTime_tag__20 }
7843 : };
7844 : /* template_members: KDCFastState exp exp */
7845 : /* generate_template_type: KDCFastState_tag_fast_state_390 */
7846 : /* template_members: KDCFastState exp exp */
7847 : /* template_members: KDCFastState exp exp */
7848 : /* generate_template_type: KDCFastState_expected_pa_types_17 */
7849 : /* generate_template_type: KDCFastState_tag_expected_pa_types_392 */
7850 : const struct asn1_template asn1_KDCFastState_tag_expected_pa_types_392[] = {
7851 : /* 0 */ { 0, sizeof(struct KDCFastState_expected_pa_types), ((void *)(uintptr_t)1) },
7852 : /* 1 */ { A1_OP_SEQOF, 0, asn1_PA_DATA_tag_padata_type_119 }
7853 : };
7854 : /* generate_template_type: KDCFastState_tag_expected_pa_types_391 */
7855 : const struct asn1_template asn1_KDCFastState_tag_expected_pa_types_391[] = {
7856 : /* 0 */ { 0, sizeof(struct KDCFastState_expected_pa_types), ((void *)(uintptr_t)1) },
7857 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDCFastState_tag_expected_pa_types_392 }
7858 : };
7859 : /* generate_template_type: KDCFastState_tag__386 */
7860 : const struct asn1_template asn1_KDCFastState_tag__386[] = {
7861 : /* 0 */ { 0, sizeof(struct KDCFastState), ((void *)(uintptr_t)9) },
7862 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KDCFastState, flags), asn1_KDCFastState_tag_flags_387 },
7863 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KDCFastState, expiration), asn1_KDCFastState_tag_expiration_388 },
7864 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KDCFastState, fast_state), asn1_EncKDCRepPart_tag_encrypted_pa_data_83 },
7865 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct KDCFastState, expected_pa_types), asn1_KDCFastState_tag_expected_pa_types_391 },
7866 : /* 5 */ { A1_OP_NAME, 0, "KDCFastState" },
7867 : /* 6 */ { A1_OP_NAME, 0, "flags" },
7868 : /* 7 */ { A1_OP_NAME, 0, "expiration" },
7869 : /* 8 */ { A1_OP_NAME, 0, "fast-state" },
7870 : /* 9 */ { A1_OP_NAME, 0, "expected-pa-types" }
7871 : };
7872 : /* generate_template_type: KDCFastState */
7873 : const struct asn1_template asn1_KDCFastState[] = {
7874 : /* 0 */ { 0, sizeof(KDCFastState), ((void *)(uintptr_t)1) },
7875 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDCFastState_tag__386 }
7876 : };
7877 :
7878 : int ASN1CALL
7879 1 : decode_KDCFastState(const unsigned char *p, size_t len, KDCFastState *data, size_t *size)
7880 : {
7881 1 : memset(data, 0, sizeof(*data));
7882 1 : return _asn1_decode_top(asn1_KDCFastState, 0|0, p, len, data, size);
7883 : }
7884 :
7885 :
7886 : int ASN1CALL
7887 1176 : encode_KDCFastState(unsigned char *p, size_t len, const KDCFastState *data, size_t *size)
7888 : {
7889 1176 : return _asn1_encode(asn1_KDCFastState, p, len, data, size);
7890 : }
7891 :
7892 :
7893 : size_t ASN1CALL
7894 1176 : length_KDCFastState(const KDCFastState *data)
7895 : {
7896 1176 : return _asn1_length(asn1_KDCFastState, data);
7897 : }
7898 :
7899 :
7900 : void ASN1CALL
7901 71023 : free_KDCFastState(KDCFastState *data)
7902 : {
7903 71023 : _asn1_free_top(asn1_KDCFastState, data);
7904 71023 : }
7905 :
7906 :
7907 : int ASN1CALL
7908 0 : copy_KDCFastState(const KDCFastState *from, KDCFastState *to)
7909 : {
7910 0 : return _asn1_copy_top(asn1_KDCFastState, from, to);
7911 : }
7912 :
7913 :
7914 : char * ASN1CALL
7915 0 : print_KDCFastState(const KDCFastState *data, int flags)
7916 : {
7917 0 : return _asn1_print_top(asn1_KDCFastState, flags, data);
7918 : }
7919 :
7920 : /* template_members: KDCFastCookie exp exp */
7921 : /* tsequence: members isstruct: 1 */
7922 : /* template_members: KDCFastCookie exp exp */
7923 : /* template_members: heim_utf8_string exp exp */
7924 : /* generate_template_type: heim_utf8_string_tag_version_395 */
7925 : const struct asn1_template asn1_heim_utf8_string_tag_version_395[] = {
7926 : /* 0 */ { 0, sizeof(heim_utf8_string), ((void *)(uintptr_t)1) },
7927 : /* 1 */ { A1_PARSE_T(A1T_UTF8_STRING), 0, NULL }
7928 : };
7929 : /* generate_template_type: KDCFastCookie_tag_version_394 */
7930 : const struct asn1_template asn1_KDCFastCookie_tag_version_394[] = {
7931 : /* 0 */ { 0, sizeof(heim_utf8_string), ((void *)(uintptr_t)1) },
7932 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_UTF8String), 0, asn1_heim_utf8_string_tag_version_395 }
7933 : };
7934 : /* template_members: KDCFastCookie exp exp */
7935 : /* generate_template_type: KDCFastCookie_tag_cookie_396 */
7936 : /* generate_template_type: KDCFastCookie_tag__393 */
7937 : const struct asn1_template asn1_KDCFastCookie_tag__393[] = {
7938 : /* 0 */ { 0, sizeof(struct KDCFastCookie), ((void *)(uintptr_t)5) },
7939 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KDCFastCookie, version), asn1_KDCFastCookie_tag_version_394 },
7940 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KDCFastCookie, cookie), asn1_Ticket_tag_enc_part_52 },
7941 : /* 3 */ { A1_OP_NAME, 0, "KDCFastCookie" },
7942 : /* 4 */ { A1_OP_NAME, 0, "version" },
7943 : /* 5 */ { A1_OP_NAME, 0, "cookie" }
7944 : };
7945 : /* generate_template_type: KDCFastCookie */
7946 : const struct asn1_template asn1_KDCFastCookie[] = {
7947 : /* 0 */ { 0, sizeof(KDCFastCookie), ((void *)(uintptr_t)1) },
7948 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDCFastCookie_tag__393 }
7949 : };
7950 :
7951 : int ASN1CALL
7952 1 : decode_KDCFastCookie(const unsigned char *p, size_t len, KDCFastCookie *data, size_t *size)
7953 : {
7954 1 : memset(data, 0, sizeof(*data));
7955 1 : return _asn1_decode_top(asn1_KDCFastCookie, 0|0, p, len, data, size);
7956 : }
7957 :
7958 :
7959 : int ASN1CALL
7960 1176 : encode_KDCFastCookie(unsigned char *p, size_t len, const KDCFastCookie *data, size_t *size)
7961 : {
7962 1176 : return _asn1_encode(asn1_KDCFastCookie, p, len, data, size);
7963 : }
7964 :
7965 :
7966 : size_t ASN1CALL
7967 1176 : length_KDCFastCookie(const KDCFastCookie *data)
7968 : {
7969 1176 : return _asn1_length(asn1_KDCFastCookie, data);
7970 : }
7971 :
7972 :
7973 : void ASN1CALL
7974 1 : free_KDCFastCookie(KDCFastCookie *data)
7975 : {
7976 1 : _asn1_free_top(asn1_KDCFastCookie, data);
7977 1 : }
7978 :
7979 :
7980 : int ASN1CALL
7981 0 : copy_KDCFastCookie(const KDCFastCookie *from, KDCFastCookie *to)
7982 : {
7983 0 : return _asn1_copy_top(asn1_KDCFastCookie, from, to);
7984 : }
7985 :
7986 :
7987 : char * ASN1CALL
7988 0 : print_KDCFastCookie(const KDCFastCookie *data, int flags)
7989 : {
7990 0 : return _asn1_print_top(asn1_KDCFastCookie, flags, data);
7991 : }
7992 :
7993 : /* template_members: KDC_PROXY_MESSAGE exp exp */
7994 : /* tsequence: members isstruct: 1 */
7995 : /* template_members: KDC_PROXY_MESSAGE exp exp */
7996 : /* template_members: heim_octet_string exp exp */
7997 : /* generate_template_type: heim_octet_string_tag_kerb_message_399 */
7998 : /* generate_template_type: KDC_PROXY_MESSAGE_tag_kerb_message_398 */
7999 : /* template_members: KDC_PROXY_MESSAGE exp exp */
8000 : /* generate_template_type: KDC_PROXY_MESSAGE_tag_target_domain_400 */
8001 : /* template_members: KDC_PROXY_MESSAGE exp exp */
8002 : /* template_members: heim_integer exp exp */
8003 : /* generate_template_type: heim_integer_tag_dclocator_hint_402 */
8004 : const struct asn1_template asn1_heim_integer_tag_dclocator_hint_402[] = {
8005 : /* 0 */ { 0, sizeof(heim_integer), ((void *)(uintptr_t)1) },
8006 : /* 1 */ { A1_PARSE_T(A1T_HEIM_INTEGER), 0, NULL }
8007 : };
8008 : /* generate_template_type: KDC_PROXY_MESSAGE_tag_dclocator_hint_401 */
8009 : const struct asn1_template asn1_KDC_PROXY_MESSAGE_tag_dclocator_hint_401[] = {
8010 : /* 0 */ { 0, sizeof(heim_integer), ((void *)(uintptr_t)1) },
8011 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_heim_integer_tag_dclocator_hint_402 }
8012 : };
8013 : /* generate_template_type: KDC_PROXY_MESSAGE_tag__397 */
8014 : const struct asn1_template asn1_KDC_PROXY_MESSAGE_tag__397[] = {
8015 : /* 0 */ { 0, sizeof(struct KDC_PROXY_MESSAGE), ((void *)(uintptr_t)7) },
8016 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KDC_PROXY_MESSAGE, kerb_message), asn1_HostAddress_tag_address_17 },
8017 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct KDC_PROXY_MESSAGE, target_domain), asn1_Ticket_tag_realm_50 },
8018 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2)|A1_FLAG_OPTIONAL, offsetof(struct KDC_PROXY_MESSAGE, dclocator_hint), asn1_KDC_PROXY_MESSAGE_tag_dclocator_hint_401 },
8019 : /* 4 */ { A1_OP_NAME, 0, "KDC_PROXY_MESSAGE" },
8020 : /* 5 */ { A1_OP_NAME, 0, "kerb-message" },
8021 : /* 6 */ { A1_OP_NAME, 0, "target-domain" },
8022 : /* 7 */ { A1_OP_NAME, 0, "dclocator-hint" }
8023 : };
8024 : /* generate_template_type: KDC_PROXY_MESSAGE */
8025 : const struct asn1_template asn1_KDC_PROXY_MESSAGE[] = {
8026 : /* 0 */ { 0, sizeof(KDC_PROXY_MESSAGE), ((void *)(uintptr_t)1) },
8027 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KDC_PROXY_MESSAGE_tag__397 }
8028 : };
8029 :
8030 : int ASN1CALL
8031 0 : decode_KDC_PROXY_MESSAGE(const unsigned char *p, size_t len, KDC_PROXY_MESSAGE *data, size_t *size)
8032 : {
8033 0 : memset(data, 0, sizeof(*data));
8034 0 : return _asn1_decode_top(asn1_KDC_PROXY_MESSAGE, 0|0, p, len, data, size);
8035 : }
8036 :
8037 :
8038 : int ASN1CALL
8039 0 : encode_KDC_PROXY_MESSAGE(unsigned char *p, size_t len, const KDC_PROXY_MESSAGE *data, size_t *size)
8040 : {
8041 0 : return _asn1_encode(asn1_KDC_PROXY_MESSAGE, p, len, data, size);
8042 : }
8043 :
8044 :
8045 : size_t ASN1CALL
8046 0 : length_KDC_PROXY_MESSAGE(const KDC_PROXY_MESSAGE *data)
8047 : {
8048 0 : return _asn1_length(asn1_KDC_PROXY_MESSAGE, data);
8049 : }
8050 :
8051 :
8052 : void ASN1CALL
8053 0 : free_KDC_PROXY_MESSAGE(KDC_PROXY_MESSAGE *data)
8054 : {
8055 0 : _asn1_free_top(asn1_KDC_PROXY_MESSAGE, data);
8056 0 : }
8057 :
8058 :
8059 : int ASN1CALL
8060 0 : copy_KDC_PROXY_MESSAGE(const KDC_PROXY_MESSAGE *from, KDC_PROXY_MESSAGE *to)
8061 : {
8062 0 : return _asn1_copy_top(asn1_KDC_PROXY_MESSAGE, from, to);
8063 : }
8064 :
8065 :
8066 : char * ASN1CALL
8067 0 : print_KDC_PROXY_MESSAGE(const KDC_PROXY_MESSAGE *data, int flags)
8068 : {
8069 0 : return _asn1_print_top(asn1_KDC_PROXY_MESSAGE, flags, data);
8070 : }
8071 :
8072 : /* template_members: KERB_TIMES exp exp */
8073 : /* tsequence: members isstruct: 1 */
8074 : /* template_members: KERB_TIMES exp exp */
8075 : /* generate_template_type: KERB_TIMES_tag_authtime_404 */
8076 : /* template_members: KERB_TIMES exp exp */
8077 : /* generate_template_type: KERB_TIMES_tag_starttime_405 */
8078 : /* template_members: KERB_TIMES exp exp */
8079 : /* generate_template_type: KERB_TIMES_tag_endtime_406 */
8080 : /* template_members: KERB_TIMES exp exp */
8081 : /* generate_template_type: KERB_TIMES_tag_renew_till_407 */
8082 : /* generate_template_type: KERB_TIMES_tag__403 */
8083 : const struct asn1_template asn1_KERB_TIMES_tag__403[] = {
8084 : /* 0 */ { 0, sizeof(struct KERB_TIMES), ((void *)(uintptr_t)9) },
8085 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KERB_TIMES, authtime), asn1_LastReq_val_tag_lr_value_33 },
8086 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KERB_TIMES, starttime), asn1_LastReq_val_tag_lr_value_33 },
8087 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KERB_TIMES, endtime), asn1_LastReq_val_tag_lr_value_33 },
8088 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KERB_TIMES, renew_till), asn1_LastReq_val_tag_lr_value_33 },
8089 : /* 5 */ { A1_OP_NAME, 0, "KERB_TIMES" },
8090 : /* 6 */ { A1_OP_NAME, 0, "authtime" },
8091 : /* 7 */ { A1_OP_NAME, 0, "starttime" },
8092 : /* 8 */ { A1_OP_NAME, 0, "endtime" },
8093 : /* 9 */ { A1_OP_NAME, 0, "renew_till" }
8094 : };
8095 : /* generate_template_type: KERB_TIMES */
8096 : const struct asn1_template asn1_KERB_TIMES[] = {
8097 : /* 0 */ { 0, sizeof(KERB_TIMES), ((void *)(uintptr_t)1) },
8098 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_TIMES_tag__403 }
8099 : };
8100 :
8101 : int ASN1CALL
8102 0 : decode_KERB_TIMES(const unsigned char *p, size_t len, KERB_TIMES *data, size_t *size)
8103 : {
8104 0 : memset(data, 0, sizeof(*data));
8105 0 : return _asn1_decode_top(asn1_KERB_TIMES, 0|0, p, len, data, size);
8106 : }
8107 :
8108 :
8109 : int ASN1CALL
8110 0 : encode_KERB_TIMES(unsigned char *p, size_t len, const KERB_TIMES *data, size_t *size)
8111 : {
8112 0 : return _asn1_encode(asn1_KERB_TIMES, p, len, data, size);
8113 : }
8114 :
8115 :
8116 : size_t ASN1CALL
8117 0 : length_KERB_TIMES(const KERB_TIMES *data)
8118 : {
8119 0 : return _asn1_length(asn1_KERB_TIMES, data);
8120 : }
8121 :
8122 :
8123 : void ASN1CALL
8124 0 : free_KERB_TIMES(KERB_TIMES *data)
8125 : {
8126 0 : _asn1_free_top(asn1_KERB_TIMES, data);
8127 0 : }
8128 :
8129 :
8130 : int ASN1CALL
8131 0 : copy_KERB_TIMES(const KERB_TIMES *from, KERB_TIMES *to)
8132 : {
8133 0 : return _asn1_copy_top(asn1_KERB_TIMES, from, to);
8134 : }
8135 :
8136 :
8137 : char * ASN1CALL
8138 0 : print_KERB_TIMES(const KERB_TIMES *data, int flags)
8139 : {
8140 0 : return _asn1_print_top(asn1_KERB_TIMES, flags, data);
8141 : }
8142 :
8143 : /* template_members: KERB_CRED exp exp */
8144 : /* tsequence: members isstruct: 1 */
8145 : /* template_members: KERB_CRED exp exp */
8146 : /* generate_template_type: KERB_CRED_tag_client_409 */
8147 : /* template_members: KERB_CRED exp exp */
8148 : /* generate_template_type: KERB_CRED_tag_server_410 */
8149 : /* template_members: KERB_CRED exp exp */
8150 : /* generate_template_type: KERB_CRED_tag_keyblock_411 */
8151 : /* template_members: KERB_CRED exp exp */
8152 : /* generate_template_type: KERB_CRED_tag_times_412 */
8153 : const struct asn1_template asn1_KERB_CRED_tag_times_412[] = {
8154 : /* 0 */ { 0, sizeof(KERB_TIMES), ((void *)(uintptr_t)1) },
8155 : /* 1 */ { A1_OP_TYPE , 0, asn1_KERB_TIMES }
8156 : };
8157 : /* template_members: KERB_CRED exp exp */
8158 : /* template_members: heim_octet_string exp exp */
8159 : /* generate_template_type: heim_octet_string_tag_ticket_414 */
8160 : /* generate_template_type: KERB_CRED_tag_ticket_413 */
8161 : /* template_members: KERB_CRED exp exp */
8162 : /* template_members: heim_octet_string exp exp */
8163 : /* generate_template_type: heim_octet_string_tag_authdata_416 */
8164 : /* generate_template_type: KERB_CRED_tag_authdata_415 */
8165 : /* template_members: KERB_CRED exp exp */
8166 : /* generate_template_type: KERB_CRED_tag_addresses_417 */
8167 : /* template_members: KERB_CRED exp exp */
8168 : /* generate_template_type: KERB_CRED_tag_flags_418 */
8169 : /* generate_template_type: KERB_CRED_tag__408 */
8170 : const struct asn1_template asn1_KERB_CRED_tag__408[] = {
8171 : /* 0 */ { 0, sizeof(struct KERB_CRED), ((void *)(uintptr_t)17) },
8172 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KERB_CRED, client), asn1_Principal_seofTstruct_4 },
8173 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KERB_CRED, server), asn1_Principal_seofTstruct_4 },
8174 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KERB_CRED, keyblock), asn1_EncTicketPart_tag_key_56 },
8175 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KERB_CRED, times), asn1_KERB_CRED_tag_times_412 },
8176 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4), offsetof(struct KERB_CRED, ticket), asn1_HostAddress_tag_address_17 },
8177 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5), offsetof(struct KERB_CRED, authdata), asn1_HostAddress_tag_address_17 },
8178 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6), offsetof(struct KERB_CRED, addresses), asn1_EncTicketPart_tag_caddr_64 },
8179 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7), offsetof(struct KERB_CRED, flags), asn1_EncTicketPart_tag_flags_55 },
8180 : /* 9 */ { A1_OP_NAME, 0, "KERB_CRED" },
8181 : /* 10 */ { A1_OP_NAME, 0, "client" },
8182 : /* 11 */ { A1_OP_NAME, 0, "server" },
8183 : /* 12 */ { A1_OP_NAME, 0, "keyblock" },
8184 : /* 13 */ { A1_OP_NAME, 0, "times" },
8185 : /* 14 */ { A1_OP_NAME, 0, "ticket" },
8186 : /* 15 */ { A1_OP_NAME, 0, "authdata" },
8187 : /* 16 */ { A1_OP_NAME, 0, "addresses" },
8188 : /* 17 */ { A1_OP_NAME, 0, "flags" }
8189 : };
8190 : /* generate_template_type: KERB_CRED */
8191 : const struct asn1_template asn1_KERB_CRED[] = {
8192 : /* 0 */ { 0, sizeof(KERB_CRED), ((void *)(uintptr_t)1) },
8193 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_CRED_tag__408 }
8194 : };
8195 :
8196 : int ASN1CALL
8197 0 : decode_KERB_CRED(const unsigned char *p, size_t len, KERB_CRED *data, size_t *size)
8198 : {
8199 0 : memset(data, 0, sizeof(*data));
8200 0 : return _asn1_decode_top(asn1_KERB_CRED, 0|0, p, len, data, size);
8201 : }
8202 :
8203 :
8204 : int ASN1CALL
8205 0 : encode_KERB_CRED(unsigned char *p, size_t len, const KERB_CRED *data, size_t *size)
8206 : {
8207 0 : return _asn1_encode(asn1_KERB_CRED, p, len, data, size);
8208 : }
8209 :
8210 :
8211 : size_t ASN1CALL
8212 0 : length_KERB_CRED(const KERB_CRED *data)
8213 : {
8214 0 : return _asn1_length(asn1_KERB_CRED, data);
8215 : }
8216 :
8217 :
8218 : void ASN1CALL
8219 0 : free_KERB_CRED(KERB_CRED *data)
8220 : {
8221 0 : _asn1_free_top(asn1_KERB_CRED, data);
8222 0 : }
8223 :
8224 :
8225 : int ASN1CALL
8226 0 : copy_KERB_CRED(const KERB_CRED *from, KERB_CRED *to)
8227 : {
8228 0 : return _asn1_copy_top(asn1_KERB_CRED, from, to);
8229 : }
8230 :
8231 :
8232 : char * ASN1CALL
8233 0 : print_KERB_CRED(const KERB_CRED *data, int flags)
8234 : {
8235 0 : return _asn1_print_top(asn1_KERB_CRED, flags, data);
8236 : }
8237 :
8238 : /* template_members: KERB_TGS_REQ_IN exp exp */
8239 : /* tsequence: members isstruct: 1 */
8240 : /* template_members: KERB_TGS_REQ_IN exp exp */
8241 : /* template_members: heim_octet_string exp exp */
8242 : /* generate_template_type: heim_octet_string_tag_cache_421 */
8243 : /* generate_template_type: KERB_TGS_REQ_IN_tag_cache_420 */
8244 : /* template_members: KERB_TGS_REQ_IN exp exp */
8245 : /* generate_template_type: KERB_TGS_REQ_IN_tag_addrs_422 */
8246 : /* template_members: KERB_TGS_REQ_IN exp exp */
8247 : /* generate_template_type: KERB_TGS_REQ_IN_tag_flags_423 */
8248 : /* template_members: KERB_TGS_REQ_IN exp exp */
8249 : /* generate_template_type: KERB_TGS_REQ_IN_tag_imp_424 */
8250 : /* template_members: KERB_TGS_REQ_IN exp exp */
8251 : /* template_members: heim_octet_string exp exp */
8252 : /* generate_template_type: heim_octet_string_tag_ticket_426 */
8253 : /* generate_template_type: KERB_TGS_REQ_IN_tag_ticket_425 */
8254 : /* template_members: KERB_TGS_REQ_IN exp exp */
8255 : /* generate_template_type: KERB_TGS_REQ_IN_tag_in_cred_427 */
8256 : const struct asn1_template asn1_KERB_TGS_REQ_IN_tag_in_cred_427[] = {
8257 : /* 0 */ { 0, sizeof(KERB_CRED), ((void *)(uintptr_t)1) },
8258 : /* 1 */ { A1_OP_TYPE , 0, asn1_KERB_CRED }
8259 : };
8260 : /* template_members: KERB_TGS_REQ_IN exp exp */
8261 : /* generate_template_type: KERB_TGS_REQ_IN_tag_krbtgt_428 */
8262 : /* template_members: KERB_TGS_REQ_IN exp exp */
8263 : /* generate_template_type: KERB_TGS_REQ_IN_tag_padata_429 */
8264 : /* generate_template_type: KERB_TGS_REQ_IN_tag__419 */
8265 : const struct asn1_template asn1_KERB_TGS_REQ_IN_tag__419[] = {
8266 : /* 0 */ { 0, sizeof(struct KERB_TGS_REQ_IN), ((void *)(uintptr_t)17) },
8267 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KERB_TGS_REQ_IN, cache), asn1_HostAddress_tag_address_17 },
8268 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KERB_TGS_REQ_IN, addrs), asn1_EncTicketPart_tag_caddr_64 },
8269 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KERB_TGS_REQ_IN, flags), asn1_Authenticator_tag_seq_number_116 },
8270 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3)|A1_FLAG_OPTIONAL, offsetof(struct KERB_TGS_REQ_IN, imp), asn1_Principal_seofTstruct_4 },
8271 : /* 5 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,4)|A1_FLAG_OPTIONAL, offsetof(struct KERB_TGS_REQ_IN, ticket), asn1_HostAddress_tag_address_17 },
8272 : /* 6 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,5), offsetof(struct KERB_TGS_REQ_IN, in_cred), asn1_KERB_TGS_REQ_IN_tag_in_cred_427 },
8273 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,6), offsetof(struct KERB_TGS_REQ_IN, krbtgt), asn1_KERB_TGS_REQ_IN_tag_in_cred_427 },
8274 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,7), offsetof(struct KERB_TGS_REQ_IN, padata), asn1_EncKDCRepPart_tag_encrypted_pa_data_83 },
8275 : /* 9 */ { A1_OP_NAME, 0, "KERB_TGS_REQ_IN" },
8276 : /* 10 */ { A1_OP_NAME, 0, "cache" },
8277 : /* 11 */ { A1_OP_NAME, 0, "addrs" },
8278 : /* 12 */ { A1_OP_NAME, 0, "flags" },
8279 : /* 13 */ { A1_OP_NAME, 0, "imp" },
8280 : /* 14 */ { A1_OP_NAME, 0, "ticket" },
8281 : /* 15 */ { A1_OP_NAME, 0, "in_cred" },
8282 : /* 16 */ { A1_OP_NAME, 0, "krbtgt" },
8283 : /* 17 */ { A1_OP_NAME, 0, "padata" }
8284 : };
8285 : /* generate_template_type: KERB_TGS_REQ_IN */
8286 : const struct asn1_template asn1_KERB_TGS_REQ_IN[] = {
8287 : /* 0 */ { 0, sizeof(KERB_TGS_REQ_IN), ((void *)(uintptr_t)1) },
8288 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_TGS_REQ_IN_tag__419 }
8289 : };
8290 :
8291 : int ASN1CALL
8292 0 : decode_KERB_TGS_REQ_IN(const unsigned char *p, size_t len, KERB_TGS_REQ_IN *data, size_t *size)
8293 : {
8294 0 : memset(data, 0, sizeof(*data));
8295 0 : return _asn1_decode_top(asn1_KERB_TGS_REQ_IN, 0|0, p, len, data, size);
8296 : }
8297 :
8298 :
8299 : int ASN1CALL
8300 0 : encode_KERB_TGS_REQ_IN(unsigned char *p, size_t len, const KERB_TGS_REQ_IN *data, size_t *size)
8301 : {
8302 0 : return _asn1_encode(asn1_KERB_TGS_REQ_IN, p, len, data, size);
8303 : }
8304 :
8305 :
8306 : size_t ASN1CALL
8307 0 : length_KERB_TGS_REQ_IN(const KERB_TGS_REQ_IN *data)
8308 : {
8309 0 : return _asn1_length(asn1_KERB_TGS_REQ_IN, data);
8310 : }
8311 :
8312 :
8313 : void ASN1CALL
8314 0 : free_KERB_TGS_REQ_IN(KERB_TGS_REQ_IN *data)
8315 : {
8316 0 : _asn1_free_top(asn1_KERB_TGS_REQ_IN, data);
8317 0 : }
8318 :
8319 :
8320 : int ASN1CALL
8321 0 : copy_KERB_TGS_REQ_IN(const KERB_TGS_REQ_IN *from, KERB_TGS_REQ_IN *to)
8322 : {
8323 0 : return _asn1_copy_top(asn1_KERB_TGS_REQ_IN, from, to);
8324 : }
8325 :
8326 :
8327 : char * ASN1CALL
8328 0 : print_KERB_TGS_REQ_IN(const KERB_TGS_REQ_IN *data, int flags)
8329 : {
8330 0 : return _asn1_print_top(asn1_KERB_TGS_REQ_IN, flags, data);
8331 : }
8332 :
8333 : /* template_members: KERB_TGS_REQ_OUT exp exp */
8334 : /* tsequence: members isstruct: 1 */
8335 : /* template_members: KERB_TGS_REQ_OUT exp exp */
8336 : /* generate_template_type: KERB_TGS_REQ_OUT_tag_subkey_431 */
8337 : /* template_members: KERB_TGS_REQ_OUT exp exp */
8338 : /* generate_template_type: KERB_TGS_REQ_OUT_tag_t_432 */
8339 : const struct asn1_template asn1_KERB_TGS_REQ_OUT_tag_t_432[] = {
8340 : /* 0 */ { 0, sizeof(TGS_REQ), ((void *)(uintptr_t)1) },
8341 : /* 1 */ { A1_OP_TYPE , 0, asn1_TGS_REQ }
8342 : };
8343 : /* generate_template_type: KERB_TGS_REQ_OUT_tag__430 */
8344 : const struct asn1_template asn1_KERB_TGS_REQ_OUT_tag__430[] = {
8345 : /* 0 */ { 0, sizeof(struct KERB_TGS_REQ_OUT), ((void *)(uintptr_t)5) },
8346 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0)|A1_FLAG_OPTIONAL, offsetof(struct KERB_TGS_REQ_OUT, subkey), asn1_EncTicketPart_tag_key_56 },
8347 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KERB_TGS_REQ_OUT, t), asn1_KERB_TGS_REQ_OUT_tag_t_432 },
8348 : /* 3 */ { A1_OP_NAME, 0, "KERB_TGS_REQ_OUT" },
8349 : /* 4 */ { A1_OP_NAME, 0, "subkey" },
8350 : /* 5 */ { A1_OP_NAME, 0, "t" }
8351 : };
8352 : /* generate_template_type: KERB_TGS_REQ_OUT */
8353 : const struct asn1_template asn1_KERB_TGS_REQ_OUT[] = {
8354 : /* 0 */ { 0, sizeof(KERB_TGS_REQ_OUT), ((void *)(uintptr_t)1) },
8355 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_TGS_REQ_OUT_tag__430 }
8356 : };
8357 :
8358 : int ASN1CALL
8359 0 : decode_KERB_TGS_REQ_OUT(const unsigned char *p, size_t len, KERB_TGS_REQ_OUT *data, size_t *size)
8360 : {
8361 0 : memset(data, 0, sizeof(*data));
8362 0 : return _asn1_decode_top(asn1_KERB_TGS_REQ_OUT, 0|0, p, len, data, size);
8363 : }
8364 :
8365 :
8366 : int ASN1CALL
8367 0 : encode_KERB_TGS_REQ_OUT(unsigned char *p, size_t len, const KERB_TGS_REQ_OUT *data, size_t *size)
8368 : {
8369 0 : return _asn1_encode(asn1_KERB_TGS_REQ_OUT, p, len, data, size);
8370 : }
8371 :
8372 :
8373 : size_t ASN1CALL
8374 0 : length_KERB_TGS_REQ_OUT(const KERB_TGS_REQ_OUT *data)
8375 : {
8376 0 : return _asn1_length(asn1_KERB_TGS_REQ_OUT, data);
8377 : }
8378 :
8379 :
8380 : void ASN1CALL
8381 0 : free_KERB_TGS_REQ_OUT(KERB_TGS_REQ_OUT *data)
8382 : {
8383 0 : _asn1_free_top(asn1_KERB_TGS_REQ_OUT, data);
8384 0 : }
8385 :
8386 :
8387 : int ASN1CALL
8388 0 : copy_KERB_TGS_REQ_OUT(const KERB_TGS_REQ_OUT *from, KERB_TGS_REQ_OUT *to)
8389 : {
8390 0 : return _asn1_copy_top(asn1_KERB_TGS_REQ_OUT, from, to);
8391 : }
8392 :
8393 :
8394 : char * ASN1CALL
8395 0 : print_KERB_TGS_REQ_OUT(const KERB_TGS_REQ_OUT *data, int flags)
8396 : {
8397 0 : return _asn1_print_top(asn1_KERB_TGS_REQ_OUT, flags, data);
8398 : }
8399 :
8400 : /* template_members: KERB_TGS_REP_IN exp exp */
8401 : /* tsequence: members isstruct: 1 */
8402 : /* template_members: KERB_TGS_REP_IN exp exp */
8403 : /* template_members: heim_octet_string exp exp */
8404 : /* generate_template_type: heim_octet_string_tag_cache_435 */
8405 : /* generate_template_type: KERB_TGS_REP_IN_tag_cache_434 */
8406 : /* template_members: KERB_TGS_REP_IN exp exp */
8407 : /* generate_template_type: KERB_TGS_REP_IN_tag_subkey_436 */
8408 : /* template_members: KERB_TGS_REP_IN exp exp */
8409 : /* generate_template_type: KERB_TGS_REP_IN_tag_in_cred_437 */
8410 : /* template_members: KERB_TGS_REP_IN exp exp */
8411 : /* generate_template_type: KERB_TGS_REP_IN_tag_t_438 */
8412 : const struct asn1_template asn1_KERB_TGS_REP_IN_tag_t_438[] = {
8413 : /* 0 */ { 0, sizeof(TGS_REP), ((void *)(uintptr_t)1) },
8414 : /* 1 */ { A1_OP_TYPE , 0, asn1_TGS_REP }
8415 : };
8416 : /* generate_template_type: KERB_TGS_REP_IN_tag__433 */
8417 : const struct asn1_template asn1_KERB_TGS_REP_IN_tag__433[] = {
8418 : /* 0 */ { 0, sizeof(struct KERB_TGS_REP_IN), ((void *)(uintptr_t)9) },
8419 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KERB_TGS_REP_IN, cache), asn1_HostAddress_tag_address_17 },
8420 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL, offsetof(struct KERB_TGS_REP_IN, subkey), asn1_EncTicketPart_tag_key_56 },
8421 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KERB_TGS_REP_IN, in_cred), asn1_KERB_TGS_REQ_IN_tag_in_cred_427 },
8422 : /* 4 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,3), offsetof(struct KERB_TGS_REP_IN, t), asn1_KERB_TGS_REP_IN_tag_t_438 },
8423 : /* 5 */ { A1_OP_NAME, 0, "KERB_TGS_REP_IN" },
8424 : /* 6 */ { A1_OP_NAME, 0, "cache" },
8425 : /* 7 */ { A1_OP_NAME, 0, "subkey" },
8426 : /* 8 */ { A1_OP_NAME, 0, "in_cred" },
8427 : /* 9 */ { A1_OP_NAME, 0, "t" }
8428 : };
8429 : /* generate_template_type: KERB_TGS_REP_IN */
8430 : const struct asn1_template asn1_KERB_TGS_REP_IN[] = {
8431 : /* 0 */ { 0, sizeof(KERB_TGS_REP_IN), ((void *)(uintptr_t)1) },
8432 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_TGS_REP_IN_tag__433 }
8433 : };
8434 :
8435 : int ASN1CALL
8436 0 : decode_KERB_TGS_REP_IN(const unsigned char *p, size_t len, KERB_TGS_REP_IN *data, size_t *size)
8437 : {
8438 0 : memset(data, 0, sizeof(*data));
8439 0 : return _asn1_decode_top(asn1_KERB_TGS_REP_IN, 0|0, p, len, data, size);
8440 : }
8441 :
8442 :
8443 : int ASN1CALL
8444 0 : encode_KERB_TGS_REP_IN(unsigned char *p, size_t len, const KERB_TGS_REP_IN *data, size_t *size)
8445 : {
8446 0 : return _asn1_encode(asn1_KERB_TGS_REP_IN, p, len, data, size);
8447 : }
8448 :
8449 :
8450 : size_t ASN1CALL
8451 0 : length_KERB_TGS_REP_IN(const KERB_TGS_REP_IN *data)
8452 : {
8453 0 : return _asn1_length(asn1_KERB_TGS_REP_IN, data);
8454 : }
8455 :
8456 :
8457 : void ASN1CALL
8458 0 : free_KERB_TGS_REP_IN(KERB_TGS_REP_IN *data)
8459 : {
8460 0 : _asn1_free_top(asn1_KERB_TGS_REP_IN, data);
8461 0 : }
8462 :
8463 :
8464 : int ASN1CALL
8465 0 : copy_KERB_TGS_REP_IN(const KERB_TGS_REP_IN *from, KERB_TGS_REP_IN *to)
8466 : {
8467 0 : return _asn1_copy_top(asn1_KERB_TGS_REP_IN, from, to);
8468 : }
8469 :
8470 :
8471 : char * ASN1CALL
8472 0 : print_KERB_TGS_REP_IN(const KERB_TGS_REP_IN *data, int flags)
8473 : {
8474 0 : return _asn1_print_top(asn1_KERB_TGS_REP_IN, flags, data);
8475 : }
8476 :
8477 : /* template_members: KERB_TGS_REP_OUT exp exp */
8478 : /* tsequence: members isstruct: 1 */
8479 : /* template_members: KERB_TGS_REP_OUT exp exp */
8480 : /* template_members: heim_octet_string exp exp */
8481 : /* generate_template_type: heim_octet_string_tag_cache_441 */
8482 : /* generate_template_type: KERB_TGS_REP_OUT_tag_cache_440 */
8483 : /* template_members: KERB_TGS_REP_OUT exp exp */
8484 : /* generate_template_type: KERB_TGS_REP_OUT_tag_cred_442 */
8485 : /* template_members: KERB_TGS_REP_OUT exp exp */
8486 : /* generate_template_type: KERB_TGS_REP_OUT_tag_subkey_443 */
8487 : /* generate_template_type: KERB_TGS_REP_OUT_tag__439 */
8488 : const struct asn1_template asn1_KERB_TGS_REP_OUT_tag__439[] = {
8489 : /* 0 */ { 0, sizeof(struct KERB_TGS_REP_OUT), ((void *)(uintptr_t)7) },
8490 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KERB_TGS_REP_OUT, cache), asn1_HostAddress_tag_address_17 },
8491 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KERB_TGS_REP_OUT, cred), asn1_KERB_TGS_REQ_IN_tag_in_cred_427 },
8492 : /* 3 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,2), offsetof(struct KERB_TGS_REP_OUT, subkey), asn1_EncTicketPart_tag_key_56 },
8493 : /* 4 */ { A1_OP_NAME, 0, "KERB_TGS_REP_OUT" },
8494 : /* 5 */ { A1_OP_NAME, 0, "cache" },
8495 : /* 6 */ { A1_OP_NAME, 0, "cred" },
8496 : /* 7 */ { A1_OP_NAME, 0, "subkey" }
8497 : };
8498 : /* generate_template_type: KERB_TGS_REP_OUT */
8499 : const struct asn1_template asn1_KERB_TGS_REP_OUT[] = {
8500 : /* 0 */ { 0, sizeof(KERB_TGS_REP_OUT), ((void *)(uintptr_t)1) },
8501 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_TGS_REP_OUT_tag__439 }
8502 : };
8503 :
8504 : int ASN1CALL
8505 0 : decode_KERB_TGS_REP_OUT(const unsigned char *p, size_t len, KERB_TGS_REP_OUT *data, size_t *size)
8506 : {
8507 0 : memset(data, 0, sizeof(*data));
8508 0 : return _asn1_decode_top(asn1_KERB_TGS_REP_OUT, 0|0, p, len, data, size);
8509 : }
8510 :
8511 :
8512 : int ASN1CALL
8513 0 : encode_KERB_TGS_REP_OUT(unsigned char *p, size_t len, const KERB_TGS_REP_OUT *data, size_t *size)
8514 : {
8515 0 : return _asn1_encode(asn1_KERB_TGS_REP_OUT, p, len, data, size);
8516 : }
8517 :
8518 :
8519 : size_t ASN1CALL
8520 0 : length_KERB_TGS_REP_OUT(const KERB_TGS_REP_OUT *data)
8521 : {
8522 0 : return _asn1_length(asn1_KERB_TGS_REP_OUT, data);
8523 : }
8524 :
8525 :
8526 : void ASN1CALL
8527 0 : free_KERB_TGS_REP_OUT(KERB_TGS_REP_OUT *data)
8528 : {
8529 0 : _asn1_free_top(asn1_KERB_TGS_REP_OUT, data);
8530 0 : }
8531 :
8532 :
8533 : int ASN1CALL
8534 0 : copy_KERB_TGS_REP_OUT(const KERB_TGS_REP_OUT *from, KERB_TGS_REP_OUT *to)
8535 : {
8536 0 : return _asn1_copy_top(asn1_KERB_TGS_REP_OUT, from, to);
8537 : }
8538 :
8539 :
8540 : char * ASN1CALL
8541 0 : print_KERB_TGS_REP_OUT(const KERB_TGS_REP_OUT *data, int flags)
8542 : {
8543 0 : return _asn1_print_top(asn1_KERB_TGS_REP_OUT, flags, data);
8544 : }
8545 :
8546 : /* template_members: KERB_ARMOR_SERVICE_REPLY exp exp */
8547 : /* tsequence: members isstruct: 1 */
8548 : /* template_members: KERB_ARMOR_SERVICE_REPLY exp exp */
8549 : /* generate_template_type: KERB_ARMOR_SERVICE_REPLY_tag_armor_445 */
8550 : /* template_members: KERB_ARMOR_SERVICE_REPLY exp exp */
8551 : /* generate_template_type: KERB_ARMOR_SERVICE_REPLY_tag_armor_key_446 */
8552 : /* generate_template_type: KERB_ARMOR_SERVICE_REPLY_tag__444 */
8553 : const struct asn1_template asn1_KERB_ARMOR_SERVICE_REPLY_tag__444[] = {
8554 : /* 0 */ { 0, sizeof(struct KERB_ARMOR_SERVICE_REPLY), ((void *)(uintptr_t)5) },
8555 : /* 1 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,0), offsetof(struct KERB_ARMOR_SERVICE_REPLY, armor), asn1_KrbFastArmoredReq_tag_armor_367 },
8556 : /* 2 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1), offsetof(struct KERB_ARMOR_SERVICE_REPLY, armor_key), asn1_EncTicketPart_tag_key_56 },
8557 : /* 3 */ { A1_OP_NAME, 0, "KERB_ARMOR_SERVICE_REPLY" },
8558 : /* 4 */ { A1_OP_NAME, 0, "armor" },
8559 : /* 5 */ { A1_OP_NAME, 0, "armor-key" }
8560 : };
8561 : /* generate_template_type: KERB_ARMOR_SERVICE_REPLY */
8562 : const struct asn1_template asn1_KERB_ARMOR_SERVICE_REPLY[] = {
8563 : /* 0 */ { 0, sizeof(KERB_ARMOR_SERVICE_REPLY), ((void *)(uintptr_t)1) },
8564 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence), 0, asn1_KERB_ARMOR_SERVICE_REPLY_tag__444 }
8565 : };
8566 :
8567 : int ASN1CALL
8568 0 : decode_KERB_ARMOR_SERVICE_REPLY(const unsigned char *p, size_t len, KERB_ARMOR_SERVICE_REPLY *data, size_t *size)
8569 : {
8570 0 : memset(data, 0, sizeof(*data));
8571 0 : return _asn1_decode_top(asn1_KERB_ARMOR_SERVICE_REPLY, 0|0, p, len, data, size);
8572 : }
8573 :
8574 :
8575 : int ASN1CALL
8576 0 : encode_KERB_ARMOR_SERVICE_REPLY(unsigned char *p, size_t len, const KERB_ARMOR_SERVICE_REPLY *data, size_t *size)
8577 : {
8578 0 : return _asn1_encode(asn1_KERB_ARMOR_SERVICE_REPLY, p, len, data, size);
8579 : }
8580 :
8581 :
8582 : size_t ASN1CALL
8583 0 : length_KERB_ARMOR_SERVICE_REPLY(const KERB_ARMOR_SERVICE_REPLY *data)
8584 : {
8585 0 : return _asn1_length(asn1_KERB_ARMOR_SERVICE_REPLY, data);
8586 : }
8587 :
8588 :
8589 : void ASN1CALL
8590 0 : free_KERB_ARMOR_SERVICE_REPLY(KERB_ARMOR_SERVICE_REPLY *data)
8591 : {
8592 0 : _asn1_free_top(asn1_KERB_ARMOR_SERVICE_REPLY, data);
8593 0 : }
8594 :
8595 :
8596 : int ASN1CALL
8597 0 : copy_KERB_ARMOR_SERVICE_REPLY(const KERB_ARMOR_SERVICE_REPLY *from, KERB_ARMOR_SERVICE_REPLY *to)
8598 : {
8599 0 : return _asn1_copy_top(asn1_KERB_ARMOR_SERVICE_REPLY, from, to);
8600 : }
8601 :
8602 :
8603 : char * ASN1CALL
8604 0 : print_KERB_ARMOR_SERVICE_REPLY(const KERB_ARMOR_SERVICE_REPLY *data, int flags)
8605 : {
8606 0 : return _asn1_print_top(asn1_KERB_ARMOR_SERVICE_REPLY, flags, data);
8607 : }
8608 :
|
