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