Line data Source code
1 : /* Generated from /builds/eaglegai/samba/third_party/heimdal/lib/asn1/rfc4108.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 "rfc4108_asn1.h"
15 : #include "rfc4108_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 : static const struct asn1_type_func asn1_extern_EnvelopedData = {
23 : (asn1_type_encode)encode_EnvelopedData,
24 : (asn1_type_decode)decode_EnvelopedData,
25 : (asn1_type_length)length_EnvelopedData,
26 : (asn1_type_copy)copy_EnvelopedData,
27 : (asn1_type_release)free_EnvelopedData,
28 : (asn1_type_print)print_EnvelopedData,
29 : sizeof(EnvelopedData)
30 : };
31 : static unsigned oid_id_ct_firmwarePackage_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 1, 16};
32 : const heim_oid asn1_oid_id_ct_firmwarePackage = { 9, oid_id_ct_firmwarePackage_variable_num };
33 :
34 : extern const struct asn1_template asn1_FirmwarePkgData[];
35 : extern const struct asn1_template asn1_FirmwarePkgData[];
36 : static unsigned oid_id_aa_firmwarePackageID_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 2, 35};
37 : const heim_oid asn1_oid_id_aa_firmwarePackageID = { 9, oid_id_aa_firmwarePackageID_variable_num };
38 :
39 : extern const struct asn1_template asn1_PreferredPackageIdentifier[];
40 : extern const struct asn1_template asn1_PreferredOrLegacyPackageIdentifier[];
41 : extern const struct asn1_template asn1_PreferredOrLegacyStalePackageIdentifier[];
42 : extern const struct asn1_template asn1_FirmwarePackageIdentifier[];
43 : static unsigned oid_id_aa_targetHardwareIDs_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 2, 36};
44 : const heim_oid asn1_oid_id_aa_targetHardwareIDs = { 9, oid_id_aa_targetHardwareIDs_variable_num };
45 :
46 : extern const struct asn1_template asn1_TargetHardwareIdentifiers[];
47 : static unsigned oid_id_aa_decryptKeyID_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 2, 37};
48 : const heim_oid asn1_oid_id_aa_decryptKeyID = { 9, oid_id_aa_decryptKeyID_variable_num };
49 :
50 : extern const struct asn1_template asn1_DecryptKeyIdentifier[];
51 : extern const struct asn1_template asn1_DecryptKeyIdentifier[];
52 : static unsigned oid_id_aa_implCryptoAlgs_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 2, 38};
53 : const heim_oid asn1_oid_id_aa_implCryptoAlgs = { 9, oid_id_aa_implCryptoAlgs_variable_num };
54 :
55 : extern const struct asn1_template asn1_ImplementedCryptoAlgorithms[];
56 : static unsigned oid_id_aa_implCompressAlgs_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 2, 43};
57 : const heim_oid asn1_oid_id_aa_implCompressAlgs = { 9, oid_id_aa_implCompressAlgs_variable_num };
58 :
59 : extern const struct asn1_template asn1_ImplementedCompressAlgorithms[];
60 : static unsigned oid_id_aa_communityIdentifiers_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 2, 40};
61 : const heim_oid asn1_oid_id_aa_communityIdentifiers = { 9, oid_id_aa_communityIdentifiers_variable_num };
62 :
63 : extern const struct asn1_template asn1_HardwareSerialEntry[];
64 : extern const struct asn1_template asn1_HardwareModules[];
65 : extern const struct asn1_template asn1_CommunityIdentifier[];
66 : extern const struct asn1_template asn1_CommunityIdentifiers[];
67 : static unsigned oid_id_aa_firmwarePackageInfo_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 2, 42};
68 : const heim_oid asn1_oid_id_aa_firmwarePackageInfo = { 9, oid_id_aa_firmwarePackageInfo_variable_num };
69 :
70 : extern const struct asn1_template asn1_FirmwarePackageInfo[];
71 : static unsigned oid_id_aa_wrappedFirmwareKey_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 2, 39};
72 : const heim_oid asn1_oid_id_aa_wrappedFirmwareKey = { 9, oid_id_aa_wrappedFirmwareKey_variable_num };
73 :
74 : extern const struct asn1_template asn1_WrappedFirmwareKey[];
75 : extern const struct asn1_template asn1_WrappedFirmwareKey[];
76 : static unsigned oid_id_ct_firmwareLoadReceipt_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 1, 17};
77 : const heim_oid asn1_oid_id_ct_firmwareLoadReceipt = { 9, oid_id_ct_firmwareLoadReceipt_variable_num };
78 :
79 : extern const struct asn1_template asn1_FWReceiptVersion[];
80 : extern const struct asn1_template asn1_FWReceiptVersion[];
81 : extern const struct asn1_template asn1_FirmwarePackageLoadReceipt[];
82 : static unsigned oid_id_ct_firmwareLoadError_variable_num[9] = { 1, 2, 840, 113549, 1, 9, 16, 1, 18};
83 : const heim_oid asn1_oid_id_ct_firmwareLoadError = { 9, oid_id_ct_firmwareLoadError_variable_num };
84 :
85 : extern const struct asn1_template asn1_FWErrorVersion[];
86 : extern const struct asn1_template asn1_FWErrorVersion[];
87 : extern const struct asn1_template asn1_FirmwarePackageLoadErrorCode[];
88 : extern const struct asn1_template asn1_FirmwarePackageLoadErrorCode[];
89 : extern const struct asn1_template asn1_VendorLoadErrorCode[];
90 : extern const struct asn1_template asn1_VendorLoadErrorCode[];
91 : extern const struct asn1_template asn1_CurrentFWConfig[];
92 : extern const struct asn1_template asn1_FirmwarePackageLoadError[];
93 : static unsigned oid_id_on_hardwareModuleName_variable_num[9] = { 1, 3, 6, 1, 5, 5, 7, 8, 4};
94 : const heim_oid asn1_oid_id_on_hardwareModuleName = { 9, oid_id_on_hardwareModuleName_variable_num };
95 :
96 : /* template_members: FirmwarePkgData exp exp */
97 : /* generate_template_type: FirmwarePkgData_tag__0 */
98 : const struct asn1_template asn1_FirmwarePkgData_tag__0[] = {
99 : /* 0 */ { 0, sizeof(heim_octet_string), ((void *)(uintptr_t)1) },
100 : /* 1 */ { A1_PARSE_T(A1T_OCTET_STRING), 0, NULL }
101 : };
102 : /* generate_template_type: FirmwarePkgData */
103 : const struct asn1_template asn1_FirmwarePkgData[] = {
104 : /* 0 */ { 0, sizeof(FirmwarePkgData), ((void *)(uintptr_t)1) },
105 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString), 0, asn1_FirmwarePkgData_tag__0 }
106 : };
107 :
108 : int ASN1CALL
109 0 : decode_FirmwarePkgData(const unsigned char *p, size_t len, FirmwarePkgData *data, size_t *size)
110 : {
111 0 : memset(data, 0, sizeof(*data));
112 0 : return _asn1_decode_top(asn1_FirmwarePkgData, 0|0, p, len, data, size);
113 : }
114 :
115 :
116 : int ASN1CALL
117 0 : encode_FirmwarePkgData(unsigned char *p, size_t len, const FirmwarePkgData *data, size_t *size)
118 : {
119 0 : return _asn1_encode(asn1_FirmwarePkgData, p, len, data, size);
120 : }
121 :
122 :
123 : size_t ASN1CALL
124 0 : length_FirmwarePkgData(const FirmwarePkgData *data)
125 : {
126 0 : return _asn1_length(asn1_FirmwarePkgData, data);
127 : }
128 :
129 :
130 : void ASN1CALL
131 0 : free_FirmwarePkgData(FirmwarePkgData *data)
132 : {
133 0 : _asn1_free_top(asn1_FirmwarePkgData, data);
134 0 : }
135 :
136 :
137 : int ASN1CALL
138 0 : copy_FirmwarePkgData(const FirmwarePkgData *from, FirmwarePkgData *to)
139 : {
140 0 : return _asn1_copy_top(asn1_FirmwarePkgData, from, to);
141 : }
142 :
143 :
144 : char * ASN1CALL
145 0 : print_FirmwarePkgData(const FirmwarePkgData *data, int flags)
146 : {
147 0 : return _asn1_print_top(asn1_FirmwarePkgData, flags, data);
148 : }
149 :
150 : /* template_members: PreferredPackageIdentifier imp imp */
151 : /* tsequence: members isstruct: 1 */
152 : /* template_members: PreferredPackageIdentifier exp exp */
153 : /* generate_template_type: PreferredPackageIdentifier_tag_fwPkgID_2 */
154 : const struct asn1_template asn1_PreferredPackageIdentifier_tag_fwPkgID_2[] = {
155 : /* 0 */ { 0, sizeof(heim_oid), ((void *)(uintptr_t)1) },
156 : /* 1 */ { A1_PARSE_T(A1T_OID), 0, NULL }
157 : };
158 : /* template_members: PreferredPackageIdentifier exp exp */
159 : /* generate_template_type: PreferredPackageIdentifier_tag_verNum_3 */
160 : const struct asn1_template asn1_PreferredPackageIdentifier_tag_verNum_3[] = {
161 : /* 0 */ { 0, sizeof(unsigned), ((void *)(uintptr_t)1) },
162 : /* 1 */ { A1_PARSE_T(A1T_UNSIGNED), 0, NULL }
163 : };
164 : /* generate_template_type: PreferredPackageIdentifier_tag__1 */
165 : const struct asn1_template asn1_PreferredPackageIdentifier_tag__1[] = {
166 : /* 0 */ { 0, sizeof(struct PreferredPackageIdentifier), ((void *)(uintptr_t)5) },
167 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OID), offsetof(struct PreferredPackageIdentifier, fwPkgID), asn1_PreferredPackageIdentifier_tag_fwPkgID_2 },
168 : /* 2 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), offsetof(struct PreferredPackageIdentifier, verNum), asn1_PreferredPackageIdentifier_tag_verNum_3 },
169 : /* 3 */ { A1_OP_NAME, 0, "PreferredPackageIdentifier" },
170 : /* 4 */ { A1_OP_NAME, 0, "fwPkgID" },
171 : /* 5 */ { A1_OP_NAME, 0, "verNum" }
172 : };
173 : /* generate_template_type: PreferredPackageIdentifier */
174 : const struct asn1_template asn1_PreferredPackageIdentifier[] = {
175 : /* 0 */ { 0, sizeof(PreferredPackageIdentifier), ((void *)(uintptr_t)1) },
176 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_PreferredPackageIdentifier_tag__1 }
177 : };
178 :
179 : int ASN1CALL
180 0 : decode_PreferredPackageIdentifier(const unsigned char *p, size_t len, PreferredPackageIdentifier *data, size_t *size)
181 : {
182 0 : memset(data, 0, sizeof(*data));
183 0 : return _asn1_decode_top(asn1_PreferredPackageIdentifier, 0|0, p, len, data, size);
184 : }
185 :
186 :
187 : int ASN1CALL
188 0 : encode_PreferredPackageIdentifier(unsigned char *p, size_t len, const PreferredPackageIdentifier *data, size_t *size)
189 : {
190 0 : return _asn1_encode(asn1_PreferredPackageIdentifier, p, len, data, size);
191 : }
192 :
193 :
194 : size_t ASN1CALL
195 0 : length_PreferredPackageIdentifier(const PreferredPackageIdentifier *data)
196 : {
197 0 : return _asn1_length(asn1_PreferredPackageIdentifier, data);
198 : }
199 :
200 :
201 : void ASN1CALL
202 0 : free_PreferredPackageIdentifier(PreferredPackageIdentifier *data)
203 : {
204 0 : _asn1_free_top(asn1_PreferredPackageIdentifier, data);
205 0 : }
206 :
207 :
208 : int ASN1CALL
209 0 : copy_PreferredPackageIdentifier(const PreferredPackageIdentifier *from, PreferredPackageIdentifier *to)
210 : {
211 0 : return _asn1_copy_top(asn1_PreferredPackageIdentifier, from, to);
212 : }
213 :
214 :
215 : char * ASN1CALL
216 0 : print_PreferredPackageIdentifier(const PreferredPackageIdentifier *data, int flags)
217 : {
218 0 : return _asn1_print_top(asn1_PreferredPackageIdentifier, flags, data);
219 : }
220 :
221 : /* generate_template_type: PreferredOrLegacyPackageIdentifier_choice_preferred */
222 : const struct asn1_template asn1_PreferredOrLegacyPackageIdentifier_choice_preferred[] = {
223 : /* 0 */ { 0, sizeof(PreferredPackageIdentifier), ((void *)(uintptr_t)1) },
224 : /* 1 */ { A1_OP_TYPE , 0, asn1_PreferredPackageIdentifier }
225 : };
226 : /* template_members: heim_octet_string exp exp */
227 : /* generate_template_type: heim_octet_string_tag__4 */
228 : /* generate_template_type: PreferredOrLegacyPackageIdentifier_choice_legacy */
229 : const struct asn1_template asn1_PreferredOrLegacyPackageIdentifier_choice_legacy[] = {
230 : /* 0 */ { 0, sizeof(heim_octet_string), ((void *)(uintptr_t)1) },
231 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString), 0, asn1_FirmwarePkgData_tag__0 }
232 : };
233 : static const struct asn1_template asn1_choice_PreferredOrLegacyPackageIdentifier_0[] = {
234 : /* 0 */ { 0, offsetof(PreferredOrLegacyPackageIdentifier, element), ((void *)(uintptr_t)4) },
235 : /* 1 */ { choice_PreferredOrLegacyPackageIdentifier_preferred, offsetof(PreferredOrLegacyPackageIdentifier, u.preferred), asn1_PreferredOrLegacyPackageIdentifier_choice_preferred },
236 : /* 2 */ { choice_PreferredOrLegacyPackageIdentifier_legacy, offsetof(PreferredOrLegacyPackageIdentifier, u.legacy), asn1_PreferredOrLegacyPackageIdentifier_choice_legacy },
237 : /* 3 */ { 0, 0, "preferred" },
238 : /* 4 */ { 0, 0, "legacy" }
239 : };
240 : /* generate_template_type: PreferredOrLegacyPackageIdentifier */
241 : const struct asn1_template asn1_PreferredOrLegacyPackageIdentifier[] = {
242 : /* 0 */ { 0, sizeof(PreferredOrLegacyPackageIdentifier), ((void *)(uintptr_t)1) },
243 : /* 1 */ { A1_OP_CHOICE, 0, asn1_choice_PreferredOrLegacyPackageIdentifier_0 }
244 : };
245 :
246 : int ASN1CALL
247 0 : decode_PreferredOrLegacyPackageIdentifier(const unsigned char *p, size_t len, PreferredOrLegacyPackageIdentifier *data, size_t *size)
248 : {
249 0 : memset(data, 0, sizeof(*data));
250 0 : return _asn1_decode_top(asn1_PreferredOrLegacyPackageIdentifier, 0|0, p, len, data, size);
251 : }
252 :
253 :
254 : int ASN1CALL
255 0 : encode_PreferredOrLegacyPackageIdentifier(unsigned char *p, size_t len, const PreferredOrLegacyPackageIdentifier *data, size_t *size)
256 : {
257 0 : return _asn1_encode(asn1_PreferredOrLegacyPackageIdentifier, p, len, data, size);
258 : }
259 :
260 :
261 : size_t ASN1CALL
262 0 : length_PreferredOrLegacyPackageIdentifier(const PreferredOrLegacyPackageIdentifier *data)
263 : {
264 0 : return _asn1_length(asn1_PreferredOrLegacyPackageIdentifier, data);
265 : }
266 :
267 :
268 : void ASN1CALL
269 0 : free_PreferredOrLegacyPackageIdentifier(PreferredOrLegacyPackageIdentifier *data)
270 : {
271 0 : _asn1_free_top(asn1_PreferredOrLegacyPackageIdentifier, data);
272 0 : }
273 :
274 :
275 : int ASN1CALL
276 0 : copy_PreferredOrLegacyPackageIdentifier(const PreferredOrLegacyPackageIdentifier *from, PreferredOrLegacyPackageIdentifier *to)
277 : {
278 0 : return _asn1_copy_top(asn1_PreferredOrLegacyPackageIdentifier, from, to);
279 : }
280 :
281 :
282 : char * ASN1CALL
283 0 : print_PreferredOrLegacyPackageIdentifier(const PreferredOrLegacyPackageIdentifier *data, int flags)
284 : {
285 0 : return _asn1_print_top(asn1_PreferredOrLegacyPackageIdentifier, flags, data);
286 : }
287 :
288 : /* template_members: unsigned exp exp */
289 : /* generate_template_type: unsigned_tag__5 */
290 : /* generate_template_type: PreferredOrLegacyStalePackageIdentifier_choice_preferredStaleVerNum */
291 : const struct asn1_template asn1_PreferredOrLegacyStalePackageIdentifier_choice_preferredStaleVerNum[] = {
292 : /* 0 */ { 0, sizeof(unsigned), ((void *)(uintptr_t)1) },
293 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_PreferredPackageIdentifier_tag_verNum_3 }
294 : };
295 : /* template_members: heim_octet_string exp exp */
296 : /* generate_template_type: heim_octet_string_tag__6 */
297 : /* generate_template_type: PreferredOrLegacyStalePackageIdentifier_choice_legacyStaleVersion */
298 : static const struct asn1_template asn1_choice_PreferredOrLegacyStalePackageIdentifier_1[] = {
299 : /* 0 */ { 0, offsetof(PreferredOrLegacyStalePackageIdentifier, element), ((void *)(uintptr_t)4) },
300 : /* 1 */ { choice_PreferredOrLegacyStalePackageIdentifier_preferredStaleVerNum, offsetof(PreferredOrLegacyStalePackageIdentifier, u.preferredStaleVerNum), asn1_PreferredOrLegacyStalePackageIdentifier_choice_preferredStaleVerNum },
301 : /* 2 */ { choice_PreferredOrLegacyStalePackageIdentifier_legacyStaleVersion, offsetof(PreferredOrLegacyStalePackageIdentifier, u.legacyStaleVersion), asn1_PreferredOrLegacyPackageIdentifier_choice_legacy },
302 : /* 3 */ { 0, 0, "preferredStaleVerNum" },
303 : /* 4 */ { 0, 0, "legacyStaleVersion" }
304 : };
305 : /* generate_template_type: PreferredOrLegacyStalePackageIdentifier */
306 : const struct asn1_template asn1_PreferredOrLegacyStalePackageIdentifier[] = {
307 : /* 0 */ { 0, sizeof(PreferredOrLegacyStalePackageIdentifier), ((void *)(uintptr_t)1) },
308 : /* 1 */ { A1_OP_CHOICE, 0, asn1_choice_PreferredOrLegacyStalePackageIdentifier_1 }
309 : };
310 :
311 : int ASN1CALL
312 0 : decode_PreferredOrLegacyStalePackageIdentifier(const unsigned char *p, size_t len, PreferredOrLegacyStalePackageIdentifier *data, size_t *size)
313 : {
314 0 : memset(data, 0, sizeof(*data));
315 0 : return _asn1_decode_top(asn1_PreferredOrLegacyStalePackageIdentifier, 0|0, p, len, data, size);
316 : }
317 :
318 :
319 : int ASN1CALL
320 0 : encode_PreferredOrLegacyStalePackageIdentifier(unsigned char *p, size_t len, const PreferredOrLegacyStalePackageIdentifier *data, size_t *size)
321 : {
322 0 : return _asn1_encode(asn1_PreferredOrLegacyStalePackageIdentifier, p, len, data, size);
323 : }
324 :
325 :
326 : size_t ASN1CALL
327 0 : length_PreferredOrLegacyStalePackageIdentifier(const PreferredOrLegacyStalePackageIdentifier *data)
328 : {
329 0 : return _asn1_length(asn1_PreferredOrLegacyStalePackageIdentifier, data);
330 : }
331 :
332 :
333 : void ASN1CALL
334 0 : free_PreferredOrLegacyStalePackageIdentifier(PreferredOrLegacyStalePackageIdentifier *data)
335 : {
336 0 : _asn1_free_top(asn1_PreferredOrLegacyStalePackageIdentifier, data);
337 0 : }
338 :
339 :
340 : int ASN1CALL
341 0 : copy_PreferredOrLegacyStalePackageIdentifier(const PreferredOrLegacyStalePackageIdentifier *from, PreferredOrLegacyStalePackageIdentifier *to)
342 : {
343 0 : return _asn1_copy_top(asn1_PreferredOrLegacyStalePackageIdentifier, from, to);
344 : }
345 :
346 :
347 : char * ASN1CALL
348 0 : print_PreferredOrLegacyStalePackageIdentifier(const PreferredOrLegacyStalePackageIdentifier *data, int flags)
349 : {
350 0 : return _asn1_print_top(asn1_PreferredOrLegacyStalePackageIdentifier, flags, data);
351 : }
352 :
353 : /* template_members: FirmwarePackageIdentifier imp imp */
354 : /* tsequence: members isstruct: 1 */
355 : /* generate_template_type: FirmwarePackageIdentifier_tag__7 */
356 : const struct asn1_template asn1_FirmwarePackageIdentifier_tag__7[] = {
357 : /* 0 */ { 0, sizeof(struct FirmwarePackageIdentifier), ((void *)(uintptr_t)5) },
358 : /* 1 */ { A1_OP_TYPE , offsetof(struct FirmwarePackageIdentifier, name), asn1_PreferredOrLegacyPackageIdentifier },
359 : /* 2 */ { A1_OP_TYPE |A1_FLAG_OPTIONAL, offsetof(struct FirmwarePackageIdentifier, stale), asn1_PreferredOrLegacyStalePackageIdentifier },
360 : /* 3 */ { A1_OP_NAME, 0, "FirmwarePackageIdentifier" },
361 : /* 4 */ { A1_OP_NAME, 0, "name" },
362 : /* 5 */ { A1_OP_NAME, 0, "stale" }
363 : };
364 : /* generate_template_type: FirmwarePackageIdentifier */
365 : const struct asn1_template asn1_FirmwarePackageIdentifier[] = {
366 : /* 0 */ { 0, sizeof(FirmwarePackageIdentifier), ((void *)(uintptr_t)1) },
367 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_FirmwarePackageIdentifier_tag__7 }
368 : };
369 :
370 : int ASN1CALL
371 0 : decode_FirmwarePackageIdentifier(const unsigned char *p, size_t len, FirmwarePackageIdentifier *data, size_t *size)
372 : {
373 0 : memset(data, 0, sizeof(*data));
374 0 : return _asn1_decode_top(asn1_FirmwarePackageIdentifier, 0|0, p, len, data, size);
375 : }
376 :
377 :
378 : int ASN1CALL
379 0 : encode_FirmwarePackageIdentifier(unsigned char *p, size_t len, const FirmwarePackageIdentifier *data, size_t *size)
380 : {
381 0 : return _asn1_encode(asn1_FirmwarePackageIdentifier, p, len, data, size);
382 : }
383 :
384 :
385 : size_t ASN1CALL
386 0 : length_FirmwarePackageIdentifier(const FirmwarePackageIdentifier *data)
387 : {
388 0 : return _asn1_length(asn1_FirmwarePackageIdentifier, data);
389 : }
390 :
391 :
392 : void ASN1CALL
393 0 : free_FirmwarePackageIdentifier(FirmwarePackageIdentifier *data)
394 : {
395 0 : _asn1_free_top(asn1_FirmwarePackageIdentifier, data);
396 0 : }
397 :
398 :
399 : int ASN1CALL
400 0 : copy_FirmwarePackageIdentifier(const FirmwarePackageIdentifier *from, FirmwarePackageIdentifier *to)
401 : {
402 0 : return _asn1_copy_top(asn1_FirmwarePackageIdentifier, from, to);
403 : }
404 :
405 :
406 : char * ASN1CALL
407 0 : print_FirmwarePackageIdentifier(const FirmwarePackageIdentifier *data, int flags)
408 : {
409 0 : return _asn1_print_top(asn1_FirmwarePackageIdentifier, flags, data);
410 : }
411 :
412 : /* template_members: TargetHardwareIdentifiers imp imp */
413 : /* template_members: heim_oid exp exp */
414 : /* generate_template_type: heim_oid_tag__9 */
415 : /* generate_template_type: heim_oid_seofTstruct_0 */
416 : const struct asn1_template asn1_heim_oid_seofTstruct_0[] = {
417 : /* 0 */ { 0, sizeof(heim_oid), ((void *)(uintptr_t)1) },
418 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OID), 0, asn1_PreferredPackageIdentifier_tag_fwPkgID_2 }
419 : };
420 : /* generate_template_type: TargetHardwareIdentifiers_tag__8 */
421 : const struct asn1_template asn1_TargetHardwareIdentifiers_tag__8[] = {
422 : /* 0 */ { 0, sizeof(heim_oid), ((void *)(uintptr_t)1) },
423 : /* 1 */ { A1_OP_SEQOF, 0, asn1_heim_oid_seofTstruct_0 }
424 : };
425 : /* generate_template_type: TargetHardwareIdentifiers */
426 : const struct asn1_template asn1_TargetHardwareIdentifiers[] = {
427 : /* 0 */ { 0, sizeof(TargetHardwareIdentifiers), ((void *)(uintptr_t)1) },
428 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_TargetHardwareIdentifiers_tag__8 }
429 : };
430 :
431 : int ASN1CALL
432 0 : decode_TargetHardwareIdentifiers(const unsigned char *p, size_t len, TargetHardwareIdentifiers *data, size_t *size)
433 : {
434 0 : memset(data, 0, sizeof(*data));
435 0 : return _asn1_decode_top(asn1_TargetHardwareIdentifiers, 0|0, p, len, data, size);
436 : }
437 :
438 :
439 : int ASN1CALL
440 0 : encode_TargetHardwareIdentifiers(unsigned char *p, size_t len, const TargetHardwareIdentifiers *data, size_t *size)
441 : {
442 0 : return _asn1_encode(asn1_TargetHardwareIdentifiers, p, len, data, size);
443 : }
444 :
445 :
446 : size_t ASN1CALL
447 0 : length_TargetHardwareIdentifiers(const TargetHardwareIdentifiers *data)
448 : {
449 0 : return _asn1_length(asn1_TargetHardwareIdentifiers, data);
450 : }
451 :
452 :
453 : void ASN1CALL
454 0 : free_TargetHardwareIdentifiers(TargetHardwareIdentifiers *data)
455 : {
456 0 : _asn1_free_top(asn1_TargetHardwareIdentifiers, data);
457 0 : }
458 :
459 :
460 : int ASN1CALL
461 0 : copy_TargetHardwareIdentifiers(const TargetHardwareIdentifiers *from, TargetHardwareIdentifiers *to)
462 : {
463 0 : return _asn1_copy_top(asn1_TargetHardwareIdentifiers, from, to);
464 : }
465 :
466 :
467 : char * ASN1CALL
468 0 : print_TargetHardwareIdentifiers(const TargetHardwareIdentifiers *data, int flags)
469 : {
470 0 : return _asn1_print_top(asn1_TargetHardwareIdentifiers, flags, data);
471 : }
472 :
473 : /* template_members: DecryptKeyIdentifier exp exp */
474 : /* generate_template_type: DecryptKeyIdentifier_tag__10 */
475 : /* generate_template_type: DecryptKeyIdentifier */
476 : const struct asn1_template asn1_DecryptKeyIdentifier[] = {
477 : /* 0 */ { 0, sizeof(DecryptKeyIdentifier), ((void *)(uintptr_t)1) },
478 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString), 0, asn1_FirmwarePkgData_tag__0 }
479 : };
480 :
481 : int ASN1CALL
482 0 : decode_DecryptKeyIdentifier(const unsigned char *p, size_t len, DecryptKeyIdentifier *data, size_t *size)
483 : {
484 0 : memset(data, 0, sizeof(*data));
485 0 : return _asn1_decode_top(asn1_DecryptKeyIdentifier, 0|0, p, len, data, size);
486 : }
487 :
488 :
489 : int ASN1CALL
490 0 : encode_DecryptKeyIdentifier(unsigned char *p, size_t len, const DecryptKeyIdentifier *data, size_t *size)
491 : {
492 0 : return _asn1_encode(asn1_DecryptKeyIdentifier, p, len, data, size);
493 : }
494 :
495 :
496 : size_t ASN1CALL
497 0 : length_DecryptKeyIdentifier(const DecryptKeyIdentifier *data)
498 : {
499 0 : return _asn1_length(asn1_DecryptKeyIdentifier, data);
500 : }
501 :
502 :
503 : void ASN1CALL
504 0 : free_DecryptKeyIdentifier(DecryptKeyIdentifier *data)
505 : {
506 0 : _asn1_free_top(asn1_DecryptKeyIdentifier, data);
507 0 : }
508 :
509 :
510 : int ASN1CALL
511 0 : copy_DecryptKeyIdentifier(const DecryptKeyIdentifier *from, DecryptKeyIdentifier *to)
512 : {
513 0 : return _asn1_copy_top(asn1_DecryptKeyIdentifier, from, to);
514 : }
515 :
516 :
517 : char * ASN1CALL
518 0 : print_DecryptKeyIdentifier(const DecryptKeyIdentifier *data, int flags)
519 : {
520 0 : return _asn1_print_top(asn1_DecryptKeyIdentifier, flags, data);
521 : }
522 :
523 : /* template_members: ImplementedCryptoAlgorithms imp imp */
524 : /* template_members: heim_oid exp exp */
525 : /* generate_template_type: heim_oid_tag__12 */
526 : /* generate_template_type: heim_oid_seofTstruct_1 */
527 : /* generate_template_type: ImplementedCryptoAlgorithms_tag__11 */
528 : /* generate_template_type: ImplementedCryptoAlgorithms */
529 : const struct asn1_template asn1_ImplementedCryptoAlgorithms[] = {
530 : /* 0 */ { 0, sizeof(ImplementedCryptoAlgorithms), ((void *)(uintptr_t)1) },
531 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_TargetHardwareIdentifiers_tag__8 }
532 : };
533 :
534 : int ASN1CALL
535 0 : decode_ImplementedCryptoAlgorithms(const unsigned char *p, size_t len, ImplementedCryptoAlgorithms *data, size_t *size)
536 : {
537 0 : memset(data, 0, sizeof(*data));
538 0 : return _asn1_decode_top(asn1_ImplementedCryptoAlgorithms, 0|0, p, len, data, size);
539 : }
540 :
541 :
542 : int ASN1CALL
543 0 : encode_ImplementedCryptoAlgorithms(unsigned char *p, size_t len, const ImplementedCryptoAlgorithms *data, size_t *size)
544 : {
545 0 : return _asn1_encode(asn1_ImplementedCryptoAlgorithms, p, len, data, size);
546 : }
547 :
548 :
549 : size_t ASN1CALL
550 0 : length_ImplementedCryptoAlgorithms(const ImplementedCryptoAlgorithms *data)
551 : {
552 0 : return _asn1_length(asn1_ImplementedCryptoAlgorithms, data);
553 : }
554 :
555 :
556 : void ASN1CALL
557 0 : free_ImplementedCryptoAlgorithms(ImplementedCryptoAlgorithms *data)
558 : {
559 0 : _asn1_free_top(asn1_ImplementedCryptoAlgorithms, data);
560 0 : }
561 :
562 :
563 : int ASN1CALL
564 0 : copy_ImplementedCryptoAlgorithms(const ImplementedCryptoAlgorithms *from, ImplementedCryptoAlgorithms *to)
565 : {
566 0 : return _asn1_copy_top(asn1_ImplementedCryptoAlgorithms, from, to);
567 : }
568 :
569 :
570 : char * ASN1CALL
571 0 : print_ImplementedCryptoAlgorithms(const ImplementedCryptoAlgorithms *data, int flags)
572 : {
573 0 : return _asn1_print_top(asn1_ImplementedCryptoAlgorithms, flags, data);
574 : }
575 :
576 : /* template_members: ImplementedCompressAlgorithms imp imp */
577 : /* template_members: heim_oid exp exp */
578 : /* generate_template_type: heim_oid_tag__14 */
579 : /* generate_template_type: heim_oid_seofTstruct_2 */
580 : /* generate_template_type: ImplementedCompressAlgorithms_tag__13 */
581 : /* generate_template_type: ImplementedCompressAlgorithms */
582 : const struct asn1_template asn1_ImplementedCompressAlgorithms[] = {
583 : /* 0 */ { 0, sizeof(ImplementedCompressAlgorithms), ((void *)(uintptr_t)1) },
584 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_TargetHardwareIdentifiers_tag__8 }
585 : };
586 :
587 : int ASN1CALL
588 0 : decode_ImplementedCompressAlgorithms(const unsigned char *p, size_t len, ImplementedCompressAlgorithms *data, size_t *size)
589 : {
590 0 : memset(data, 0, sizeof(*data));
591 0 : return _asn1_decode_top(asn1_ImplementedCompressAlgorithms, 0|0, p, len, data, size);
592 : }
593 :
594 :
595 : int ASN1CALL
596 0 : encode_ImplementedCompressAlgorithms(unsigned char *p, size_t len, const ImplementedCompressAlgorithms *data, size_t *size)
597 : {
598 0 : return _asn1_encode(asn1_ImplementedCompressAlgorithms, p, len, data, size);
599 : }
600 :
601 :
602 : size_t ASN1CALL
603 0 : length_ImplementedCompressAlgorithms(const ImplementedCompressAlgorithms *data)
604 : {
605 0 : return _asn1_length(asn1_ImplementedCompressAlgorithms, data);
606 : }
607 :
608 :
609 : void ASN1CALL
610 0 : free_ImplementedCompressAlgorithms(ImplementedCompressAlgorithms *data)
611 : {
612 0 : _asn1_free_top(asn1_ImplementedCompressAlgorithms, data);
613 0 : }
614 :
615 :
616 : int ASN1CALL
617 0 : copy_ImplementedCompressAlgorithms(const ImplementedCompressAlgorithms *from, ImplementedCompressAlgorithms *to)
618 : {
619 0 : return _asn1_copy_top(asn1_ImplementedCompressAlgorithms, from, to);
620 : }
621 :
622 :
623 : char * ASN1CALL
624 0 : print_ImplementedCompressAlgorithms(const ImplementedCompressAlgorithms *data, int flags)
625 : {
626 0 : return _asn1_print_top(asn1_ImplementedCompressAlgorithms, flags, data);
627 : }
628 :
629 : /* template_members: heim_integer exp exp */
630 : /* generate_template_type: heim_integer_tag__15 */
631 : const struct asn1_template asn1_heim_integer_tag__15[] = {
632 : /* 0 */ { 0, sizeof(heim_integer), ((void *)(uintptr_t)0) },
633 : };
634 : /* generate_template_type: HardwareSerialEntry_choice_all */
635 : const struct asn1_template asn1_HardwareSerialEntry_choice_all[] = {
636 : /* 0 */ { 0, sizeof(heim_integer), ((void *)(uintptr_t)1) },
637 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Null), 0, asn1_heim_integer_tag__15 }
638 : };
639 : /* template_members: heim_octet_string exp exp */
640 : /* generate_template_type: heim_octet_string_tag__16 */
641 : /* generate_template_type: HardwareSerialEntry_choice_single */
642 : /* template_members: HardwareSerialEntry_block imp imp */
643 : /* tsequence: members isstruct: 1 */
644 : /* template_members: HardwareSerialEntry_block exp exp */
645 : /* generate_template_type: HardwareSerialEntry_block_tag_low_18 */
646 : /* template_members: HardwareSerialEntry_block exp exp */
647 : /* generate_template_type: HardwareSerialEntry_block_tag_high_19 */
648 : /* generate_template_type: HardwareSerialEntry_block_tag__17 */
649 : const struct asn1_template asn1_HardwareSerialEntry_block_tag__17[] = {
650 : /* 0 */ { 0, sizeof(struct HardwareSerialEntry_block), ((void *)(uintptr_t)5) },
651 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString), offsetof(struct HardwareSerialEntry_block, low), asn1_FirmwarePkgData_tag__0 },
652 : /* 2 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString), offsetof(struct HardwareSerialEntry_block, high), asn1_FirmwarePkgData_tag__0 },
653 : /* 3 */ { A1_OP_NAME, 0, "HardwareSerialEntry_block" },
654 : /* 4 */ { A1_OP_NAME, 0, "low" },
655 : /* 5 */ { A1_OP_NAME, 0, "high" }
656 : };
657 : /* generate_template_type: HardwareSerialEntry_choice_block */
658 : const struct asn1_template asn1_HardwareSerialEntry_choice_block[] = {
659 : /* 0 */ { 0, sizeof(struct HardwareSerialEntry_block), ((void *)(uintptr_t)1) },
660 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_HardwareSerialEntry_block_tag__17 }
661 : };
662 : static const struct asn1_template asn1_choice_HardwareSerialEntry_2[] = {
663 : /* 0 */ { 0, offsetof(HardwareSerialEntry, element), ((void *)(uintptr_t)6) },
664 : /* 1 */ { choice_HardwareSerialEntry_all, offsetof(HardwareSerialEntry, u.all), asn1_HardwareSerialEntry_choice_all },
665 : /* 2 */ { choice_HardwareSerialEntry_single, offsetof(HardwareSerialEntry, u.single), asn1_PreferredOrLegacyPackageIdentifier_choice_legacy },
666 : /* 3 */ { choice_HardwareSerialEntry_block, offsetof(HardwareSerialEntry, u.block), asn1_HardwareSerialEntry_choice_block },
667 : /* 4 */ { 0, 0, "all" },
668 : /* 5 */ { 0, 0, "single" },
669 : /* 6 */ { 0, 0, "block" }
670 : };
671 : /* generate_template_type: HardwareSerialEntry */
672 : const struct asn1_template asn1_HardwareSerialEntry[] = {
673 : /* 0 */ { 0, sizeof(HardwareSerialEntry), ((void *)(uintptr_t)1) },
674 : /* 1 */ { A1_OP_CHOICE, 0, asn1_choice_HardwareSerialEntry_2 }
675 : };
676 :
677 : int ASN1CALL
678 0 : decode_HardwareSerialEntry(const unsigned char *p, size_t len, HardwareSerialEntry *data, size_t *size)
679 : {
680 0 : memset(data, 0, sizeof(*data));
681 0 : return _asn1_decode_top(asn1_HardwareSerialEntry, 0|0, p, len, data, size);
682 : }
683 :
684 :
685 : int ASN1CALL
686 0 : encode_HardwareSerialEntry(unsigned char *p, size_t len, const HardwareSerialEntry *data, size_t *size)
687 : {
688 0 : return _asn1_encode(asn1_HardwareSerialEntry, p, len, data, size);
689 : }
690 :
691 :
692 : size_t ASN1CALL
693 0 : length_HardwareSerialEntry(const HardwareSerialEntry *data)
694 : {
695 0 : return _asn1_length(asn1_HardwareSerialEntry, data);
696 : }
697 :
698 :
699 : void ASN1CALL
700 0 : free_HardwareSerialEntry(HardwareSerialEntry *data)
701 : {
702 0 : _asn1_free_top(asn1_HardwareSerialEntry, data);
703 0 : }
704 :
705 :
706 : int ASN1CALL
707 0 : copy_HardwareSerialEntry(const HardwareSerialEntry *from, HardwareSerialEntry *to)
708 : {
709 0 : return _asn1_copy_top(asn1_HardwareSerialEntry, from, to);
710 : }
711 :
712 :
713 : char * ASN1CALL
714 0 : print_HardwareSerialEntry(const HardwareSerialEntry *data, int flags)
715 : {
716 0 : return _asn1_print_top(asn1_HardwareSerialEntry, flags, data);
717 : }
718 :
719 : /* template_members: HardwareModules imp imp */
720 : /* tsequence: members isstruct: 1 */
721 : /* template_members: HardwareModules exp exp */
722 : /* generate_template_type: HardwareModules_tag_hwType_21 */
723 : /* template_members: HardwareModules exp imp */
724 : /* generate_template_type: HardwareModules_hwSerialEntries_3 */
725 : const struct asn1_template asn1_HardwareModules_hwSerialEntries_3[] = {
726 : /* 0 */ { 0, sizeof(HardwareSerialEntry), ((void *)(uintptr_t)1) },
727 : /* 1 */ { A1_OP_TYPE , 0, asn1_HardwareSerialEntry }
728 : };
729 : /* generate_template_type: HardwareModules_tag_hwSerialEntries_22 */
730 : const struct asn1_template asn1_HardwareModules_tag_hwSerialEntries_22[] = {
731 : /* 0 */ { 0, sizeof(struct HardwareModules_hwSerialEntries), ((void *)(uintptr_t)1) },
732 : /* 1 */ { A1_OP_SEQOF, 0, asn1_HardwareModules_hwSerialEntries_3 }
733 : };
734 : /* generate_template_type: HardwareModules_tag__20 */
735 : const struct asn1_template asn1_HardwareModules_tag__20[] = {
736 : /* 0 */ { 0, sizeof(struct HardwareModules), ((void *)(uintptr_t)5) },
737 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OID), offsetof(struct HardwareModules, hwType), asn1_PreferredPackageIdentifier_tag_fwPkgID_2 },
738 : /* 2 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, offsetof(struct HardwareModules, hwSerialEntries), asn1_HardwareModules_tag_hwSerialEntries_22 },
739 : /* 3 */ { A1_OP_NAME, 0, "HardwareModules" },
740 : /* 4 */ { A1_OP_NAME, 0, "hwType" },
741 : /* 5 */ { A1_OP_NAME, 0, "hwSerialEntries" }
742 : };
743 : /* generate_template_type: HardwareModules */
744 : const struct asn1_template asn1_HardwareModules[] = {
745 : /* 0 */ { 0, sizeof(HardwareModules), ((void *)(uintptr_t)1) },
746 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_HardwareModules_tag__20 }
747 : };
748 :
749 : int ASN1CALL
750 0 : decode_HardwareModules(const unsigned char *p, size_t len, HardwareModules *data, size_t *size)
751 : {
752 0 : memset(data, 0, sizeof(*data));
753 0 : return _asn1_decode_top(asn1_HardwareModules, 0|0, p, len, data, size);
754 : }
755 :
756 :
757 : int ASN1CALL
758 0 : encode_HardwareModules(unsigned char *p, size_t len, const HardwareModules *data, size_t *size)
759 : {
760 0 : return _asn1_encode(asn1_HardwareModules, p, len, data, size);
761 : }
762 :
763 :
764 : size_t ASN1CALL
765 0 : length_HardwareModules(const HardwareModules *data)
766 : {
767 0 : return _asn1_length(asn1_HardwareModules, data);
768 : }
769 :
770 :
771 : void ASN1CALL
772 0 : free_HardwareModules(HardwareModules *data)
773 : {
774 0 : _asn1_free_top(asn1_HardwareModules, data);
775 0 : }
776 :
777 :
778 : int ASN1CALL
779 0 : copy_HardwareModules(const HardwareModules *from, HardwareModules *to)
780 : {
781 0 : return _asn1_copy_top(asn1_HardwareModules, from, to);
782 : }
783 :
784 :
785 : char * ASN1CALL
786 0 : print_HardwareModules(const HardwareModules *data, int flags)
787 : {
788 0 : return _asn1_print_top(asn1_HardwareModules, flags, data);
789 : }
790 :
791 : /* template_members: heim_oid exp exp */
792 : /* generate_template_type: heim_oid_tag__23 */
793 : /* generate_template_type: CommunityIdentifier_choice_communityOID */
794 : /* generate_template_type: CommunityIdentifier_choice_hwModuleList */
795 : const struct asn1_template asn1_CommunityIdentifier_choice_hwModuleList[] = {
796 : /* 0 */ { 0, sizeof(HardwareModules), ((void *)(uintptr_t)1) },
797 : /* 1 */ { A1_OP_TYPE , 0, asn1_HardwareModules }
798 : };
799 : static const struct asn1_template asn1_choice_CommunityIdentifier_3[] = {
800 : /* 0 */ { 0, offsetof(CommunityIdentifier, element), ((void *)(uintptr_t)4) },
801 : /* 1 */ { choice_CommunityIdentifier_communityOID, offsetof(CommunityIdentifier, u.communityOID), asn1_heim_oid_seofTstruct_0 },
802 : /* 2 */ { choice_CommunityIdentifier_hwModuleList, offsetof(CommunityIdentifier, u.hwModuleList), asn1_CommunityIdentifier_choice_hwModuleList },
803 : /* 3 */ { 0, 0, "communityOID" },
804 : /* 4 */ { 0, 0, "hwModuleList" }
805 : };
806 : /* generate_template_type: CommunityIdentifier */
807 : const struct asn1_template asn1_CommunityIdentifier[] = {
808 : /* 0 */ { 0, sizeof(CommunityIdentifier), ((void *)(uintptr_t)1) },
809 : /* 1 */ { A1_OP_CHOICE, 0, asn1_choice_CommunityIdentifier_3 }
810 : };
811 :
812 : int ASN1CALL
813 0 : decode_CommunityIdentifier(const unsigned char *p, size_t len, CommunityIdentifier *data, size_t *size)
814 : {
815 0 : memset(data, 0, sizeof(*data));
816 0 : return _asn1_decode_top(asn1_CommunityIdentifier, 0|0, p, len, data, size);
817 : }
818 :
819 :
820 : int ASN1CALL
821 0 : encode_CommunityIdentifier(unsigned char *p, size_t len, const CommunityIdentifier *data, size_t *size)
822 : {
823 0 : return _asn1_encode(asn1_CommunityIdentifier, p, len, data, size);
824 : }
825 :
826 :
827 : size_t ASN1CALL
828 0 : length_CommunityIdentifier(const CommunityIdentifier *data)
829 : {
830 0 : return _asn1_length(asn1_CommunityIdentifier, data);
831 : }
832 :
833 :
834 : void ASN1CALL
835 0 : free_CommunityIdentifier(CommunityIdentifier *data)
836 : {
837 0 : _asn1_free_top(asn1_CommunityIdentifier, data);
838 0 : }
839 :
840 :
841 : int ASN1CALL
842 0 : copy_CommunityIdentifier(const CommunityIdentifier *from, CommunityIdentifier *to)
843 : {
844 0 : return _asn1_copy_top(asn1_CommunityIdentifier, from, to);
845 : }
846 :
847 :
848 : char * ASN1CALL
849 0 : print_CommunityIdentifier(const CommunityIdentifier *data, int flags)
850 : {
851 0 : return _asn1_print_top(asn1_CommunityIdentifier, flags, data);
852 : }
853 :
854 : /* template_members: CommunityIdentifiers imp imp */
855 : /* generate_template_type: CommunityIdentifier_seofTstruct_4 */
856 : const struct asn1_template asn1_CommunityIdentifier_seofTstruct_4[] = {
857 : /* 0 */ { 0, sizeof(CommunityIdentifier), ((void *)(uintptr_t)1) },
858 : /* 1 */ { A1_OP_TYPE , 0, asn1_CommunityIdentifier }
859 : };
860 : /* generate_template_type: CommunityIdentifiers_tag__24 */
861 : const struct asn1_template asn1_CommunityIdentifiers_tag__24[] = {
862 : /* 0 */ { 0, sizeof(CommunityIdentifier), ((void *)(uintptr_t)1) },
863 : /* 1 */ { A1_OP_SEQOF, 0, asn1_CommunityIdentifier_seofTstruct_4 }
864 : };
865 : /* generate_template_type: CommunityIdentifiers */
866 : const struct asn1_template asn1_CommunityIdentifiers[] = {
867 : /* 0 */ { 0, sizeof(CommunityIdentifiers), ((void *)(uintptr_t)1) },
868 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_CommunityIdentifiers_tag__24 }
869 : };
870 :
871 : int ASN1CALL
872 0 : decode_CommunityIdentifiers(const unsigned char *p, size_t len, CommunityIdentifiers *data, size_t *size)
873 : {
874 0 : memset(data, 0, sizeof(*data));
875 0 : return _asn1_decode_top(asn1_CommunityIdentifiers, 0|0, p, len, data, size);
876 : }
877 :
878 :
879 : int ASN1CALL
880 0 : encode_CommunityIdentifiers(unsigned char *p, size_t len, const CommunityIdentifiers *data, size_t *size)
881 : {
882 0 : return _asn1_encode(asn1_CommunityIdentifiers, p, len, data, size);
883 : }
884 :
885 :
886 : size_t ASN1CALL
887 0 : length_CommunityIdentifiers(const CommunityIdentifiers *data)
888 : {
889 0 : return _asn1_length(asn1_CommunityIdentifiers, data);
890 : }
891 :
892 :
893 : void ASN1CALL
894 0 : free_CommunityIdentifiers(CommunityIdentifiers *data)
895 : {
896 0 : _asn1_free_top(asn1_CommunityIdentifiers, data);
897 0 : }
898 :
899 :
900 : int ASN1CALL
901 0 : copy_CommunityIdentifiers(const CommunityIdentifiers *from, CommunityIdentifiers *to)
902 : {
903 0 : return _asn1_copy_top(asn1_CommunityIdentifiers, from, to);
904 : }
905 :
906 :
907 : char * ASN1CALL
908 0 : print_CommunityIdentifiers(const CommunityIdentifiers *data, int flags)
909 : {
910 0 : return _asn1_print_top(asn1_CommunityIdentifiers, flags, data);
911 : }
912 :
913 : /* template_members: FirmwarePackageInfo imp imp */
914 : /* tsequence: members isstruct: 1 */
915 : /* template_members: FirmwarePackageInfo exp exp */
916 : /* generate_template_type: FirmwarePackageInfo_tag_fwPkgType_26 */
917 : const struct asn1_template asn1_FirmwarePackageInfo_tag_fwPkgType_26[] = {
918 : /* 0 */ { 0, sizeof(heim_integer), ((void *)(uintptr_t)1) },
919 : /* 1 */ { A1_PARSE_T(A1T_HEIM_INTEGER), 0, NULL }
920 : };
921 : /* template_members: FirmwarePackageInfo exp imp */
922 : /* generate_template_type: FirmwarePackageInfo_dependencies_5 */
923 : const struct asn1_template asn1_FirmwarePackageInfo_dependencies_5[] = {
924 : /* 0 */ { 0, sizeof(PreferredOrLegacyPackageIdentifier), ((void *)(uintptr_t)1) },
925 : /* 1 */ { A1_OP_TYPE , 0, asn1_PreferredOrLegacyPackageIdentifier }
926 : };
927 : /* generate_template_type: FirmwarePackageInfo_tag_dependencies_27 */
928 : const struct asn1_template asn1_FirmwarePackageInfo_tag_dependencies_27[] = {
929 : /* 0 */ { 0, sizeof(struct FirmwarePackageInfo_dependencies), ((void *)(uintptr_t)1) },
930 : /* 1 */ { A1_OP_SEQOF, 0, asn1_FirmwarePackageInfo_dependencies_5 }
931 : };
932 : /* generate_template_type: FirmwarePackageInfo_tag__25 */
933 : const struct asn1_template asn1_FirmwarePackageInfo_tag__25[] = {
934 : /* 0 */ { 0, sizeof(struct FirmwarePackageInfo), ((void *)(uintptr_t)5) },
935 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer)|A1_FLAG_OPTIONAL, offsetof(struct FirmwarePackageInfo, fwPkgType), asn1_FirmwarePackageInfo_tag_fwPkgType_26 },
936 : /* 2 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_OPTIONAL|A1_FLAG_IMPLICIT, offsetof(struct FirmwarePackageInfo, dependencies), asn1_FirmwarePackageInfo_tag_dependencies_27 },
937 : /* 3 */ { A1_OP_NAME, 0, "FirmwarePackageInfo" },
938 : /* 4 */ { A1_OP_NAME, 0, "fwPkgType" },
939 : /* 5 */ { A1_OP_NAME, 0, "dependencies" }
940 : };
941 : /* generate_template_type: FirmwarePackageInfo */
942 : const struct asn1_template asn1_FirmwarePackageInfo[] = {
943 : /* 0 */ { 0, sizeof(FirmwarePackageInfo), ((void *)(uintptr_t)1) },
944 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_FirmwarePackageInfo_tag__25 }
945 : };
946 :
947 : int ASN1CALL
948 0 : decode_FirmwarePackageInfo(const unsigned char *p, size_t len, FirmwarePackageInfo *data, size_t *size)
949 : {
950 0 : memset(data, 0, sizeof(*data));
951 0 : return _asn1_decode_top(asn1_FirmwarePackageInfo, 0|0, p, len, data, size);
952 : }
953 :
954 :
955 : int ASN1CALL
956 0 : encode_FirmwarePackageInfo(unsigned char *p, size_t len, const FirmwarePackageInfo *data, size_t *size)
957 : {
958 0 : return _asn1_encode(asn1_FirmwarePackageInfo, p, len, data, size);
959 : }
960 :
961 :
962 : size_t ASN1CALL
963 0 : length_FirmwarePackageInfo(const FirmwarePackageInfo *data)
964 : {
965 0 : return _asn1_length(asn1_FirmwarePackageInfo, data);
966 : }
967 :
968 :
969 : void ASN1CALL
970 0 : free_FirmwarePackageInfo(FirmwarePackageInfo *data)
971 : {
972 0 : _asn1_free_top(asn1_FirmwarePackageInfo, data);
973 0 : }
974 :
975 :
976 : int ASN1CALL
977 0 : copy_FirmwarePackageInfo(const FirmwarePackageInfo *from, FirmwarePackageInfo *to)
978 : {
979 0 : return _asn1_copy_top(asn1_FirmwarePackageInfo, from, to);
980 : }
981 :
982 :
983 : char * ASN1CALL
984 0 : print_FirmwarePackageInfo(const FirmwarePackageInfo *data, int flags)
985 : {
986 0 : return _asn1_print_top(asn1_FirmwarePackageInfo, flags, data);
987 : }
988 :
989 : /* generate_template_type: WrappedFirmwareKey */
990 : const struct asn1_template asn1_WrappedFirmwareKey[] = {
991 : /* 0 */ { 0, sizeof(WrappedFirmwareKey), ((void *)(uintptr_t)1) },
992 : /* 1 */ { A1_OP_TYPE_EXTERN , 0, &asn1_extern_EnvelopedData}
993 : };
994 :
995 : int ASN1CALL
996 0 : decode_WrappedFirmwareKey(const unsigned char *p, size_t len, WrappedFirmwareKey *data, size_t *size)
997 : {
998 0 : memset(data, 0, sizeof(*data));
999 0 : return _asn1_decode_top(asn1_WrappedFirmwareKey, 0|0, p, len, data, size);
1000 : }
1001 :
1002 :
1003 : int ASN1CALL
1004 0 : encode_WrappedFirmwareKey(unsigned char *p, size_t len, const WrappedFirmwareKey *data, size_t *size)
1005 : {
1006 0 : return _asn1_encode(asn1_WrappedFirmwareKey, p, len, data, size);
1007 : }
1008 :
1009 :
1010 : size_t ASN1CALL
1011 0 : length_WrappedFirmwareKey(const WrappedFirmwareKey *data)
1012 : {
1013 0 : return _asn1_length(asn1_WrappedFirmwareKey, data);
1014 : }
1015 :
1016 :
1017 : void ASN1CALL
1018 0 : free_WrappedFirmwareKey(WrappedFirmwareKey *data)
1019 : {
1020 0 : _asn1_free_top(asn1_WrappedFirmwareKey, data);
1021 0 : }
1022 :
1023 :
1024 : int ASN1CALL
1025 0 : copy_WrappedFirmwareKey(const WrappedFirmwareKey *from, WrappedFirmwareKey *to)
1026 : {
1027 0 : return _asn1_copy_top(asn1_WrappedFirmwareKey, from, to);
1028 : }
1029 :
1030 :
1031 : char * ASN1CALL
1032 0 : print_WrappedFirmwareKey(const WrappedFirmwareKey *data, int flags)
1033 : {
1034 0 : return _asn1_print_top(asn1_WrappedFirmwareKey, flags, data);
1035 : }
1036 :
1037 : /* template_members: FWReceiptVersion exp exp */
1038 : const struct asn1_template asn1_FWReceiptVersion_enum_names[] = {
1039 : /* 0 */ { 0, 0, ((void *)(uintptr_t)1) },
1040 : /* 1 */ { A1_OP_NAME, 1, "rfc4108-v1" }
1041 : };
1042 : /* generate_template_type: FWReceiptVersion_tag__28 */
1043 : const struct asn1_template asn1_FWReceiptVersion_tag__28[] = {
1044 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
1045 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_FWReceiptVersion_enum_names }
1046 : };
1047 : /* generate_template_type: FWReceiptVersion */
1048 : const struct asn1_template asn1_FWReceiptVersion[] = {
1049 : /* 0 */ { 0, sizeof(FWReceiptVersion), ((void *)(uintptr_t)1) },
1050 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_FWReceiptVersion_tag__28 }
1051 : };
1052 :
1053 : int ASN1CALL
1054 0 : decode_FWReceiptVersion(const unsigned char *p, size_t len, FWReceiptVersion *data, size_t *size)
1055 : {
1056 0 : memset(data, 0, sizeof(*data));
1057 0 : return _asn1_decode_top(asn1_FWReceiptVersion, 0|0, p, len, data, size);
1058 : }
1059 :
1060 :
1061 : int ASN1CALL
1062 0 : encode_FWReceiptVersion(unsigned char *p, size_t len, const FWReceiptVersion *data, size_t *size)
1063 : {
1064 0 : return _asn1_encode(asn1_FWReceiptVersion, p, len, data, size);
1065 : }
1066 :
1067 :
1068 : size_t ASN1CALL
1069 0 : length_FWReceiptVersion(const FWReceiptVersion *data)
1070 : {
1071 0 : return _asn1_length(asn1_FWReceiptVersion, data);
1072 : }
1073 :
1074 :
1075 : void ASN1CALL
1076 0 : free_FWReceiptVersion(FWReceiptVersion *data)
1077 : {
1078 0 : _asn1_free_top(asn1_FWReceiptVersion, data);
1079 0 : }
1080 :
1081 :
1082 : int ASN1CALL
1083 0 : copy_FWReceiptVersion(const FWReceiptVersion *from, FWReceiptVersion *to)
1084 : {
1085 0 : return _asn1_copy_top(asn1_FWReceiptVersion, from, to);
1086 : }
1087 :
1088 :
1089 : char * ASN1CALL
1090 0 : print_FWReceiptVersion(const FWReceiptVersion *data, int flags)
1091 : {
1092 0 : return _asn1_print_top(asn1_FWReceiptVersion, flags, data);
1093 : }
1094 :
1095 : /* template_members: FirmwarePackageLoadReceipt imp imp */
1096 : /* tsequence: members isstruct: 1 */
1097 : /* template_members: FirmwarePackageLoadReceipt exp exp */
1098 : /* generate_template_type: FirmwarePackageLoadReceipt_tag_hwType_30 */
1099 : /* template_members: FirmwarePackageLoadReceipt exp exp */
1100 : /* generate_template_type: FirmwarePackageLoadReceipt_tag_hwSerialNum_31 */
1101 : /* template_members: FirmwarePackageLoadReceipt exp exp */
1102 : /* generate_template_type: FirmwarePackageLoadReceipt_tag_trustAnchorKeyID_32 */
1103 : /* template_members: FirmwarePackageLoadReceipt exp imp */
1104 : /* template_members: heim_octet_string exp exp */
1105 : /* generate_template_type: heim_octet_string_tag_decryptKeyID_34 */
1106 : /* generate_template_type: FirmwarePackageLoadReceipt_tag_decryptKeyID_33 */
1107 : /* generate_template_type: FirmwarePackageLoadReceipt_tag__29 */
1108 : const struct asn1_template asn1_FirmwarePackageLoadReceipt_tag__29[] = {
1109 : /* 0 */ { 0, sizeof(struct FirmwarePackageLoadReceipt), ((void *)(uintptr_t)14) },
1110 : /* 1 */ { A1_OP_DEFVAL|A1_DV_INTEGER32, ~0, (void *)(uintptr_t)1 },
1111 : /* 2 */ { A1_OP_TYPE |A1_FLAG_DEFAULT, offsetof(struct FirmwarePackageLoadReceipt, version), asn1_FWReceiptVersion },
1112 : /* 3 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OID), offsetof(struct FirmwarePackageLoadReceipt, hwType), asn1_PreferredPackageIdentifier_tag_fwPkgID_2 },
1113 : /* 4 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString), offsetof(struct FirmwarePackageLoadReceipt, hwSerialNum), asn1_FirmwarePkgData_tag__0 },
1114 : /* 5 */ { A1_OP_TYPE , offsetof(struct FirmwarePackageLoadReceipt, fwPkgName), asn1_PreferredOrLegacyPackageIdentifier },
1115 : /* 6 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString)|A1_FLAG_OPTIONAL, offsetof(struct FirmwarePackageLoadReceipt, trustAnchorKeyID), asn1_FirmwarePkgData_tag__0 },
1116 : /* 7 */ { A1_TAG_T(ASN1_C_CONTEXT,PRIM,1)|A1_FLAG_OPTIONAL|A1_FLAG_IMPLICIT, offsetof(struct FirmwarePackageLoadReceipt, decryptKeyID), asn1_PreferredOrLegacyPackageIdentifier_choice_legacy },
1117 : /* 8 */ { A1_OP_NAME, 0, "FirmwarePackageLoadReceipt" },
1118 : /* 9 */ { A1_OP_NAME, 0, "version" },
1119 : /* 10 */ { A1_OP_NAME, 0, "hwType" },
1120 : /* 11 */ { A1_OP_NAME, 0, "hwSerialNum" },
1121 : /* 12 */ { A1_OP_NAME, 0, "fwPkgName" },
1122 : /* 13 */ { A1_OP_NAME, 0, "trustAnchorKeyID" },
1123 : /* 14 */ { A1_OP_NAME, 0, "decryptKeyID" }
1124 : };
1125 : /* generate_template_type: FirmwarePackageLoadReceipt */
1126 : const struct asn1_template asn1_FirmwarePackageLoadReceipt[] = {
1127 : /* 0 */ { 0, sizeof(FirmwarePackageLoadReceipt), ((void *)(uintptr_t)1) },
1128 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_FirmwarePackageLoadReceipt_tag__29 }
1129 : };
1130 :
1131 : int ASN1CALL
1132 0 : decode_FirmwarePackageLoadReceipt(const unsigned char *p, size_t len, FirmwarePackageLoadReceipt *data, size_t *size)
1133 : {
1134 0 : memset(data, 0, sizeof(*data));
1135 0 : return _asn1_decode_top(asn1_FirmwarePackageLoadReceipt, 0|0, p, len, data, size);
1136 : }
1137 :
1138 :
1139 : int ASN1CALL
1140 0 : encode_FirmwarePackageLoadReceipt(unsigned char *p, size_t len, const FirmwarePackageLoadReceipt *data, size_t *size)
1141 : {
1142 0 : return _asn1_encode(asn1_FirmwarePackageLoadReceipt, p, len, data, size);
1143 : }
1144 :
1145 :
1146 : size_t ASN1CALL
1147 0 : length_FirmwarePackageLoadReceipt(const FirmwarePackageLoadReceipt *data)
1148 : {
1149 0 : return _asn1_length(asn1_FirmwarePackageLoadReceipt, data);
1150 : }
1151 :
1152 :
1153 : void ASN1CALL
1154 0 : free_FirmwarePackageLoadReceipt(FirmwarePackageLoadReceipt *data)
1155 : {
1156 0 : _asn1_free_top(asn1_FirmwarePackageLoadReceipt, data);
1157 0 : }
1158 :
1159 :
1160 : int ASN1CALL
1161 0 : copy_FirmwarePackageLoadReceipt(const FirmwarePackageLoadReceipt *from, FirmwarePackageLoadReceipt *to)
1162 : {
1163 0 : return _asn1_copy_top(asn1_FirmwarePackageLoadReceipt, from, to);
1164 : }
1165 :
1166 :
1167 : char * ASN1CALL
1168 0 : print_FirmwarePackageLoadReceipt(const FirmwarePackageLoadReceipt *data, int flags)
1169 : {
1170 0 : return _asn1_print_top(asn1_FirmwarePackageLoadReceipt, flags, data);
1171 : }
1172 :
1173 : /* generate_template_type: FWErrorVersion */
1174 : const struct asn1_template asn1_FWErrorVersion[] = {
1175 : /* 0 */ { 0, sizeof(FWErrorVersion), ((void *)(uintptr_t)1) },
1176 : /* 1 */ { A1_OP_TYPE , 0, asn1_FWReceiptVersion }
1177 : };
1178 :
1179 : int ASN1CALL
1180 0 : decode_FWErrorVersion(const unsigned char *p, size_t len, FWErrorVersion *data, size_t *size)
1181 : {
1182 0 : memset(data, 0, sizeof(*data));
1183 0 : return _asn1_decode_top(asn1_FWErrorVersion, 0|0, p, len, data, size);
1184 : }
1185 :
1186 :
1187 : int ASN1CALL
1188 0 : encode_FWErrorVersion(unsigned char *p, size_t len, const FWErrorVersion *data, size_t *size)
1189 : {
1190 0 : return _asn1_encode(asn1_FWErrorVersion, p, len, data, size);
1191 : }
1192 :
1193 :
1194 : size_t ASN1CALL
1195 0 : length_FWErrorVersion(const FWErrorVersion *data)
1196 : {
1197 0 : return _asn1_length(asn1_FWErrorVersion, data);
1198 : }
1199 :
1200 :
1201 : void ASN1CALL
1202 0 : free_FWErrorVersion(FWErrorVersion *data)
1203 : {
1204 0 : _asn1_free_top(asn1_FWErrorVersion, data);
1205 0 : }
1206 :
1207 :
1208 : int ASN1CALL
1209 0 : copy_FWErrorVersion(const FWErrorVersion *from, FWErrorVersion *to)
1210 : {
1211 0 : return _asn1_copy_top(asn1_FWErrorVersion, from, to);
1212 : }
1213 :
1214 :
1215 : char * ASN1CALL
1216 0 : print_FWErrorVersion(const FWErrorVersion *data, int flags)
1217 : {
1218 0 : return _asn1_print_top(asn1_FWErrorVersion, flags, data);
1219 : }
1220 :
1221 : /* template_members: FirmwarePackageLoadErrorCode exp exp */
1222 : const struct asn1_template asn1_FirmwarePackageLoadErrorCode_enum_names[] = {
1223 : /* 0 */ { 0, 0, ((void *)(uintptr_t)37) },
1224 : /* 1 */ { A1_OP_NAME, 1, "decodeFailure" },
1225 : /* 2 */ { A1_OP_NAME, 2, "badContentInfo" },
1226 : /* 3 */ { A1_OP_NAME, 3, "badSignedData" },
1227 : /* 4 */ { A1_OP_NAME, 4, "badEncapContent" },
1228 : /* 5 */ { A1_OP_NAME, 5, "badCertificate" },
1229 : /* 6 */ { A1_OP_NAME, 6, "badSignerInfo" },
1230 : /* 7 */ { A1_OP_NAME, 7, "badSignedAttrs" },
1231 : /* 8 */ { A1_OP_NAME, 8, "badUnsignedAttrs" },
1232 : /* 9 */ { A1_OP_NAME, 9, "missingContent" },
1233 : /* 10 */ { A1_OP_NAME, 10, "noTrustAnchor" },
1234 : /* 11 */ { A1_OP_NAME, 11, "notAuthorized" },
1235 : /* 12 */ { A1_OP_NAME, 12, "badDigestAlgorithm" },
1236 : /* 13 */ { A1_OP_NAME, 13, "badSignatureAlgorithm" },
1237 : /* 14 */ { A1_OP_NAME, 14, "unsupportedKeySize" },
1238 : /* 15 */ { A1_OP_NAME, 15, "signatureFailure" },
1239 : /* 16 */ { A1_OP_NAME, 16, "contentTypeMismatch" },
1240 : /* 17 */ { A1_OP_NAME, 17, "badEncryptedData" },
1241 : /* 18 */ { A1_OP_NAME, 18, "unprotectedAttrsPresent" },
1242 : /* 19 */ { A1_OP_NAME, 19, "badEncryptContent" },
1243 : /* 20 */ { A1_OP_NAME, 20, "badEncryptAlgorithm" },
1244 : /* 21 */ { A1_OP_NAME, 21, "missingCiphertext" },
1245 : /* 22 */ { A1_OP_NAME, 22, "noDecryptKey" },
1246 : /* 23 */ { A1_OP_NAME, 23, "decryptFailure" },
1247 : /* 24 */ { A1_OP_NAME, 24, "badCompressAlgorithm" },
1248 : /* 25 */ { A1_OP_NAME, 25, "missingCompressedContent" },
1249 : /* 26 */ { A1_OP_NAME, 26, "decompressFailure" },
1250 : /* 27 */ { A1_OP_NAME, 27, "wrongHardware" },
1251 : /* 28 */ { A1_OP_NAME, 28, "stalePackage" },
1252 : /* 29 */ { A1_OP_NAME, 29, "notInCommunity" },
1253 : /* 30 */ { A1_OP_NAME, 30, "unsupportedPackageType" },
1254 : /* 31 */ { A1_OP_NAME, 31, "missingDependency" },
1255 : /* 32 */ { A1_OP_NAME, 32, "wrongDependencyVersion" },
1256 : /* 33 */ { A1_OP_NAME, 33, "insufficientMemory" },
1257 : /* 34 */ { A1_OP_NAME, 34, "badFirmware" },
1258 : /* 35 */ { A1_OP_NAME, 35, "unsupportedParameters" },
1259 : /* 36 */ { A1_OP_NAME, 36, "breaksDependency" },
1260 : /* 37 */ { A1_OP_NAME, 99, "otherError" }
1261 : };
1262 : /* generate_template_type: FirmwarePackageLoadErrorCode_tag__35 */
1263 : const struct asn1_template asn1_FirmwarePackageLoadErrorCode_tag__35[] = {
1264 : /* 0 */ { 0, sizeof(int), ((void *)(uintptr_t)1) },
1265 : /* 1 */ { A1_PARSE_T(A1T_IMEMBER), 0, asn1_FirmwarePackageLoadErrorCode_enum_names }
1266 : };
1267 : /* generate_template_type: FirmwarePackageLoadErrorCode */
1268 : const struct asn1_template asn1_FirmwarePackageLoadErrorCode[] = {
1269 : /* 0 */ { 0, sizeof(FirmwarePackageLoadErrorCode), ((void *)(uintptr_t)1) },
1270 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Enumerated), 0, asn1_FirmwarePackageLoadErrorCode_tag__35 }
1271 : };
1272 :
1273 : int ASN1CALL
1274 0 : decode_FirmwarePackageLoadErrorCode(const unsigned char *p, size_t len, FirmwarePackageLoadErrorCode *data, size_t *size)
1275 : {
1276 0 : memset(data, 0, sizeof(*data));
1277 0 : return _asn1_decode_top(asn1_FirmwarePackageLoadErrorCode, 0|0, p, len, data, size);
1278 : }
1279 :
1280 :
1281 : int ASN1CALL
1282 0 : encode_FirmwarePackageLoadErrorCode(unsigned char *p, size_t len, const FirmwarePackageLoadErrorCode *data, size_t *size)
1283 : {
1284 0 : return _asn1_encode(asn1_FirmwarePackageLoadErrorCode, p, len, data, size);
1285 : }
1286 :
1287 :
1288 : size_t ASN1CALL
1289 0 : length_FirmwarePackageLoadErrorCode(const FirmwarePackageLoadErrorCode *data)
1290 : {
1291 0 : return _asn1_length(asn1_FirmwarePackageLoadErrorCode, data);
1292 : }
1293 :
1294 :
1295 : void ASN1CALL
1296 0 : free_FirmwarePackageLoadErrorCode(FirmwarePackageLoadErrorCode *data)
1297 : {
1298 0 : _asn1_free_top(asn1_FirmwarePackageLoadErrorCode, data);
1299 0 : }
1300 :
1301 :
1302 : int ASN1CALL
1303 0 : copy_FirmwarePackageLoadErrorCode(const FirmwarePackageLoadErrorCode *from, FirmwarePackageLoadErrorCode *to)
1304 : {
1305 0 : return _asn1_copy_top(asn1_FirmwarePackageLoadErrorCode, from, to);
1306 : }
1307 :
1308 :
1309 : char * ASN1CALL
1310 0 : print_FirmwarePackageLoadErrorCode(const FirmwarePackageLoadErrorCode *data, int flags)
1311 : {
1312 0 : return _asn1_print_top(asn1_FirmwarePackageLoadErrorCode, flags, data);
1313 : }
1314 :
1315 : /* template_members: VendorLoadErrorCode exp exp */
1316 : /* generate_template_type: VendorLoadErrorCode_tag__36 */
1317 : /* generate_template_type: VendorLoadErrorCode */
1318 : const struct asn1_template asn1_VendorLoadErrorCode[] = {
1319 : /* 0 */ { 0, sizeof(VendorLoadErrorCode), ((void *)(uintptr_t)1) },
1320 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer), 0, asn1_FirmwarePackageInfo_tag_fwPkgType_26 }
1321 : };
1322 :
1323 : int ASN1CALL
1324 0 : decode_VendorLoadErrorCode(const unsigned char *p, size_t len, VendorLoadErrorCode *data, size_t *size)
1325 : {
1326 0 : memset(data, 0, sizeof(*data));
1327 0 : return _asn1_decode_top(asn1_VendorLoadErrorCode, 0|0, p, len, data, size);
1328 : }
1329 :
1330 :
1331 : int ASN1CALL
1332 0 : encode_VendorLoadErrorCode(unsigned char *p, size_t len, const VendorLoadErrorCode *data, size_t *size)
1333 : {
1334 0 : return _asn1_encode(asn1_VendorLoadErrorCode, p, len, data, size);
1335 : }
1336 :
1337 :
1338 : size_t ASN1CALL
1339 0 : length_VendorLoadErrorCode(const VendorLoadErrorCode *data)
1340 : {
1341 0 : return _asn1_length(asn1_VendorLoadErrorCode, data);
1342 : }
1343 :
1344 :
1345 : void ASN1CALL
1346 0 : free_VendorLoadErrorCode(VendorLoadErrorCode *data)
1347 : {
1348 0 : _asn1_free_top(asn1_VendorLoadErrorCode, data);
1349 0 : }
1350 :
1351 :
1352 : int ASN1CALL
1353 0 : copy_VendorLoadErrorCode(const VendorLoadErrorCode *from, VendorLoadErrorCode *to)
1354 : {
1355 0 : return _asn1_copy_top(asn1_VendorLoadErrorCode, from, to);
1356 : }
1357 :
1358 :
1359 : char * ASN1CALL
1360 0 : print_VendorLoadErrorCode(const VendorLoadErrorCode *data, int flags)
1361 : {
1362 0 : return _asn1_print_top(asn1_VendorLoadErrorCode, flags, data);
1363 : }
1364 :
1365 : /* template_members: CurrentFWConfig imp imp */
1366 : /* tsequence: members isstruct: 1 */
1367 : /* template_members: CurrentFWConfig exp exp */
1368 : /* generate_template_type: CurrentFWConfig_tag_fwPkgType_38 */
1369 : /* generate_template_type: CurrentFWConfig_tag__37 */
1370 : const struct asn1_template asn1_CurrentFWConfig_tag__37[] = {
1371 : /* 0 */ { 0, sizeof(struct CurrentFWConfig), ((void *)(uintptr_t)5) },
1372 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_Integer)|A1_FLAG_OPTIONAL, offsetof(struct CurrentFWConfig, fwPkgType), asn1_FirmwarePackageInfo_tag_fwPkgType_26 },
1373 : /* 2 */ { A1_OP_TYPE , offsetof(struct CurrentFWConfig, fwPkgName), asn1_PreferredOrLegacyPackageIdentifier },
1374 : /* 3 */ { A1_OP_NAME, 0, "CurrentFWConfig" },
1375 : /* 4 */ { A1_OP_NAME, 0, "fwPkgType" },
1376 : /* 5 */ { A1_OP_NAME, 0, "fwPkgName" }
1377 : };
1378 : /* generate_template_type: CurrentFWConfig */
1379 : const struct asn1_template asn1_CurrentFWConfig[] = {
1380 : /* 0 */ { 0, sizeof(CurrentFWConfig), ((void *)(uintptr_t)1) },
1381 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_CurrentFWConfig_tag__37 }
1382 : };
1383 :
1384 : int ASN1CALL
1385 0 : decode_CurrentFWConfig(const unsigned char *p, size_t len, CurrentFWConfig *data, size_t *size)
1386 : {
1387 0 : memset(data, 0, sizeof(*data));
1388 0 : return _asn1_decode_top(asn1_CurrentFWConfig, 0|0, p, len, data, size);
1389 : }
1390 :
1391 :
1392 : int ASN1CALL
1393 0 : encode_CurrentFWConfig(unsigned char *p, size_t len, const CurrentFWConfig *data, size_t *size)
1394 : {
1395 0 : return _asn1_encode(asn1_CurrentFWConfig, p, len, data, size);
1396 : }
1397 :
1398 :
1399 : size_t ASN1CALL
1400 0 : length_CurrentFWConfig(const CurrentFWConfig *data)
1401 : {
1402 0 : return _asn1_length(asn1_CurrentFWConfig, data);
1403 : }
1404 :
1405 :
1406 : void ASN1CALL
1407 0 : free_CurrentFWConfig(CurrentFWConfig *data)
1408 : {
1409 0 : _asn1_free_top(asn1_CurrentFWConfig, data);
1410 0 : }
1411 :
1412 :
1413 : int ASN1CALL
1414 0 : copy_CurrentFWConfig(const CurrentFWConfig *from, CurrentFWConfig *to)
1415 : {
1416 0 : return _asn1_copy_top(asn1_CurrentFWConfig, from, to);
1417 : }
1418 :
1419 :
1420 : char * ASN1CALL
1421 0 : print_CurrentFWConfig(const CurrentFWConfig *data, int flags)
1422 : {
1423 0 : return _asn1_print_top(asn1_CurrentFWConfig, flags, data);
1424 : }
1425 :
1426 : /* template_members: FirmwarePackageLoadError imp imp */
1427 : /* tsequence: members isstruct: 1 */
1428 : /* template_members: FirmwarePackageLoadError exp exp */
1429 : /* generate_template_type: FirmwarePackageLoadError_tag_hwType_40 */
1430 : /* template_members: FirmwarePackageLoadError exp exp */
1431 : /* generate_template_type: FirmwarePackageLoadError_tag_hwSerialNum_41 */
1432 : /* template_members: FirmwarePackageLoadError exp imp */
1433 : /* template_members: FirmwarePackageLoadError imp imp */
1434 : /* generate_template_type: FirmwarePackageLoadError_config_6 */
1435 : const struct asn1_template asn1_FirmwarePackageLoadError_config_6[] = {
1436 : /* 0 */ { 0, sizeof(CurrentFWConfig), ((void *)(uintptr_t)1) },
1437 : /* 1 */ { A1_OP_TYPE , 0, asn1_CurrentFWConfig }
1438 : };
1439 : /* generate_template_type: FirmwarePackageLoadError_tag_config_43 */
1440 : const struct asn1_template asn1_FirmwarePackageLoadError_tag_config_43[] = {
1441 : /* 0 */ { 0, sizeof(struct FirmwarePackageLoadError_config), ((void *)(uintptr_t)1) },
1442 : /* 1 */ { A1_OP_SEQOF, 0, asn1_FirmwarePackageLoadError_config_6 }
1443 : };
1444 : /* generate_template_type: FirmwarePackageLoadError_tag_config_42 */
1445 : const struct asn1_template asn1_FirmwarePackageLoadError_tag_config_42[] = {
1446 : /* 0 */ { 0, sizeof(struct FirmwarePackageLoadError_config), ((void *)(uintptr_t)1) },
1447 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_FirmwarePackageLoadError_tag_config_43 }
1448 : };
1449 : /* generate_template_type: FirmwarePackageLoadError_tag__39 */
1450 : const struct asn1_template asn1_FirmwarePackageLoadError_tag__39[] = {
1451 : /* 0 */ { 0, sizeof(struct FirmwarePackageLoadError), ((void *)(uintptr_t)16) },
1452 : /* 1 */ { A1_OP_DEFVAL|A1_DV_INTEGER32, ~0, (void *)(uintptr_t)1 },
1453 : /* 2 */ { A1_OP_TYPE |A1_FLAG_DEFAULT, offsetof(struct FirmwarePackageLoadError, version), asn1_FWErrorVersion },
1454 : /* 3 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OID), offsetof(struct FirmwarePackageLoadError, hwType), asn1_PreferredPackageIdentifier_tag_fwPkgID_2 },
1455 : /* 4 */ { A1_TAG_T(ASN1_C_UNIV,PRIM,UT_OctetString), offsetof(struct FirmwarePackageLoadError, hwSerialNum), asn1_FirmwarePkgData_tag__0 },
1456 : /* 5 */ { A1_OP_TYPE , offsetof(struct FirmwarePackageLoadError, errorCode), asn1_FirmwarePackageLoadErrorCode },
1457 : /* 6 */ { A1_OP_TYPE |A1_FLAG_OPTIONAL, offsetof(struct FirmwarePackageLoadError, vendorErrorCode), asn1_VendorLoadErrorCode },
1458 : /* 7 */ { A1_OP_TYPE |A1_FLAG_OPTIONAL, offsetof(struct FirmwarePackageLoadError, fwPkgName), asn1_PreferredOrLegacyPackageIdentifier },
1459 : /* 8 */ { A1_TAG_T(ASN1_C_CONTEXT,CONS,1)|A1_FLAG_OPTIONAL|A1_FLAG_IMPLICIT, offsetof(struct FirmwarePackageLoadError, config), asn1_FirmwarePackageLoadError_tag_config_42 },
1460 : /* 9 */ { A1_OP_NAME, 0, "FirmwarePackageLoadError" },
1461 : /* 10 */ { A1_OP_NAME, 0, "version" },
1462 : /* 11 */ { A1_OP_NAME, 0, "hwType" },
1463 : /* 12 */ { A1_OP_NAME, 0, "hwSerialNum" },
1464 : /* 13 */ { A1_OP_NAME, 0, "errorCode" },
1465 : /* 14 */ { A1_OP_NAME, 0, "vendorErrorCode" },
1466 : /* 15 */ { A1_OP_NAME, 0, "fwPkgName" },
1467 : /* 16 */ { A1_OP_NAME, 0, "config" }
1468 : };
1469 : /* generate_template_type: FirmwarePackageLoadError */
1470 : const struct asn1_template asn1_FirmwarePackageLoadError[] = {
1471 : /* 0 */ { 0, sizeof(FirmwarePackageLoadError), ((void *)(uintptr_t)1) },
1472 : /* 1 */ { A1_TAG_T(ASN1_C_UNIV,CONS,UT_Sequence)|A1_FLAG_IMPLICIT, 0, asn1_FirmwarePackageLoadError_tag__39 }
1473 : };
1474 :
1475 : int ASN1CALL
1476 0 : decode_FirmwarePackageLoadError(const unsigned char *p, size_t len, FirmwarePackageLoadError *data, size_t *size)
1477 : {
1478 0 : memset(data, 0, sizeof(*data));
1479 0 : return _asn1_decode_top(asn1_FirmwarePackageLoadError, 0|0, p, len, data, size);
1480 : }
1481 :
1482 :
1483 : int ASN1CALL
1484 0 : encode_FirmwarePackageLoadError(unsigned char *p, size_t len, const FirmwarePackageLoadError *data, size_t *size)
1485 : {
1486 0 : return _asn1_encode(asn1_FirmwarePackageLoadError, p, len, data, size);
1487 : }
1488 :
1489 :
1490 : size_t ASN1CALL
1491 0 : length_FirmwarePackageLoadError(const FirmwarePackageLoadError *data)
1492 : {
1493 0 : return _asn1_length(asn1_FirmwarePackageLoadError, data);
1494 : }
1495 :
1496 :
1497 : void ASN1CALL
1498 0 : free_FirmwarePackageLoadError(FirmwarePackageLoadError *data)
1499 : {
1500 0 : _asn1_free_top(asn1_FirmwarePackageLoadError, data);
1501 0 : }
1502 :
1503 :
1504 : int ASN1CALL
1505 0 : copy_FirmwarePackageLoadError(const FirmwarePackageLoadError *from, FirmwarePackageLoadError *to)
1506 : {
1507 0 : return _asn1_copy_top(asn1_FirmwarePackageLoadError, from, to);
1508 : }
1509 :
1510 :
1511 : char * ASN1CALL
1512 0 : print_FirmwarePackageLoadError(const FirmwarePackageLoadError *data, int flags)
1513 : {
1514 0 : return _asn1_print_top(asn1_FirmwarePackageLoadError, flags, data);
1515 : }
1516 :
|
