1/* Generated from cms.asn1 */
2/* Do not edit */
3
4#define ASN1_LIB
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <time.h>
9#include <string.h>
10#include <errno.h>
11#include <limits.h>
12#include <krb5/krb5-types.h>
13#include "cms_asn1.h"
14#include "cms_asn1-priv.h"
15#include <krb5/asn1_err.h>
16#include <krb5/der.h>
17#include <asn1-template.h>
18
19#include <krb5/parse_units.h>
20
21static unsigned oid_id_pkcs7_variable_num[6] = {1, 2, 840, 113549, 1, 7 };
22const heim_oid asn1_oid_id_pkcs7 = { 6, oid_id_pkcs7_variable_num };
23
24static unsigned oid_id_pkcs7_data_variable_num[7] = {1, 2, 840, 113549, 1, 7, 1 };
25const heim_oid asn1_oid_id_pkcs7_data = { 7, oid_id_pkcs7_data_variable_num };
26
27static unsigned oid_id_pkcs7_signedData_variable_num[7] = {1, 2, 840, 113549, 1, 7, 2 };
28const heim_oid asn1_oid_id_pkcs7_signedData = { 7, oid_id_pkcs7_signedData_variable_num };
29
30static unsigned oid_id_pkcs7_envelopedData_variable_num[7] = {1, 2, 840, 113549, 1, 7, 3 };
31const heim_oid asn1_oid_id_pkcs7_envelopedData = { 7, oid_id_pkcs7_envelopedData_variable_num };
32
33static unsigned oid_id_pkcs7_signedAndEnvelopedData_variable_num[7] = {1, 2, 840, 113549, 1, 7, 4 };
34const heim_oid asn1_oid_id_pkcs7_signedAndEnvelopedData = { 7, oid_id_pkcs7_signedAndEnvelopedData_variable_num };
35
36static unsigned oid_id_pkcs7_digestedData_variable_num[7] = {1, 2, 840, 113549, 1, 7, 5 };
37const heim_oid asn1_oid_id_pkcs7_digestedData = { 7, oid_id_pkcs7_digestedData_variable_num };
38
39static unsigned oid_id_pkcs7_encryptedData_variable_num[7] = {1, 2, 840, 113549, 1, 7, 6 };
40const heim_oid asn1_oid_id_pkcs7_encryptedData = { 7, oid_id_pkcs7_encryptedData_variable_num };
41
42int ASN1CALL
43encode_CMSVersion(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CMSVersion *data, size_t *size)
44{
45size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
46size_t l HEIMDAL_UNUSED_ATTRIBUTE;
47int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
48
49{
50int enumint = (int)*data;
51e = der_put_integer(p, len, &enumint, &l);
52if (e) return e;
53p -= l; len -= l; ret += l;
54
55}
56;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
57if (e) return e;
58p -= l; len -= l; ret += l;
59
60*size = ret;
61return 0;
62}
63
64int ASN1CALL
65decode_CMSVersion(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CMSVersion *data, size_t *size)
66{
67size_t ret = 0;
68size_t l HEIMDAL_UNUSED_ATTRIBUTE;
69int e HEIMDAL_UNUSED_ATTRIBUTE;
70
71memset(data, 0, sizeof(*data));
72{
73size_t Top_datalen, Top_oldlen;
74Der_type Top_type;
75int is_indefinite1;
76e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
77if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
78if(e) goto fail;
79p += l; len -= l; ret += l;
80Top_oldlen = len;
81if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
82{ e = ASN1_BAD_FORMAT; goto fail; }
83if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
84int enumint;
85e = der_get_integer(p, len, &enumint, &l);
86if(e) goto fail;
87p += l; len -= l; ret += l;
88*data = enumint;
89}
90if(is_indefinite1){
91len += 2;
92e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
93if(e) goto fail;
94p += l; len -= l; ret += l;
95if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
96} else
97len = Top_oldlen - Top_datalen;
98}
99if(size) *size = ret;
100return 0;
101fail:
102free_CMSVersion(data);
103return e;
104}
105
106void ASN1CALL
107free_CMSVersion(CMSVersion *data)
108{
109}
110
111size_t ASN1CALL
112length_CMSVersion(const CMSVersion *data)
113{
114size_t ret = 0;
115{
116int enumint = *data;
117ret += der_length_integer(&enumint);
118}
119ret += 1 + der_length_len (ret);
120return ret;
121}
122
123int ASN1CALL
124copy_CMSVersion(const CMSVersion *from, CMSVersion *to)
125{
126memset(to, 0, sizeof(*to));
127*(to) = *(from);
128return 0;
129}
130
131int ASN1CALL
132encode_DigestAlgorithmIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestAlgorithmIdentifier *data, size_t *size)
133{
134size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
135size_t l HEIMDAL_UNUSED_ATTRIBUTE;
136int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
137
138e = encode_AlgorithmIdentifier(p, len, data, &l);
139if (e) return e;
140p -= l; len -= l; ret += l;
141
142*size = ret;
143return 0;
144}
145
146int ASN1CALL
147decode_DigestAlgorithmIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestAlgorithmIdentifier *data, size_t *size)
148{
149size_t ret = 0;
150size_t l HEIMDAL_UNUSED_ATTRIBUTE;
151int e HEIMDAL_UNUSED_ATTRIBUTE;
152
153memset(data, 0, sizeof(*data));
154e = decode_AlgorithmIdentifier(p, len, data, &l);
155if(e) goto fail;
156p += l; len -= l; ret += l;
157if(size) *size = ret;
158return 0;
159fail:
160free_DigestAlgorithmIdentifier(data);
161return e;
162}
163
164void ASN1CALL
165free_DigestAlgorithmIdentifier(DigestAlgorithmIdentifier *data)
166{
167free_AlgorithmIdentifier(data);
168}
169
170size_t ASN1CALL
171length_DigestAlgorithmIdentifier(const DigestAlgorithmIdentifier *data)
172{
173size_t ret = 0;
174ret += length_AlgorithmIdentifier(data);
175return ret;
176}
177
178int ASN1CALL
179copy_DigestAlgorithmIdentifier(const DigestAlgorithmIdentifier *from, DigestAlgorithmIdentifier *to)
180{
181memset(to, 0, sizeof(*to));
182if(copy_AlgorithmIdentifier(from, to)) goto fail;
183return 0;
184fail:
185free_DigestAlgorithmIdentifier(to);
186return ENOMEM;
187}
188
189int ASN1CALL
190encode_DigestAlgorithmIdentifiers(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestAlgorithmIdentifiers *data, size_t *size)
191{
192size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
193size_t l HEIMDAL_UNUSED_ATTRIBUTE;
194int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
195
196{
197heim_octet_string *val;
198size_t elen = 0, totallen = 0;
199int eret = 0;
200if ((data)->len > UINT_MAX/sizeof(val[0]))
201return ERANGE;
202val = malloc(sizeof(val[0]) * (data)->len);
203if (val == NULL && (data)->len != 0) return ENOMEM;
204for(i = 0; i < (int)(data)->len; i++) {
205ASN1_MALLOC_ENCODE(DigestAlgorithmIdentifier, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
206if(eret) {
207i--;
208while (i >= 0) {
209free(val[i].data);
210i--;
211}
212free(val);
213return eret;
214}
215totallen += elen;
216}
217if (totallen > len) {
218for (i = 0; i < (int)(data)->len; i++) {
219free(val[i].data);
220}
221free(val);
222return ASN1_OVERFLOW;
223}
224qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
225for(i = (int)(data)->len - 1; i >= 0; --i) {
226p -= val[i].length;
227ret += val[i].length;
228memcpy(p + 1, val[i].data, val[i].length);
229free(val[i].data);
230}
231free(val);
232}
233e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
234if (e) return e;
235p -= l; len -= l; ret += l;
236
237*size = ret;
238return 0;
239}
240
241int ASN1CALL
242decode_DigestAlgorithmIdentifiers(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestAlgorithmIdentifiers *data, size_t *size)
243{
244size_t ret = 0;
245size_t l HEIMDAL_UNUSED_ATTRIBUTE;
246int e HEIMDAL_UNUSED_ATTRIBUTE;
247
248memset(data, 0, sizeof(*data));
249{
250size_t Top_datalen, Top_oldlen;
251Der_type Top_type;
252int is_indefinite1;
253e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
254if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
255if(e) goto fail;
256p += l; len -= l; ret += l;
257Top_oldlen = len;
258if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
259{ e = ASN1_BAD_FORMAT; goto fail; }
260if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
261size_t Top_Tag_origlen = len;
262size_t Top_Tag_oldret = ret;
263size_t Top_Tag_olen = 0;
264void *Top_Tag_tmp;
265ret = 0;
266(data)->len = 0;
267(data)->val = NULL;
268while(ret < Top_Tag_origlen) {
269size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
270if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
271Top_Tag_olen = Top_Tag_nlen;
272Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
273if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
274(data)->val = Top_Tag_tmp;
275e = decode_DigestAlgorithmIdentifier(p, len, &(data)->val[(data)->len], &l);
276if(e) goto fail;
277p += l; len -= l; ret += l;
278(data)->len++;
279len = Top_Tag_origlen - ret;
280}
281ret += Top_Tag_oldret;
282}
283if(is_indefinite1){
284len += 2;
285e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
286if(e) goto fail;
287p += l; len -= l; ret += l;
288if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
289} else
290len = Top_oldlen - Top_datalen;
291}
292if(size) *size = ret;
293return 0;
294fail:
295free_DigestAlgorithmIdentifiers(data);
296return e;
297}
298
299void ASN1CALL
300free_DigestAlgorithmIdentifiers(DigestAlgorithmIdentifiers *data)
301{
302while((data)->len){
303free_DigestAlgorithmIdentifier(&(data)->val[(data)->len-1]);
304(data)->len--;
305}
306free((data)->val);
307(data)->val = NULL;
308}
309
310size_t ASN1CALL
311length_DigestAlgorithmIdentifiers(const DigestAlgorithmIdentifiers *data)
312{
313size_t ret = 0;
314{
315size_t Top_tag_oldret = ret;
316unsigned int n_Top_tag;
317ret = 0;
318for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
319size_t Top_tag_for_oldret = ret;
320ret = 0;
321ret += length_DigestAlgorithmIdentifier(&(data)->val[n_Top_tag - 1]);
322ret += Top_tag_for_oldret;
323}
324ret += Top_tag_oldret;
325}
326ret += 1 + der_length_len (ret);
327return ret;
328}
329
330int ASN1CALL
331copy_DigestAlgorithmIdentifiers(const DigestAlgorithmIdentifiers *from, DigestAlgorithmIdentifiers *to)
332{
333memset(to, 0, sizeof(*to));
334if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
335goto fail;
336for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
337if(copy_DigestAlgorithmIdentifier(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
338}
339return 0;
340fail:
341free_DigestAlgorithmIdentifiers(to);
342return ENOMEM;
343}
344
345int ASN1CALL
346add_DigestAlgorithmIdentifiers(DigestAlgorithmIdentifiers *data, const DigestAlgorithmIdentifier *element)
347{
348int ret;
349void *ptr;
350
351ptr = realloc(data->val,
352 (data->len + 1) * sizeof(data->val[0]));
353if (ptr == NULL) return ENOMEM;
354data->val = ptr;
355
356ret = copy_DigestAlgorithmIdentifier(element, &data->val[data->len]);
357if (ret) return ret;
358data->len++;
359return 0;
360}
361
362int ASN1CALL
363remove_DigestAlgorithmIdentifiers(DigestAlgorithmIdentifiers *data, unsigned int element)
364{
365void *ptr;
366
367if (data->len == 0 || element >= data->len)
368 return ASN1_OVERRUN;
369free_DigestAlgorithmIdentifier(&data->val[element]);
370data->len--;
371if (element < data->len)
372 memmove(&data->val[element], &data->val[element + 1],
373 sizeof(data->val[0]) * (data->len - element));
374ptr = realloc(data->val, data->len * sizeof(data->val[0]));
375if (ptr != NULL || data->len == 0) data->val = ptr;
376return 0;
377}
378
379int ASN1CALL
380encode_SignatureAlgorithmIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SignatureAlgorithmIdentifier *data, size_t *size)
381{
382size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
383size_t l HEIMDAL_UNUSED_ATTRIBUTE;
384int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
385
386e = encode_AlgorithmIdentifier(p, len, data, &l);
387if (e) return e;
388p -= l; len -= l; ret += l;
389
390*size = ret;
391return 0;
392}
393
394int ASN1CALL
395decode_SignatureAlgorithmIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SignatureAlgorithmIdentifier *data, size_t *size)
396{
397size_t ret = 0;
398size_t l HEIMDAL_UNUSED_ATTRIBUTE;
399int e HEIMDAL_UNUSED_ATTRIBUTE;
400
401memset(data, 0, sizeof(*data));
402e = decode_AlgorithmIdentifier(p, len, data, &l);
403if(e) goto fail;
404p += l; len -= l; ret += l;
405if(size) *size = ret;
406return 0;
407fail:
408free_SignatureAlgorithmIdentifier(data);
409return e;
410}
411
412void ASN1CALL
413free_SignatureAlgorithmIdentifier(SignatureAlgorithmIdentifier *data)
414{
415free_AlgorithmIdentifier(data);
416}
417
418size_t ASN1CALL
419length_SignatureAlgorithmIdentifier(const SignatureAlgorithmIdentifier *data)
420{
421size_t ret = 0;
422ret += length_AlgorithmIdentifier(data);
423return ret;
424}
425
426int ASN1CALL
427copy_SignatureAlgorithmIdentifier(const SignatureAlgorithmIdentifier *from, SignatureAlgorithmIdentifier *to)
428{
429memset(to, 0, sizeof(*to));
430if(copy_AlgorithmIdentifier(from, to)) goto fail;
431return 0;
432fail:
433free_SignatureAlgorithmIdentifier(to);
434return ENOMEM;
435}
436
437int ASN1CALL
438encode_ContentType(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ContentType *data, size_t *size)
439{
440size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
441size_t l HEIMDAL_UNUSED_ATTRIBUTE;
442int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
443
444e = der_put_oid(p, len, data, &l);
445if (e) return e;
446p -= l; len -= l; ret += l;
447
448e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
449if (e) return e;
450p -= l; len -= l; ret += l;
451
452*size = ret;
453return 0;
454}
455
456int ASN1CALL
457decode_ContentType(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ContentType *data, size_t *size)
458{
459size_t ret = 0;
460size_t l HEIMDAL_UNUSED_ATTRIBUTE;
461int e HEIMDAL_UNUSED_ATTRIBUTE;
462
463memset(data, 0, sizeof(*data));
464{
465size_t Top_datalen, Top_oldlen;
466Der_type Top_type;
467int is_indefinite1;
468e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OID, &Top_datalen, &l);
469if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
470if(e) goto fail;
471p += l; len -= l; ret += l;
472Top_oldlen = len;
473if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
474{ e = ASN1_BAD_FORMAT; goto fail; }
475if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = der_get_oid(p, len, data, &l);
476if(e) goto fail;
477p += l; len -= l; ret += l;
478if(is_indefinite1){
479len += 2;
480e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
481if(e) goto fail;
482p += l; len -= l; ret += l;
483if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
484} else
485len = Top_oldlen - Top_datalen;
486}
487if(size) *size = ret;
488return 0;
489fail:
490free_ContentType(data);
491return e;
492}
493
494void ASN1CALL
495free_ContentType(ContentType *data)
496{
497der_free_oid(data);
498}
499
500size_t ASN1CALL
501length_ContentType(const ContentType *data)
502{
503size_t ret = 0;
504ret += der_length_oid(data);
505ret += 1 + der_length_len (ret);
506return ret;
507}
508
509int ASN1CALL
510copy_ContentType(const ContentType *from, ContentType *to)
511{
512memset(to, 0, sizeof(*to));
513if(der_copy_oid(from, to)) goto fail;
514return 0;
515fail:
516free_ContentType(to);
517return ENOMEM;
518}
519
520int ASN1CALL
521encode_MessageDigest(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const MessageDigest *data, size_t *size)
522{
523size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
524size_t l HEIMDAL_UNUSED_ATTRIBUTE;
525int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
526
527e = der_put_octet_string(p, len, data, &l);
528if (e) return e;
529p -= l; len -= l; ret += l;
530
531e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
532if (e) return e;
533p -= l; len -= l; ret += l;
534
535*size = ret;
536return 0;
537}
538
539int ASN1CALL
540decode_MessageDigest(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, MessageDigest *data, size_t *size)
541{
542size_t ret = 0;
543size_t l HEIMDAL_UNUSED_ATTRIBUTE;
544int e HEIMDAL_UNUSED_ATTRIBUTE;
545
546memset(data, 0, sizeof(*data));
547{
548size_t Top_datalen, Top_oldlen;
549Der_type Top_type;
550int is_indefinite1;
551e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
552if(e) goto fail;
553p += l; len -= l; ret += l;
554Top_oldlen = len;
555if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
556{ e = ASN1_BAD_FORMAT; goto fail; }
557if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }if (Top_type == CONS) {
558e = der_get_octet_string_ber(p, len, data, &l);
559if(e) goto fail;
560p += l; len -= l; ret += l;
561} else {
562e = der_get_octet_string(p, len, data, &l);
563if(e) goto fail;
564p += l; len -= l; ret += l;
565}
566if(is_indefinite1){
567len += 2;
568e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
569if(e) goto fail;
570p += l; len -= l; ret += l;
571if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
572} else
573len = Top_oldlen - Top_datalen;
574}
575if(size) *size = ret;
576return 0;
577fail:
578free_MessageDigest(data);
579return e;
580}
581
582void ASN1CALL
583free_MessageDigest(MessageDigest *data)
584{
585der_free_octet_string(data);
586}
587
588size_t ASN1CALL
589length_MessageDigest(const MessageDigest *data)
590{
591size_t ret = 0;
592ret += der_length_octet_string(data);
593ret += 1 + der_length_len (ret);
594return ret;
595}
596
597int ASN1CALL
598copy_MessageDigest(const MessageDigest *from, MessageDigest *to)
599{
600memset(to, 0, sizeof(*to));
601if(der_copy_octet_string(from, to)) goto fail;
602return 0;
603fail:
604free_MessageDigest(to);
605return ENOMEM;
606}
607
608int ASN1CALL
609encode_ContentInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ContentInfo *data, size_t *size)
610{
611size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
612size_t l HEIMDAL_UNUSED_ATTRIBUTE;
613int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
614
615/* content */
616if((data)->content) {
617size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
618ret = 0;
619e = encode_heim_any(p, len, (data)->content, &l);
620if (e) return e;
621p -= l; len -= l; ret += l;
622
623e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
624if (e) return e;
625p -= l; len -= l; ret += l;
626
627ret += Top_tag_oldret;
628}
629/* contentType */
630{
631size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
632ret = 0;
633e = encode_ContentType(p, len, &(data)->contentType, &l);
634if (e) return e;
635p -= l; len -= l; ret += l;
636
637ret += Top_tag_oldret;
638}
639e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
640if (e) return e;
641p -= l; len -= l; ret += l;
642
643*size = ret;
644return 0;
645}
646
647int ASN1CALL
648decode_ContentInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ContentInfo *data, size_t *size)
649{
650size_t ret = 0;
651size_t l HEIMDAL_UNUSED_ATTRIBUTE;
652int e HEIMDAL_UNUSED_ATTRIBUTE;
653
654memset(data, 0, sizeof(*data));
655{
656size_t Top_datalen, Top_oldlen;
657Der_type Top_type;
658int is_indefinite1;
659e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
660if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
661if(e) goto fail;
662p += l; len -= l; ret += l;
663Top_oldlen = len;
664if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
665{ e = ASN1_BAD_FORMAT; goto fail; }
666if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_ContentType(p, len, &(data)->contentType, &l);
667if(e) goto fail;
668p += l; len -= l; ret += l;
669{
670size_t content_datalen, content_oldlen;
671Der_type content_type;
672int is_indefinite3;
673e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &content_type, 0, &content_datalen, &l);
674if (e == 0 && content_type != CONS) { e = ASN1_BAD_ID; }
675if(e) {
676(data)->content = NULL;
677} else {
678(data)->content = calloc(1, sizeof(*(data)->content));
679if ((data)->content == NULL) { e = ENOMEM; goto fail; }
680p += l; len -= l; ret += l;
681content_oldlen = len;
682if((is_indefinite3 = _heim_fix_dce(content_datalen, &len)) < 0)
683{ e = ASN1_BAD_FORMAT; goto fail; }
684if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_heim_any(p, len, (data)->content, &l);
685if(e) goto fail;
686p += l; len -= l; ret += l;
687if(is_indefinite3){
688len += 2;
689e = der_match_tag_and_length(p, len, (Der_class)0, &content_type, UT_EndOfContent, &content_datalen, &l);
690if(e) goto fail;
691p += l; len -= l; ret += l;
692if (content_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
693} else
694len = content_oldlen - content_datalen;
695}
696}
697if(is_indefinite1){
698len += 2;
699e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
700if(e) goto fail;
701p += l; len -= l; ret += l;
702if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
703} else
704len = Top_oldlen - Top_datalen;
705}
706if(size) *size = ret;
707return 0;
708fail:
709free_ContentInfo(data);
710return e;
711}
712
713void ASN1CALL
714free_ContentInfo(ContentInfo *data)
715{
716free_ContentType(&(data)->contentType);
717if((data)->content) {
718free_heim_any((data)->content);
719free((data)->content);
720(data)->content = NULL;
721}
722}
723
724size_t ASN1CALL
725length_ContentInfo(const ContentInfo *data)
726{
727size_t ret = 0;
728{
729size_t Top_tag_oldret = ret;
730ret = 0;
731ret += length_ContentType(&(data)->contentType);
732ret += Top_tag_oldret;
733}
734if((data)->content){
735size_t Top_tag_oldret = ret;
736ret = 0;
737ret += length_heim_any((data)->content);
738ret += 1 + der_length_len (ret);
739ret += Top_tag_oldret;
740}
741ret += 1 + der_length_len (ret);
742return ret;
743}
744
745int ASN1CALL
746copy_ContentInfo(const ContentInfo *from, ContentInfo *to)
747{
748memset(to, 0, sizeof(*to));
749if(copy_ContentType(&(from)->contentType, &(to)->contentType)) goto fail;
750if((from)->content) {
751(to)->content = malloc(sizeof(*(to)->content));
752if((to)->content == NULL) goto fail;
753if(copy_heim_any((from)->content, (to)->content)) goto fail;
754}else
755(to)->content = NULL;
756return 0;
757fail:
758free_ContentInfo(to);
759return ENOMEM;
760}
761
762int ASN1CALL
763encode_EncapsulatedContentInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncapsulatedContentInfo *data, size_t *size)
764{
765size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
766size_t l HEIMDAL_UNUSED_ATTRIBUTE;
767int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
768
769/* eContent */
770if((data)->eContent) {
771size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
772ret = 0;
773e = der_put_octet_string(p, len, (data)->eContent, &l);
774if (e) return e;
775p -= l; len -= l; ret += l;
776
777e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
778if (e) return e;
779p -= l; len -= l; ret += l;
780
781e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
782if (e) return e;
783p -= l; len -= l; ret += l;
784
785ret += Top_tag_oldret;
786}
787/* eContentType */
788{
789size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
790ret = 0;
791e = encode_ContentType(p, len, &(data)->eContentType, &l);
792if (e) return e;
793p -= l; len -= l; ret += l;
794
795ret += Top_tag_oldret;
796}
797e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
798if (e) return e;
799p -= l; len -= l; ret += l;
800
801*size = ret;
802return 0;
803}
804
805int ASN1CALL
806decode_EncapsulatedContentInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncapsulatedContentInfo *data, size_t *size)
807{
808size_t ret = 0;
809size_t l HEIMDAL_UNUSED_ATTRIBUTE;
810int e HEIMDAL_UNUSED_ATTRIBUTE;
811
812memset(data, 0, sizeof(*data));
813{
814size_t Top_datalen, Top_oldlen;
815Der_type Top_type;
816int is_indefinite1;
817e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
818if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
819if(e) goto fail;
820p += l; len -= l; ret += l;
821Top_oldlen = len;
822if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
823{ e = ASN1_BAD_FORMAT; goto fail; }
824if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_ContentType(p, len, &(data)->eContentType, &l);
825if(e) goto fail;
826p += l; len -= l; ret += l;
827{
828size_t eContent_datalen, eContent_oldlen;
829Der_type eContent_type;
830int is_indefinite3;
831e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &eContent_type, 0, &eContent_datalen, &l);
832if (e == 0 && eContent_type != CONS) { e = ASN1_BAD_ID; }
833if(e) {
834(data)->eContent = NULL;
835} else {
836(data)->eContent = calloc(1, sizeof(*(data)->eContent));
837if ((data)->eContent == NULL) { e = ENOMEM; goto fail; }
838p += l; len -= l; ret += l;
839eContent_oldlen = len;
840if((is_indefinite3 = _heim_fix_dce(eContent_datalen, &len)) < 0)
841{ e = ASN1_BAD_FORMAT; goto fail; }
842if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
843size_t eContent_Tag_datalen, eContent_Tag_oldlen;
844Der_type eContent_Tag_type;
845int is_indefinite4;
846e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &eContent_Tag_type, UT_OctetString, &eContent_Tag_datalen, &l);
847if(e) goto fail;
848p += l; len -= l; ret += l;
849eContent_Tag_oldlen = len;
850if((is_indefinite4 = _heim_fix_dce(eContent_Tag_datalen, &len)) < 0)
851{ e = ASN1_BAD_FORMAT; goto fail; }
852if (is_indefinite4) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }if (eContent_Tag_type == CONS) {
853e = der_get_octet_string_ber(p, len, (data)->eContent, &l);
854if(e) goto fail;
855p += l; len -= l; ret += l;
856} else {
857e = der_get_octet_string(p, len, (data)->eContent, &l);
858if(e) goto fail;
859p += l; len -= l; ret += l;
860}
861if(is_indefinite4){
862len += 2;
863e = der_match_tag_and_length(p, len, (Der_class)0, &eContent_Tag_type, UT_EndOfContent, &eContent_Tag_datalen, &l);
864if(e) goto fail;
865p += l; len -= l; ret += l;
866if (eContent_Tag_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
867} else
868len = eContent_Tag_oldlen - eContent_Tag_datalen;
869}
870if(is_indefinite3){
871len += 2;
872e = der_match_tag_and_length(p, len, (Der_class)0, &eContent_type, UT_EndOfContent, &eContent_datalen, &l);
873if(e) goto fail;
874p += l; len -= l; ret += l;
875if (eContent_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
876} else
877len = eContent_oldlen - eContent_datalen;
878}
879}
880if(is_indefinite1){
881len += 2;
882e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
883if(e) goto fail;
884p += l; len -= l; ret += l;
885if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
886} else
887len = Top_oldlen - Top_datalen;
888}
889if(size) *size = ret;
890return 0;
891fail:
892free_EncapsulatedContentInfo(data);
893return e;
894}
895
896void ASN1CALL
897free_EncapsulatedContentInfo(EncapsulatedContentInfo *data)
898{
899free_ContentType(&(data)->eContentType);
900if((data)->eContent) {
901der_free_octet_string((data)->eContent);
902free((data)->eContent);
903(data)->eContent = NULL;
904}
905}
906
907size_t ASN1CALL
908length_EncapsulatedContentInfo(const EncapsulatedContentInfo *data)
909{
910size_t ret = 0;
911{
912size_t Top_tag_oldret = ret;
913ret = 0;
914ret += length_ContentType(&(data)->eContentType);
915ret += Top_tag_oldret;
916}
917if((data)->eContent){
918size_t Top_tag_oldret = ret;
919ret = 0;
920ret += der_length_octet_string((data)->eContent);
921ret += 1 + der_length_len (ret);
922ret += 1 + der_length_len (ret);
923ret += Top_tag_oldret;
924}
925ret += 1 + der_length_len (ret);
926return ret;
927}
928
929int ASN1CALL
930copy_EncapsulatedContentInfo(const EncapsulatedContentInfo *from, EncapsulatedContentInfo *to)
931{
932memset(to, 0, sizeof(*to));
933if(copy_ContentType(&(from)->eContentType, &(to)->eContentType)) goto fail;
934if((from)->eContent) {
935(to)->eContent = malloc(sizeof(*(to)->eContent));
936if((to)->eContent == NULL) goto fail;
937if(der_copy_octet_string((from)->eContent, (to)->eContent)) goto fail;
938}else
939(to)->eContent = NULL;
940return 0;
941fail:
942free_EncapsulatedContentInfo(to);
943return ENOMEM;
944}
945
946int ASN1CALL
947encode_CertificateSet(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CertificateSet *data, size_t *size)
948{
949size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
950size_t l HEIMDAL_UNUSED_ATTRIBUTE;
951int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
952
953{
954heim_octet_string *val;
955size_t elen = 0, totallen = 0;
956int eret = 0;
957if ((data)->len > UINT_MAX/sizeof(val[0]))
958return ERANGE;
959val = malloc(sizeof(val[0]) * (data)->len);
960if (val == NULL && (data)->len != 0) return ENOMEM;
961for(i = 0; i < (int)(data)->len; i++) {
962ASN1_MALLOC_ENCODE(heim_any, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
963if(eret) {
964i--;
965while (i >= 0) {
966free(val[i].data);
967i--;
968}
969free(val);
970return eret;
971}
972totallen += elen;
973}
974if (totallen > len) {
975for (i = 0; i < (int)(data)->len; i++) {
976free(val[i].data);
977}
978free(val);
979return ASN1_OVERFLOW;
980}
981qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
982for(i = (int)(data)->len - 1; i >= 0; --i) {
983p -= val[i].length;
984ret += val[i].length;
985memcpy(p + 1, val[i].data, val[i].length);
986free(val[i].data);
987}
988free(val);
989}
990e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
991if (e) return e;
992p -= l; len -= l; ret += l;
993
994*size = ret;
995return 0;
996}
997
998int ASN1CALL
999decode_CertificateSet(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CertificateSet *data, size_t *size)
1000{
1001size_t ret = 0;
1002size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1003int e HEIMDAL_UNUSED_ATTRIBUTE;
1004
1005memset(data, 0, sizeof(*data));
1006{
1007size_t Top_datalen, Top_oldlen;
1008Der_type Top_type;
1009int is_indefinite1;
1010e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
1011if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1012if(e) goto fail;
1013p += l; len -= l; ret += l;
1014Top_oldlen = len;
1015if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
1016{ e = ASN1_BAD_FORMAT; goto fail; }
1017if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
1018size_t Top_Tag_origlen = len;
1019size_t Top_Tag_oldret = ret;
1020size_t Top_Tag_olen = 0;
1021void *Top_Tag_tmp;
1022ret = 0;
1023(data)->len = 0;
1024(data)->val = NULL;
1025while(ret < Top_Tag_origlen) {
1026size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1027if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1028Top_Tag_olen = Top_Tag_nlen;
1029Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1030if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1031(data)->val = Top_Tag_tmp;
1032e = decode_heim_any(p, len, &(data)->val[(data)->len], &l);
1033if(e) goto fail;
1034p += l; len -= l; ret += l;
1035(data)->len++;
1036len = Top_Tag_origlen - ret;
1037}
1038ret += Top_Tag_oldret;
1039}
1040if(is_indefinite1){
1041len += 2;
1042e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
1043if(e) goto fail;
1044p += l; len -= l; ret += l;
1045if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
1046} else
1047len = Top_oldlen - Top_datalen;
1048}
1049if(size) *size = ret;
1050return 0;
1051fail:
1052free_CertificateSet(data);
1053return e;
1054}
1055
1056void ASN1CALL
1057free_CertificateSet(CertificateSet *data)
1058{
1059while((data)->len){
1060free_heim_any(&(data)->val[(data)->len-1]);
1061(data)->len--;
1062}
1063free((data)->val);
1064(data)->val = NULL;
1065}
1066
1067size_t ASN1CALL
1068length_CertificateSet(const CertificateSet *data)
1069{
1070size_t ret = 0;
1071{
1072size_t Top_tag_oldret = ret;
1073unsigned int n_Top_tag;
1074ret = 0;
1075for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
1076size_t Top_tag_for_oldret = ret;
1077ret = 0;
1078ret += length_heim_any(&(data)->val[n_Top_tag - 1]);
1079ret += Top_tag_for_oldret;
1080}
1081ret += Top_tag_oldret;
1082}
1083ret += 1 + der_length_len (ret);
1084return ret;
1085}
1086
1087int ASN1CALL
1088copy_CertificateSet(const CertificateSet *from, CertificateSet *to)
1089{
1090memset(to, 0, sizeof(*to));
1091if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1092goto fail;
1093for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1094if(copy_heim_any(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1095}
1096return 0;
1097fail:
1098free_CertificateSet(to);
1099return ENOMEM;
1100}
1101
1102int ASN1CALL
1103encode_CertificateList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CertificateList *data, size_t *size)
1104{
1105size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1106size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1107int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1108
1109e = encode_Certificate(p, len, data, &l);
1110if (e) return e;
1111p -= l; len -= l; ret += l;
1112
1113*size = ret;
1114return 0;
1115}
1116
1117int ASN1CALL
1118decode_CertificateList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CertificateList *data, size_t *size)
1119{
1120size_t ret = 0;
1121size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1122int e HEIMDAL_UNUSED_ATTRIBUTE;
1123
1124memset(data, 0, sizeof(*data));
1125e = decode_Certificate(p, len, data, &l);
1126if(e) goto fail;
1127p += l; len -= l; ret += l;
1128if(size) *size = ret;
1129return 0;
1130fail:
1131free_CertificateList(data);
1132return e;
1133}
1134
1135void ASN1CALL
1136free_CertificateList(CertificateList *data)
1137{
1138free_Certificate(data);
1139}
1140
1141size_t ASN1CALL
1142length_CertificateList(const CertificateList *data)
1143{
1144size_t ret = 0;
1145ret += length_Certificate(data);
1146return ret;
1147}
1148
1149int ASN1CALL
1150copy_CertificateList(const CertificateList *from, CertificateList *to)
1151{
1152memset(to, 0, sizeof(*to));
1153if(copy_Certificate(from, to)) goto fail;
1154return 0;
1155fail:
1156free_CertificateList(to);
1157return ENOMEM;
1158}
1159
1160int ASN1CALL
1161encode_CertificateRevocationLists(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CertificateRevocationLists *data, size_t *size)
1162{
1163size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1164size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1165int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1166
1167{
1168heim_octet_string *val;
1169size_t elen = 0, totallen = 0;
1170int eret = 0;
1171if ((data)->len > UINT_MAX/sizeof(val[0]))
1172return ERANGE;
1173val = malloc(sizeof(val[0]) * (data)->len);
1174if (val == NULL && (data)->len != 0) return ENOMEM;
1175for(i = 0; i < (int)(data)->len; i++) {
1176ASN1_MALLOC_ENCODE(CertificateList, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
1177if(eret) {
1178i--;
1179while (i >= 0) {
1180free(val[i].data);
1181i--;
1182}
1183free(val);
1184return eret;
1185}
1186totallen += elen;
1187}
1188if (totallen > len) {
1189for (i = 0; i < (int)(data)->len; i++) {
1190free(val[i].data);
1191}
1192free(val);
1193return ASN1_OVERFLOW;
1194}
1195qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
1196for(i = (int)(data)->len - 1; i >= 0; --i) {
1197p -= val[i].length;
1198ret += val[i].length;
1199memcpy(p + 1, val[i].data, val[i].length);
1200free(val[i].data);
1201}
1202free(val);
1203}
1204e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
1205if (e) return e;
1206p -= l; len -= l; ret += l;
1207
1208*size = ret;
1209return 0;
1210}
1211
1212int ASN1CALL
1213decode_CertificateRevocationLists(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CertificateRevocationLists *data, size_t *size)
1214{
1215size_t ret = 0;
1216size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1217int e HEIMDAL_UNUSED_ATTRIBUTE;
1218
1219memset(data, 0, sizeof(*data));
1220{
1221size_t Top_datalen, Top_oldlen;
1222Der_type Top_type;
1223int is_indefinite1;
1224e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
1225if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1226if(e) goto fail;
1227p += l; len -= l; ret += l;
1228Top_oldlen = len;
1229if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
1230{ e = ASN1_BAD_FORMAT; goto fail; }
1231if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
1232size_t Top_Tag_origlen = len;
1233size_t Top_Tag_oldret = ret;
1234size_t Top_Tag_olen = 0;
1235void *Top_Tag_tmp;
1236ret = 0;
1237(data)->len = 0;
1238(data)->val = NULL;
1239while(ret < Top_Tag_origlen) {
1240size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1241if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1242Top_Tag_olen = Top_Tag_nlen;
1243Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1244if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1245(data)->val = Top_Tag_tmp;
1246e = decode_CertificateList(p, len, &(data)->val[(data)->len], &l);
1247if(e) goto fail;
1248p += l; len -= l; ret += l;
1249(data)->len++;
1250len = Top_Tag_origlen - ret;
1251}
1252ret += Top_Tag_oldret;
1253}
1254if(is_indefinite1){
1255len += 2;
1256e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
1257if(e) goto fail;
1258p += l; len -= l; ret += l;
1259if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
1260} else
1261len = Top_oldlen - Top_datalen;
1262}
1263if(size) *size = ret;
1264return 0;
1265fail:
1266free_CertificateRevocationLists(data);
1267return e;
1268}
1269
1270void ASN1CALL
1271free_CertificateRevocationLists(CertificateRevocationLists *data)
1272{
1273while((data)->len){
1274free_CertificateList(&(data)->val[(data)->len-1]);
1275(data)->len--;
1276}
1277free((data)->val);
1278(data)->val = NULL;
1279}
1280
1281size_t ASN1CALL
1282length_CertificateRevocationLists(const CertificateRevocationLists *data)
1283{
1284size_t ret = 0;
1285{
1286size_t Top_tag_oldret = ret;
1287unsigned int n_Top_tag;
1288ret = 0;
1289for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
1290size_t Top_tag_for_oldret = ret;
1291ret = 0;
1292ret += length_CertificateList(&(data)->val[n_Top_tag - 1]);
1293ret += Top_tag_for_oldret;
1294}
1295ret += Top_tag_oldret;
1296}
1297ret += 1 + der_length_len (ret);
1298return ret;
1299}
1300
1301int ASN1CALL
1302copy_CertificateRevocationLists(const CertificateRevocationLists *from, CertificateRevocationLists *to)
1303{
1304memset(to, 0, sizeof(*to));
1305if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1306goto fail;
1307for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1308if(copy_CertificateList(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1309}
1310return 0;
1311fail:
1312free_CertificateRevocationLists(to);
1313return ENOMEM;
1314}
1315
1316int ASN1CALL
1317encode_IssuerAndSerialNumber(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const IssuerAndSerialNumber *data, size_t *size)
1318{
1319size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1320size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1321int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1322
1323/* serialNumber */
1324{
1325size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1326ret = 0;
1327e = encode_CertificateSerialNumber(p, len, &(data)->serialNumber, &l);
1328if (e) return e;
1329p -= l; len -= l; ret += l;
1330
1331ret += Top_tag_oldret;
1332}
1333/* issuer */
1334{
1335size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1336ret = 0;
1337e = encode_Name(p, len, &(data)->issuer, &l);
1338if (e) return e;
1339p -= l; len -= l; ret += l;
1340
1341ret += Top_tag_oldret;
1342}
1343e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
1344if (e) return e;
1345p -= l; len -= l; ret += l;
1346
1347*size = ret;
1348return 0;
1349}
1350
1351int ASN1CALL
1352decode_IssuerAndSerialNumber(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, IssuerAndSerialNumber *data, size_t *size)
1353{
1354size_t ret = 0;
1355size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1356int e HEIMDAL_UNUSED_ATTRIBUTE;
1357
1358memset(data, 0, sizeof(*data));
1359{
1360size_t Top_datalen, Top_oldlen;
1361Der_type Top_type;
1362int is_indefinite1;
1363e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
1364if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1365if(e) goto fail;
1366p += l; len -= l; ret += l;
1367Top_oldlen = len;
1368if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
1369{ e = ASN1_BAD_FORMAT; goto fail; }
1370if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_Name(p, len, &(data)->issuer, &l);
1371if(e) goto fail;
1372p += l; len -= l; ret += l;
1373e = decode_CertificateSerialNumber(p, len, &(data)->serialNumber, &l);
1374if(e) goto fail;
1375p += l; len -= l; ret += l;
1376if(is_indefinite1){
1377len += 2;
1378e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
1379if(e) goto fail;
1380p += l; len -= l; ret += l;
1381if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
1382} else
1383len = Top_oldlen - Top_datalen;
1384}
1385if(size) *size = ret;
1386return 0;
1387fail:
1388free_IssuerAndSerialNumber(data);
1389return e;
1390}
1391
1392void ASN1CALL
1393free_IssuerAndSerialNumber(IssuerAndSerialNumber *data)
1394{
1395free_Name(&(data)->issuer);
1396free_CertificateSerialNumber(&(data)->serialNumber);
1397}
1398
1399size_t ASN1CALL
1400length_IssuerAndSerialNumber(const IssuerAndSerialNumber *data)
1401{
1402size_t ret = 0;
1403{
1404size_t Top_tag_oldret = ret;
1405ret = 0;
1406ret += length_Name(&(data)->issuer);
1407ret += Top_tag_oldret;
1408}
1409{
1410size_t Top_tag_oldret = ret;
1411ret = 0;
1412ret += length_CertificateSerialNumber(&(data)->serialNumber);
1413ret += Top_tag_oldret;
1414}
1415ret += 1 + der_length_len (ret);
1416return ret;
1417}
1418
1419int ASN1CALL
1420copy_IssuerAndSerialNumber(const IssuerAndSerialNumber *from, IssuerAndSerialNumber *to)
1421{
1422memset(to, 0, sizeof(*to));
1423if(copy_Name(&(from)->issuer, &(to)->issuer)) goto fail;
1424if(copy_CertificateSerialNumber(&(from)->serialNumber, &(to)->serialNumber)) goto fail;
1425return 0;
1426fail:
1427free_IssuerAndSerialNumber(to);
1428return ENOMEM;
1429}
1430
1431int ASN1CALL
1432encode_CMSIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CMSIdentifier *data, size_t *size)
1433{
1434size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1435size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1436int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1437
1438
1439switch((data)->element) {
1440case choice_CMSIdentifier_subjectKeyIdentifier: {size_t Top_oldret = ret;
1441ret = 0;
1442e = encode_SubjectKeyIdentifier(p, len, &((data))->u.subjectKeyIdentifier, &l);
1443if (e) return e;
1444p -= l; len -= l; ret += l;
1445
1446e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1447if (e) return e;
1448p -= l; len -= l; ret += l;
1449
1450ret += Top_oldret;
1451break;
1452}
1453case choice_CMSIdentifier_issuerAndSerialNumber: {size_t Top_oldret = ret;
1454ret = 0;
1455e = encode_IssuerAndSerialNumber(p, len, &((data))->u.issuerAndSerialNumber, &l);
1456if (e) return e;
1457p -= l; len -= l; ret += l;
1458
1459ret += Top_oldret;
1460break;
1461}
1462};
1463*size = ret;
1464return 0;
1465}
1466
1467int ASN1CALL
1468decode_CMSIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CMSIdentifier *data, size_t *size)
1469{
1470size_t ret = 0;
1471size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1472int e HEIMDAL_UNUSED_ATTRIBUTE;
1473
1474memset(data, 0, sizeof(*data));
1475if (der_match_tag(p, len, ASN1_C_UNIV, CONS, UT_Sequence, NULL) == 0) {
1476e = decode_IssuerAndSerialNumber(p, len, &(data)->u.issuerAndSerialNumber, &l);
1477if(e) goto fail;
1478p += l; len -= l; ret += l;
1479(data)->element = choice_CMSIdentifier_issuerAndSerialNumber;
1480}
1481else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
1482{
1483size_t subjectKeyIdentifier_datalen, subjectKeyIdentifier_oldlen;
1484Der_type subjectKeyIdentifier_type;
1485int is_indefinite2;
1486e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subjectKeyIdentifier_type, 0, &subjectKeyIdentifier_datalen, &l);
1487if (e == 0 && subjectKeyIdentifier_type != CONS) { e = ASN1_BAD_ID; }
1488if(e) goto fail;
1489p += l; len -= l; ret += l;
1490subjectKeyIdentifier_oldlen = len;
1491if((is_indefinite2 = _heim_fix_dce(subjectKeyIdentifier_datalen, &len)) < 0)
1492{ e = ASN1_BAD_FORMAT; goto fail; }
1493if (is_indefinite2) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_SubjectKeyIdentifier(p, len, &(data)->u.subjectKeyIdentifier, &l);
1494if(e) goto fail;
1495p += l; len -= l; ret += l;
1496if(is_indefinite2){
1497len += 2;
1498e = der_match_tag_and_length(p, len, (Der_class)0, &subjectKeyIdentifier_type, UT_EndOfContent, &subjectKeyIdentifier_datalen, &l);
1499if(e) goto fail;
1500p += l; len -= l; ret += l;
1501if (subjectKeyIdentifier_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
1502} else
1503len = subjectKeyIdentifier_oldlen - subjectKeyIdentifier_datalen;
1504}
1505(data)->element = choice_CMSIdentifier_subjectKeyIdentifier;
1506}
1507else {
1508e = ASN1_PARSE_ERROR;
1509goto fail;
1510}
1511if(size) *size = ret;
1512return 0;
1513fail:
1514free_CMSIdentifier(data);
1515return e;
1516}
1517
1518void ASN1CALL
1519free_CMSIdentifier(CMSIdentifier *data)
1520{
1521switch((data)->element) {
1522case choice_CMSIdentifier_issuerAndSerialNumber:
1523free_IssuerAndSerialNumber(&(data)->u.issuerAndSerialNumber);
1524break;
1525case choice_CMSIdentifier_subjectKeyIdentifier:
1526free_SubjectKeyIdentifier(&(data)->u.subjectKeyIdentifier);
1527break;
1528}
1529}
1530
1531size_t ASN1CALL
1532length_CMSIdentifier(const CMSIdentifier *data)
1533{
1534size_t ret = 0;
1535switch((data)->element) {
1536case choice_CMSIdentifier_issuerAndSerialNumber:
1537{
1538size_t Top_oldret = ret;
1539ret = 0;
1540ret += length_IssuerAndSerialNumber(&(data)->u.issuerAndSerialNumber);
1541ret += Top_oldret;
1542}
1543break;
1544case choice_CMSIdentifier_subjectKeyIdentifier:
1545{
1546size_t Top_oldret = ret;
1547ret = 0;
1548ret += length_SubjectKeyIdentifier(&(data)->u.subjectKeyIdentifier);
1549ret += 1 + der_length_len (ret);
1550ret += Top_oldret;
1551}
1552break;
1553}
1554return ret;
1555}
1556
1557int ASN1CALL
1558copy_CMSIdentifier(const CMSIdentifier *from, CMSIdentifier *to)
1559{
1560memset(to, 0, sizeof(*to));
1561(to)->element = (from)->element;
1562switch((from)->element) {
1563case choice_CMSIdentifier_issuerAndSerialNumber:
1564if(copy_IssuerAndSerialNumber(&(from)->u.issuerAndSerialNumber, &(to)->u.issuerAndSerialNumber)) goto fail;
1565break;
1566case choice_CMSIdentifier_subjectKeyIdentifier:
1567if(copy_SubjectKeyIdentifier(&(from)->u.subjectKeyIdentifier, &(to)->u.subjectKeyIdentifier)) goto fail;
1568break;
1569}
1570return 0;
1571fail:
1572free_CMSIdentifier(to);
1573return ENOMEM;
1574}
1575
1576int ASN1CALL
1577encode_SignerIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SignerIdentifier *data, size_t *size)
1578{
1579size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1580size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1581int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1582
1583e = encode_CMSIdentifier(p, len, data, &l);
1584if (e) return e;
1585p -= l; len -= l; ret += l;
1586
1587*size = ret;
1588return 0;
1589}
1590
1591int ASN1CALL
1592decode_SignerIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SignerIdentifier *data, size_t *size)
1593{
1594size_t ret = 0;
1595size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1596int e HEIMDAL_UNUSED_ATTRIBUTE;
1597
1598memset(data, 0, sizeof(*data));
1599e = decode_CMSIdentifier(p, len, data, &l);
1600if(e) goto fail;
1601p += l; len -= l; ret += l;
1602if(size) *size = ret;
1603return 0;
1604fail:
1605free_SignerIdentifier(data);
1606return e;
1607}
1608
1609void ASN1CALL
1610free_SignerIdentifier(SignerIdentifier *data)
1611{
1612free_CMSIdentifier(data);
1613}
1614
1615size_t ASN1CALL
1616length_SignerIdentifier(const SignerIdentifier *data)
1617{
1618size_t ret = 0;
1619ret += length_CMSIdentifier(data);
1620return ret;
1621}
1622
1623int ASN1CALL
1624copy_SignerIdentifier(const SignerIdentifier *from, SignerIdentifier *to)
1625{
1626memset(to, 0, sizeof(*to));
1627if(copy_CMSIdentifier(from, to)) goto fail;
1628return 0;
1629fail:
1630free_SignerIdentifier(to);
1631return ENOMEM;
1632}
1633
1634int ASN1CALL
1635encode_RecipientIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RecipientIdentifier *data, size_t *size)
1636{
1637size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1638size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1639int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1640
1641e = encode_CMSIdentifier(p, len, data, &l);
1642if (e) return e;
1643p -= l; len -= l; ret += l;
1644
1645*size = ret;
1646return 0;
1647}
1648
1649int ASN1CALL
1650decode_RecipientIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RecipientIdentifier *data, size_t *size)
1651{
1652size_t ret = 0;
1653size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1654int e HEIMDAL_UNUSED_ATTRIBUTE;
1655
1656memset(data, 0, sizeof(*data));
1657e = decode_CMSIdentifier(p, len, data, &l);
1658if(e) goto fail;
1659p += l; len -= l; ret += l;
1660if(size) *size = ret;
1661return 0;
1662fail:
1663free_RecipientIdentifier(data);
1664return e;
1665}
1666
1667void ASN1CALL
1668free_RecipientIdentifier(RecipientIdentifier *data)
1669{
1670free_CMSIdentifier(data);
1671}
1672
1673size_t ASN1CALL
1674length_RecipientIdentifier(const RecipientIdentifier *data)
1675{
1676size_t ret = 0;
1677ret += length_CMSIdentifier(data);
1678return ret;
1679}
1680
1681int ASN1CALL
1682copy_RecipientIdentifier(const RecipientIdentifier *from, RecipientIdentifier *to)
1683{
1684memset(to, 0, sizeof(*to));
1685if(copy_CMSIdentifier(from, to)) goto fail;
1686return 0;
1687fail:
1688free_RecipientIdentifier(to);
1689return ENOMEM;
1690}
1691
1692int ASN1CALL
1693encode_CMSAttributes(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CMSAttributes *data, size_t *size)
1694{
1695size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1696size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1697int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1698
1699{
1700heim_octet_string *val;
1701size_t elen = 0, totallen = 0;
1702int eret = 0;
1703if ((data)->len > UINT_MAX/sizeof(val[0]))
1704return ERANGE;
1705val = malloc(sizeof(val[0]) * (data)->len);
1706if (val == NULL && (data)->len != 0) return ENOMEM;
1707for(i = 0; i < (int)(data)->len; i++) {
1708ASN1_MALLOC_ENCODE(Attribute, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
1709if(eret) {
1710i--;
1711while (i >= 0) {
1712free(val[i].data);
1713i--;
1714}
1715free(val);
1716return eret;
1717}
1718totallen += elen;
1719}
1720if (totallen > len) {
1721for (i = 0; i < (int)(data)->len; i++) {
1722free(val[i].data);
1723}
1724free(val);
1725return ASN1_OVERFLOW;
1726}
1727qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
1728for(i = (int)(data)->len - 1; i >= 0; --i) {
1729p -= val[i].length;
1730ret += val[i].length;
1731memcpy(p + 1, val[i].data, val[i].length);
1732free(val[i].data);
1733}
1734free(val);
1735}
1736e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
1737if (e) return e;
1738p -= l; len -= l; ret += l;
1739
1740*size = ret;
1741return 0;
1742}
1743
1744int ASN1CALL
1745decode_CMSAttributes(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CMSAttributes *data, size_t *size)
1746{
1747size_t ret = 0;
1748size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1749int e HEIMDAL_UNUSED_ATTRIBUTE;
1750
1751memset(data, 0, sizeof(*data));
1752{
1753size_t Top_datalen, Top_oldlen;
1754Der_type Top_type;
1755int is_indefinite1;
1756e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
1757if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
1758if(e) goto fail;
1759p += l; len -= l; ret += l;
1760Top_oldlen = len;
1761if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
1762{ e = ASN1_BAD_FORMAT; goto fail; }
1763if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
1764size_t Top_Tag_origlen = len;
1765size_t Top_Tag_oldret = ret;
1766size_t Top_Tag_olen = 0;
1767void *Top_Tag_tmp;
1768ret = 0;
1769(data)->len = 0;
1770(data)->val = NULL;
1771while(ret < Top_Tag_origlen) {
1772size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1773if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
1774Top_Tag_olen = Top_Tag_nlen;
1775Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1776if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
1777(data)->val = Top_Tag_tmp;
1778e = decode_Attribute(p, len, &(data)->val[(data)->len], &l);
1779if(e) goto fail;
1780p += l; len -= l; ret += l;
1781(data)->len++;
1782len = Top_Tag_origlen - ret;
1783}
1784ret += Top_Tag_oldret;
1785}
1786if(is_indefinite1){
1787len += 2;
1788e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
1789if(e) goto fail;
1790p += l; len -= l; ret += l;
1791if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
1792} else
1793len = Top_oldlen - Top_datalen;
1794}
1795if(size) *size = ret;
1796return 0;
1797fail:
1798free_CMSAttributes(data);
1799return e;
1800}
1801
1802void ASN1CALL
1803free_CMSAttributes(CMSAttributes *data)
1804{
1805while((data)->len){
1806free_Attribute(&(data)->val[(data)->len-1]);
1807(data)->len--;
1808}
1809free((data)->val);
1810(data)->val = NULL;
1811}
1812
1813size_t ASN1CALL
1814length_CMSAttributes(const CMSAttributes *data)
1815{
1816size_t ret = 0;
1817{
1818size_t Top_tag_oldret = ret;
1819unsigned int n_Top_tag;
1820ret = 0;
1821for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
1822size_t Top_tag_for_oldret = ret;
1823ret = 0;
1824ret += length_Attribute(&(data)->val[n_Top_tag - 1]);
1825ret += Top_tag_for_oldret;
1826}
1827ret += Top_tag_oldret;
1828}
1829ret += 1 + der_length_len (ret);
1830return ret;
1831}
1832
1833int ASN1CALL
1834copy_CMSAttributes(const CMSAttributes *from, CMSAttributes *to)
1835{
1836memset(to, 0, sizeof(*to));
1837if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
1838goto fail;
1839for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
1840if(copy_Attribute(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
1841}
1842return 0;
1843fail:
1844free_CMSAttributes(to);
1845return ENOMEM;
1846}
1847
1848int ASN1CALL
1849encode_SignatureValue(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SignatureValue *data, size_t *size)
1850{
1851size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1852size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1853int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1854
1855e = der_put_octet_string(p, len, data, &l);
1856if (e) return e;
1857p -= l; len -= l; ret += l;
1858
1859e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
1860if (e) return e;
1861p -= l; len -= l; ret += l;
1862
1863*size = ret;
1864return 0;
1865}
1866
1867int ASN1CALL
1868decode_SignatureValue(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SignatureValue *data, size_t *size)
1869{
1870size_t ret = 0;
1871size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1872int e HEIMDAL_UNUSED_ATTRIBUTE;
1873
1874memset(data, 0, sizeof(*data));
1875{
1876size_t Top_datalen, Top_oldlen;
1877Der_type Top_type;
1878int is_indefinite1;
1879e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
1880if(e) goto fail;
1881p += l; len -= l; ret += l;
1882Top_oldlen = len;
1883if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
1884{ e = ASN1_BAD_FORMAT; goto fail; }
1885if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }if (Top_type == CONS) {
1886e = der_get_octet_string_ber(p, len, data, &l);
1887if(e) goto fail;
1888p += l; len -= l; ret += l;
1889} else {
1890e = der_get_octet_string(p, len, data, &l);
1891if(e) goto fail;
1892p += l; len -= l; ret += l;
1893}
1894if(is_indefinite1){
1895len += 2;
1896e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
1897if(e) goto fail;
1898p += l; len -= l; ret += l;
1899if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
1900} else
1901len = Top_oldlen - Top_datalen;
1902}
1903if(size) *size = ret;
1904return 0;
1905fail:
1906free_SignatureValue(data);
1907return e;
1908}
1909
1910void ASN1CALL
1911free_SignatureValue(SignatureValue *data)
1912{
1913der_free_octet_string(data);
1914}
1915
1916size_t ASN1CALL
1917length_SignatureValue(const SignatureValue *data)
1918{
1919size_t ret = 0;
1920ret += der_length_octet_string(data);
1921ret += 1 + der_length_len (ret);
1922return ret;
1923}
1924
1925int ASN1CALL
1926copy_SignatureValue(const SignatureValue *from, SignatureValue *to)
1927{
1928memset(to, 0, sizeof(*to));
1929if(der_copy_octet_string(from, to)) goto fail;
1930return 0;
1931fail:
1932free_SignatureValue(to);
1933return ENOMEM;
1934}
1935
1936int ASN1CALL
1937encode_SignerInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SignerInfo *data, size_t *size)
1938{
1939size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1940size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1941int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1942
1943/* unsignedAttrs */
1944if((data)->unsignedAttrs) {
1945size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1946ret = 0;
1947{
1948heim_octet_string *val;
1949size_t elen = 0, totallen = 0;
1950int eret = 0;
1951if (((data)->unsignedAttrs)->len > UINT_MAX/sizeof(val[0]))
1952return ERANGE;
1953val = malloc(sizeof(val[0]) * ((data)->unsignedAttrs)->len);
1954if (val == NULL && ((data)->unsignedAttrs)->len != 0) return ENOMEM;
1955for(i = 0; i < (int)((data)->unsignedAttrs)->len; i++) {
1956ASN1_MALLOC_ENCODE(Attribute, val[i].data, val[i].length, &((data)->unsignedAttrs)->val[i], &elen, eret);
1957if(eret) {
1958i--;
1959while (i >= 0) {
1960free(val[i].data);
1961i--;
1962}
1963free(val);
1964return eret;
1965}
1966totallen += elen;
1967}
1968if (totallen > len) {
1969for (i = 0; i < (int)((data)->unsignedAttrs)->len; i++) {
1970free(val[i].data);
1971}
1972free(val);
1973return ASN1_OVERFLOW;
1974}
1975qsort(val, ((data)->unsignedAttrs)->len, sizeof(val[0]), _heim_der_set_sort);
1976for(i = (int)((data)->unsignedAttrs)->len - 1; i >= 0; --i) {
1977p -= val[i].length;
1978ret += val[i].length;
1979memcpy(p + 1, val[i].data, val[i].length);
1980free(val[i].data);
1981}
1982free(val);
1983}
1984e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1985if (e) return e;
1986p -= l; len -= l; ret += l;
1987
1988ret += Top_tag_oldret;
1989}
1990/* signature */
1991{
1992size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1993ret = 0;
1994e = encode_SignatureValue(p, len, &(data)->signature, &l);
1995if (e) return e;
1996p -= l; len -= l; ret += l;
1997
1998ret += Top_tag_oldret;
1999}
2000/* signatureAlgorithm */
2001{
2002size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2003ret = 0;
2004e = encode_SignatureAlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
2005if (e) return e;
2006p -= l; len -= l; ret += l;
2007
2008ret += Top_tag_oldret;
2009}
2010/* signedAttrs */
2011if((data)->signedAttrs) {
2012size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2013ret = 0;
2014{
2015heim_octet_string *val;
2016size_t elen = 0, totallen = 0;
2017int eret = 0;
2018if (((data)->signedAttrs)->len > UINT_MAX/sizeof(val[0]))
2019return ERANGE;
2020val = malloc(sizeof(val[0]) * ((data)->signedAttrs)->len);
2021if (val == NULL && ((data)->signedAttrs)->len != 0) return ENOMEM;
2022for(i = 0; i < (int)((data)->signedAttrs)->len; i++) {
2023ASN1_MALLOC_ENCODE(Attribute, val[i].data, val[i].length, &((data)->signedAttrs)->val[i], &elen, eret);
2024if(eret) {
2025i--;
2026while (i >= 0) {
2027free(val[i].data);
2028i--;
2029}
2030free(val);
2031return eret;
2032}
2033totallen += elen;
2034}
2035if (totallen > len) {
2036for (i = 0; i < (int)((data)->signedAttrs)->len; i++) {
2037free(val[i].data);
2038}
2039free(val);
2040return ASN1_OVERFLOW;
2041}
2042qsort(val, ((data)->signedAttrs)->len, sizeof(val[0]), _heim_der_set_sort);
2043for(i = (int)((data)->signedAttrs)->len - 1; i >= 0; --i) {
2044p -= val[i].length;
2045ret += val[i].length;
2046memcpy(p + 1, val[i].data, val[i].length);
2047free(val[i].data);
2048}
2049free(val);
2050}
2051e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2052if (e) return e;
2053p -= l; len -= l; ret += l;
2054
2055ret += Top_tag_oldret;
2056}
2057/* digestAlgorithm */
2058{
2059size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2060ret = 0;
2061e = encode_DigestAlgorithmIdentifier(p, len, &(data)->digestAlgorithm, &l);
2062if (e) return e;
2063p -= l; len -= l; ret += l;
2064
2065ret += Top_tag_oldret;
2066}
2067/* sid */
2068{
2069size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2070ret = 0;
2071e = encode_SignerIdentifier(p, len, &(data)->sid, &l);
2072if (e) return e;
2073p -= l; len -= l; ret += l;
2074
2075ret += Top_tag_oldret;
2076}
2077/* version */
2078{
2079size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2080ret = 0;
2081e = encode_CMSVersion(p, len, &(data)->version, &l);
2082if (e) return e;
2083p -= l; len -= l; ret += l;
2084
2085ret += Top_tag_oldret;
2086}
2087e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2088if (e) return e;
2089p -= l; len -= l; ret += l;
2090
2091*size = ret;
2092return 0;
2093}
2094
2095int ASN1CALL
2096decode_SignerInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SignerInfo *data, size_t *size)
2097{
2098size_t ret = 0;
2099size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2100int e HEIMDAL_UNUSED_ATTRIBUTE;
2101
2102memset(data, 0, sizeof(*data));
2103{
2104size_t Top_datalen, Top_oldlen;
2105Der_type Top_type;
2106int is_indefinite1;
2107e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2108if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2109if(e) goto fail;
2110p += l; len -= l; ret += l;
2111Top_oldlen = len;
2112if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
2113{ e = ASN1_BAD_FORMAT; goto fail; }
2114if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_CMSVersion(p, len, &(data)->version, &l);
2115if(e) goto fail;
2116p += l; len -= l; ret += l;
2117e = decode_SignerIdentifier(p, len, &(data)->sid, &l);
2118if(e) goto fail;
2119p += l; len -= l; ret += l;
2120e = decode_DigestAlgorithmIdentifier(p, len, &(data)->digestAlgorithm, &l);
2121if(e) goto fail;
2122p += l; len -= l; ret += l;
2123{
2124size_t signedAttrs_datalen, signedAttrs_oldlen;
2125Der_type signedAttrs_type;
2126int is_indefinite3;
2127e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &signedAttrs_type, 0, &signedAttrs_datalen, &l);
2128if (e == 0 && signedAttrs_type != CONS) { e = ASN1_BAD_ID; }
2129if(e) {
2130(data)->signedAttrs = NULL;
2131} else {
2132(data)->signedAttrs = calloc(1, sizeof(*(data)->signedAttrs));
2133if ((data)->signedAttrs == NULL) { e = ENOMEM; goto fail; }
2134p += l; len -= l; ret += l;
2135signedAttrs_oldlen = len;
2136if((is_indefinite3 = _heim_fix_dce(signedAttrs_datalen, &len)) < 0)
2137{ e = ASN1_BAD_FORMAT; goto fail; }
2138if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
2139size_t signedAttrs_Tag_origlen = len;
2140size_t signedAttrs_Tag_oldret = ret;
2141size_t signedAttrs_Tag_olen = 0;
2142void *signedAttrs_Tag_tmp;
2143ret = 0;
2144((data)->signedAttrs)->len = 0;
2145((data)->signedAttrs)->val = NULL;
2146while(ret < signedAttrs_Tag_origlen) {
2147size_t signedAttrs_Tag_nlen = signedAttrs_Tag_olen + sizeof(*(((data)->signedAttrs)->val));
2148if (signedAttrs_Tag_olen > signedAttrs_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2149signedAttrs_Tag_olen = signedAttrs_Tag_nlen;
2150signedAttrs_Tag_tmp = realloc(((data)->signedAttrs)->val, signedAttrs_Tag_olen);
2151if (signedAttrs_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2152((data)->signedAttrs)->val = signedAttrs_Tag_tmp;
2153e = decode_Attribute(p, len, &((data)->signedAttrs)->val[((data)->signedAttrs)->len], &l);
2154if(e) goto fail;
2155p += l; len -= l; ret += l;
2156((data)->signedAttrs)->len++;
2157len = signedAttrs_Tag_origlen - ret;
2158}
2159ret += signedAttrs_Tag_oldret;
2160}
2161if(is_indefinite3){
2162len += 2;
2163e = der_match_tag_and_length(p, len, (Der_class)0, &signedAttrs_type, UT_EndOfContent, &signedAttrs_datalen, &l);
2164if(e) goto fail;
2165p += l; len -= l; ret += l;
2166if (signedAttrs_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
2167} else
2168len = signedAttrs_oldlen - signedAttrs_datalen;
2169}
2170}
2171e = decode_SignatureAlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
2172if(e) goto fail;
2173p += l; len -= l; ret += l;
2174e = decode_SignatureValue(p, len, &(data)->signature, &l);
2175if(e) goto fail;
2176p += l; len -= l; ret += l;
2177{
2178size_t unsignedAttrs_datalen, unsignedAttrs_oldlen;
2179Der_type unsignedAttrs_type;
2180int is_indefinite3;
2181e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &unsignedAttrs_type, 1, &unsignedAttrs_datalen, &l);
2182if (e == 0 && unsignedAttrs_type != CONS) { e = ASN1_BAD_ID; }
2183if(e) {
2184(data)->unsignedAttrs = NULL;
2185} else {
2186(data)->unsignedAttrs = calloc(1, sizeof(*(data)->unsignedAttrs));
2187if ((data)->unsignedAttrs == NULL) { e = ENOMEM; goto fail; }
2188p += l; len -= l; ret += l;
2189unsignedAttrs_oldlen = len;
2190if((is_indefinite3 = _heim_fix_dce(unsignedAttrs_datalen, &len)) < 0)
2191{ e = ASN1_BAD_FORMAT; goto fail; }
2192if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
2193size_t unsignedAttrs_Tag_origlen = len;
2194size_t unsignedAttrs_Tag_oldret = ret;
2195size_t unsignedAttrs_Tag_olen = 0;
2196void *unsignedAttrs_Tag_tmp;
2197ret = 0;
2198((data)->unsignedAttrs)->len = 0;
2199((data)->unsignedAttrs)->val = NULL;
2200while(ret < unsignedAttrs_Tag_origlen) {
2201size_t unsignedAttrs_Tag_nlen = unsignedAttrs_Tag_olen + sizeof(*(((data)->unsignedAttrs)->val));
2202if (unsignedAttrs_Tag_olen > unsignedAttrs_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2203unsignedAttrs_Tag_olen = unsignedAttrs_Tag_nlen;
2204unsignedAttrs_Tag_tmp = realloc(((data)->unsignedAttrs)->val, unsignedAttrs_Tag_olen);
2205if (unsignedAttrs_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2206((data)->unsignedAttrs)->val = unsignedAttrs_Tag_tmp;
2207e = decode_Attribute(p, len, &((data)->unsignedAttrs)->val[((data)->unsignedAttrs)->len], &l);
2208if(e) goto fail;
2209p += l; len -= l; ret += l;
2210((data)->unsignedAttrs)->len++;
2211len = unsignedAttrs_Tag_origlen - ret;
2212}
2213ret += unsignedAttrs_Tag_oldret;
2214}
2215if(is_indefinite3){
2216len += 2;
2217e = der_match_tag_and_length(p, len, (Der_class)0, &unsignedAttrs_type, UT_EndOfContent, &unsignedAttrs_datalen, &l);
2218if(e) goto fail;
2219p += l; len -= l; ret += l;
2220if (unsignedAttrs_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
2221} else
2222len = unsignedAttrs_oldlen - unsignedAttrs_datalen;
2223}
2224}
2225if(is_indefinite1){
2226len += 2;
2227e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
2228if(e) goto fail;
2229p += l; len -= l; ret += l;
2230if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
2231} else
2232len = Top_oldlen - Top_datalen;
2233}
2234if(size) *size = ret;
2235return 0;
2236fail:
2237free_SignerInfo(data);
2238return e;
2239}
2240
2241void ASN1CALL
2242free_SignerInfo(SignerInfo *data)
2243{
2244free_CMSVersion(&(data)->version);
2245free_SignerIdentifier(&(data)->sid);
2246free_DigestAlgorithmIdentifier(&(data)->digestAlgorithm);
2247if((data)->signedAttrs) {
2248while(((data)->signedAttrs)->len){
2249free_Attribute(&((data)->signedAttrs)->val[((data)->signedAttrs)->len-1]);
2250((data)->signedAttrs)->len--;
2251}
2252free(((data)->signedAttrs)->val);
2253((data)->signedAttrs)->val = NULL;
2254free((data)->signedAttrs);
2255(data)->signedAttrs = NULL;
2256}
2257free_SignatureAlgorithmIdentifier(&(data)->signatureAlgorithm);
2258free_SignatureValue(&(data)->signature);
2259if((data)->unsignedAttrs) {
2260while(((data)->unsignedAttrs)->len){
2261free_Attribute(&((data)->unsignedAttrs)->val[((data)->unsignedAttrs)->len-1]);
2262((data)->unsignedAttrs)->len--;
2263}
2264free(((data)->unsignedAttrs)->val);
2265((data)->unsignedAttrs)->val = NULL;
2266free((data)->unsignedAttrs);
2267(data)->unsignedAttrs = NULL;
2268}
2269}
2270
2271size_t ASN1CALL
2272length_SignerInfo(const SignerInfo *data)
2273{
2274size_t ret = 0;
2275{
2276size_t Top_tag_oldret = ret;
2277ret = 0;
2278ret += length_CMSVersion(&(data)->version);
2279ret += Top_tag_oldret;
2280}
2281{
2282size_t Top_tag_oldret = ret;
2283ret = 0;
2284ret += length_SignerIdentifier(&(data)->sid);
2285ret += Top_tag_oldret;
2286}
2287{
2288size_t Top_tag_oldret = ret;
2289ret = 0;
2290ret += length_DigestAlgorithmIdentifier(&(data)->digestAlgorithm);
2291ret += Top_tag_oldret;
2292}
2293if((data)->signedAttrs){
2294size_t Top_tag_oldret = ret;
2295ret = 0;
2296{
2297size_t signedAttrs_tag_oldret = ret;
2298unsigned int n_signedAttrs_tag;
2299ret = 0;
2300for(n_signedAttrs_tag = ((data)->signedAttrs)->len; n_signedAttrs_tag > 0; --n_signedAttrs_tag){
2301size_t signedAttrs_tag_for_oldret = ret;
2302ret = 0;
2303ret += length_Attribute(&((data)->signedAttrs)->val[n_signedAttrs_tag - 1]);
2304ret += signedAttrs_tag_for_oldret;
2305}
2306ret += signedAttrs_tag_oldret;
2307}
2308ret += 1 + der_length_len (ret);
2309ret += Top_tag_oldret;
2310}
2311{
2312size_t Top_tag_oldret = ret;
2313ret = 0;
2314ret += length_SignatureAlgorithmIdentifier(&(data)->signatureAlgorithm);
2315ret += Top_tag_oldret;
2316}
2317{
2318size_t Top_tag_oldret = ret;
2319ret = 0;
2320ret += length_SignatureValue(&(data)->signature);
2321ret += Top_tag_oldret;
2322}
2323if((data)->unsignedAttrs){
2324size_t Top_tag_oldret = ret;
2325ret = 0;
2326{
2327size_t unsignedAttrs_tag_oldret = ret;
2328unsigned int n_unsignedAttrs_tag;
2329ret = 0;
2330for(n_unsignedAttrs_tag = ((data)->unsignedAttrs)->len; n_unsignedAttrs_tag > 0; --n_unsignedAttrs_tag){
2331size_t unsignedAttrs_tag_for_oldret = ret;
2332ret = 0;
2333ret += length_Attribute(&((data)->unsignedAttrs)->val[n_unsignedAttrs_tag - 1]);
2334ret += unsignedAttrs_tag_for_oldret;
2335}
2336ret += unsignedAttrs_tag_oldret;
2337}
2338ret += 1 + der_length_len (ret);
2339ret += Top_tag_oldret;
2340}
2341ret += 1 + der_length_len (ret);
2342return ret;
2343}
2344
2345int ASN1CALL
2346copy_SignerInfo(const SignerInfo *from, SignerInfo *to)
2347{
2348memset(to, 0, sizeof(*to));
2349if(copy_CMSVersion(&(from)->version, &(to)->version)) goto fail;
2350if(copy_SignerIdentifier(&(from)->sid, &(to)->sid)) goto fail;
2351if(copy_DigestAlgorithmIdentifier(&(from)->digestAlgorithm, &(to)->digestAlgorithm)) goto fail;
2352if((from)->signedAttrs) {
2353(to)->signedAttrs = malloc(sizeof(*(to)->signedAttrs));
2354if((to)->signedAttrs == NULL) goto fail;
2355if((((to)->signedAttrs)->val = malloc(((from)->signedAttrs)->len * sizeof(*((to)->signedAttrs)->val))) == NULL && ((from)->signedAttrs)->len != 0)
2356goto fail;
2357for(((to)->signedAttrs)->len = 0; ((to)->signedAttrs)->len < ((from)->signedAttrs)->len; ((to)->signedAttrs)->len++){
2358if(copy_Attribute(&((from)->signedAttrs)->val[((to)->signedAttrs)->len], &((to)->signedAttrs)->val[((to)->signedAttrs)->len])) goto fail;
2359}
2360}else
2361(to)->signedAttrs = NULL;
2362if(copy_SignatureAlgorithmIdentifier(&(from)->signatureAlgorithm, &(to)->signatureAlgorithm)) goto fail;
2363if(copy_SignatureValue(&(from)->signature, &(to)->signature)) goto fail;
2364if((from)->unsignedAttrs) {
2365(to)->unsignedAttrs = malloc(sizeof(*(to)->unsignedAttrs));
2366if((to)->unsignedAttrs == NULL) goto fail;
2367if((((to)->unsignedAttrs)->val = malloc(((from)->unsignedAttrs)->len * sizeof(*((to)->unsignedAttrs)->val))) == NULL && ((from)->unsignedAttrs)->len != 0)
2368goto fail;
2369for(((to)->unsignedAttrs)->len = 0; ((to)->unsignedAttrs)->len < ((from)->unsignedAttrs)->len; ((to)->unsignedAttrs)->len++){
2370if(copy_Attribute(&((from)->unsignedAttrs)->val[((to)->unsignedAttrs)->len], &((to)->unsignedAttrs)->val[((to)->unsignedAttrs)->len])) goto fail;
2371}
2372}else
2373(to)->unsignedAttrs = NULL;
2374return 0;
2375fail:
2376free_SignerInfo(to);
2377return ENOMEM;
2378}
2379
2380int ASN1CALL
2381encode_SignerInfos(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SignerInfos *data, size_t *size)
2382{
2383size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2384size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2385int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2386
2387{
2388heim_octet_string *val;
2389size_t elen = 0, totallen = 0;
2390int eret = 0;
2391if ((data)->len > UINT_MAX/sizeof(val[0]))
2392return ERANGE;
2393val = malloc(sizeof(val[0]) * (data)->len);
2394if (val == NULL && (data)->len != 0) return ENOMEM;
2395for(i = 0; i < (int)(data)->len; i++) {
2396ASN1_MALLOC_ENCODE(SignerInfo, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
2397if(eret) {
2398i--;
2399while (i >= 0) {
2400free(val[i].data);
2401i--;
2402}
2403free(val);
2404return eret;
2405}
2406totallen += elen;
2407}
2408if (totallen > len) {
2409for (i = 0; i < (int)(data)->len; i++) {
2410free(val[i].data);
2411}
2412free(val);
2413return ASN1_OVERFLOW;
2414}
2415qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
2416for(i = (int)(data)->len - 1; i >= 0; --i) {
2417p -= val[i].length;
2418ret += val[i].length;
2419memcpy(p + 1, val[i].data, val[i].length);
2420free(val[i].data);
2421}
2422free(val);
2423}
2424e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
2425if (e) return e;
2426p -= l; len -= l; ret += l;
2427
2428*size = ret;
2429return 0;
2430}
2431
2432int ASN1CALL
2433decode_SignerInfos(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SignerInfos *data, size_t *size)
2434{
2435size_t ret = 0;
2436size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2437int e HEIMDAL_UNUSED_ATTRIBUTE;
2438
2439memset(data, 0, sizeof(*data));
2440{
2441size_t Top_datalen, Top_oldlen;
2442Der_type Top_type;
2443int is_indefinite1;
2444e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
2445if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2446if(e) goto fail;
2447p += l; len -= l; ret += l;
2448Top_oldlen = len;
2449if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
2450{ e = ASN1_BAD_FORMAT; goto fail; }
2451if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
2452size_t Top_Tag_origlen = len;
2453size_t Top_Tag_oldret = ret;
2454size_t Top_Tag_olen = 0;
2455void *Top_Tag_tmp;
2456ret = 0;
2457(data)->len = 0;
2458(data)->val = NULL;
2459while(ret < Top_Tag_origlen) {
2460size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
2461if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2462Top_Tag_olen = Top_Tag_nlen;
2463Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
2464if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2465(data)->val = Top_Tag_tmp;
2466e = decode_SignerInfo(p, len, &(data)->val[(data)->len], &l);
2467if(e) goto fail;
2468p += l; len -= l; ret += l;
2469(data)->len++;
2470len = Top_Tag_origlen - ret;
2471}
2472ret += Top_Tag_oldret;
2473}
2474if(is_indefinite1){
2475len += 2;
2476e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
2477if(e) goto fail;
2478p += l; len -= l; ret += l;
2479if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
2480} else
2481len = Top_oldlen - Top_datalen;
2482}
2483if(size) *size = ret;
2484return 0;
2485fail:
2486free_SignerInfos(data);
2487return e;
2488}
2489
2490void ASN1CALL
2491free_SignerInfos(SignerInfos *data)
2492{
2493while((data)->len){
2494free_SignerInfo(&(data)->val[(data)->len-1]);
2495(data)->len--;
2496}
2497free((data)->val);
2498(data)->val = NULL;
2499}
2500
2501size_t ASN1CALL
2502length_SignerInfos(const SignerInfos *data)
2503{
2504size_t ret = 0;
2505{
2506size_t Top_tag_oldret = ret;
2507unsigned int n_Top_tag;
2508ret = 0;
2509for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
2510size_t Top_tag_for_oldret = ret;
2511ret = 0;
2512ret += length_SignerInfo(&(data)->val[n_Top_tag - 1]);
2513ret += Top_tag_for_oldret;
2514}
2515ret += Top_tag_oldret;
2516}
2517ret += 1 + der_length_len (ret);
2518return ret;
2519}
2520
2521int ASN1CALL
2522copy_SignerInfos(const SignerInfos *from, SignerInfos *to)
2523{
2524memset(to, 0, sizeof(*to));
2525if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
2526goto fail;
2527for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
2528if(copy_SignerInfo(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
2529}
2530return 0;
2531fail:
2532free_SignerInfos(to);
2533return ENOMEM;
2534}
2535
2536int ASN1CALL
2537encode_SignedData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SignedData *data, size_t *size)
2538{
2539size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2540size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2541int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2542
2543/* signerInfos */
2544{
2545size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2546ret = 0;
2547e = encode_SignerInfos(p, len, &(data)->signerInfos, &l);
2548if (e) return e;
2549p -= l; len -= l; ret += l;
2550
2551ret += Top_tag_oldret;
2552}
2553/* crls */
2554if((data)->crls) {
2555size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2556ret = 0;
2557e = encode_heim_any(p, len, (data)->crls, &l);
2558if (e) return e;
2559p -= l; len -= l; ret += l;
2560
2561e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2562if (e) return e;
2563p -= l; len -= l; ret += l;
2564
2565ret += Top_tag_oldret;
2566}
2567/* certificates */
2568if((data)->certificates) {
2569size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2570ret = 0;
2571{
2572heim_octet_string *val;
2573size_t elen = 0, totallen = 0;
2574int eret = 0;
2575if (((data)->certificates)->len > UINT_MAX/sizeof(val[0]))
2576return ERANGE;
2577val = malloc(sizeof(val[0]) * ((data)->certificates)->len);
2578if (val == NULL && ((data)->certificates)->len != 0) return ENOMEM;
2579for(i = 0; i < (int)((data)->certificates)->len; i++) {
2580ASN1_MALLOC_ENCODE(heim_any, val[i].data, val[i].length, &((data)->certificates)->val[i], &elen, eret);
2581if(eret) {
2582i--;
2583while (i >= 0) {
2584free(val[i].data);
2585i--;
2586}
2587free(val);
2588return eret;
2589}
2590totallen += elen;
2591}
2592if (totallen > len) {
2593for (i = 0; i < (int)((data)->certificates)->len; i++) {
2594free(val[i].data);
2595}
2596free(val);
2597return ASN1_OVERFLOW;
2598}
2599qsort(val, ((data)->certificates)->len, sizeof(val[0]), _heim_der_set_sort);
2600for(i = (int)((data)->certificates)->len - 1; i >= 0; --i) {
2601p -= val[i].length;
2602ret += val[i].length;
2603memcpy(p + 1, val[i].data, val[i].length);
2604free(val[i].data);
2605}
2606free(val);
2607}
2608e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2609if (e) return e;
2610p -= l; len -= l; ret += l;
2611
2612ret += Top_tag_oldret;
2613}
2614/* encapContentInfo */
2615{
2616size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2617ret = 0;
2618e = encode_EncapsulatedContentInfo(p, len, &(data)->encapContentInfo, &l);
2619if (e) return e;
2620p -= l; len -= l; ret += l;
2621
2622ret += Top_tag_oldret;
2623}
2624/* digestAlgorithms */
2625{
2626size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2627ret = 0;
2628e = encode_DigestAlgorithmIdentifiers(p, len, &(data)->digestAlgorithms, &l);
2629if (e) return e;
2630p -= l; len -= l; ret += l;
2631
2632ret += Top_tag_oldret;
2633}
2634/* version */
2635{
2636size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2637ret = 0;
2638e = encode_CMSVersion(p, len, &(data)->version, &l);
2639if (e) return e;
2640p -= l; len -= l; ret += l;
2641
2642ret += Top_tag_oldret;
2643}
2644e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2645if (e) return e;
2646p -= l; len -= l; ret += l;
2647
2648*size = ret;
2649return 0;
2650}
2651
2652int ASN1CALL
2653decode_SignedData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SignedData *data, size_t *size)
2654{
2655size_t ret = 0;
2656size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2657int e HEIMDAL_UNUSED_ATTRIBUTE;
2658
2659memset(data, 0, sizeof(*data));
2660{
2661size_t Top_datalen, Top_oldlen;
2662Der_type Top_type;
2663int is_indefinite1;
2664e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2665if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2666if(e) goto fail;
2667p += l; len -= l; ret += l;
2668Top_oldlen = len;
2669if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
2670{ e = ASN1_BAD_FORMAT; goto fail; }
2671if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_CMSVersion(p, len, &(data)->version, &l);
2672if(e) goto fail;
2673p += l; len -= l; ret += l;
2674e = decode_DigestAlgorithmIdentifiers(p, len, &(data)->digestAlgorithms, &l);
2675if(e) goto fail;
2676p += l; len -= l; ret += l;
2677e = decode_EncapsulatedContentInfo(p, len, &(data)->encapContentInfo, &l);
2678if(e) goto fail;
2679p += l; len -= l; ret += l;
2680{
2681size_t certificates_datalen, certificates_oldlen;
2682Der_type certificates_type;
2683int is_indefinite3;
2684e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &certificates_type, 0, &certificates_datalen, &l);
2685if (e == 0 && certificates_type != CONS) { e = ASN1_BAD_ID; }
2686if(e) {
2687(data)->certificates = NULL;
2688} else {
2689(data)->certificates = calloc(1, sizeof(*(data)->certificates));
2690if ((data)->certificates == NULL) { e = ENOMEM; goto fail; }
2691p += l; len -= l; ret += l;
2692certificates_oldlen = len;
2693if((is_indefinite3 = _heim_fix_dce(certificates_datalen, &len)) < 0)
2694{ e = ASN1_BAD_FORMAT; goto fail; }
2695if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
2696size_t certificates_Tag_origlen = len;
2697size_t certificates_Tag_oldret = ret;
2698size_t certificates_Tag_olen = 0;
2699void *certificates_Tag_tmp;
2700ret = 0;
2701((data)->certificates)->len = 0;
2702((data)->certificates)->val = NULL;
2703while(ret < certificates_Tag_origlen) {
2704size_t certificates_Tag_nlen = certificates_Tag_olen + sizeof(*(((data)->certificates)->val));
2705if (certificates_Tag_olen > certificates_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
2706certificates_Tag_olen = certificates_Tag_nlen;
2707certificates_Tag_tmp = realloc(((data)->certificates)->val, certificates_Tag_olen);
2708if (certificates_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
2709((data)->certificates)->val = certificates_Tag_tmp;
2710e = decode_heim_any(p, len, &((data)->certificates)->val[((data)->certificates)->len], &l);
2711if(e) goto fail;
2712p += l; len -= l; ret += l;
2713((data)->certificates)->len++;
2714len = certificates_Tag_origlen - ret;
2715}
2716ret += certificates_Tag_oldret;
2717}
2718if(is_indefinite3){
2719len += 2;
2720e = der_match_tag_and_length(p, len, (Der_class)0, &certificates_type, UT_EndOfContent, &certificates_datalen, &l);
2721if(e) goto fail;
2722p += l; len -= l; ret += l;
2723if (certificates_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
2724} else
2725len = certificates_oldlen - certificates_datalen;
2726}
2727}
2728{
2729size_t crls_datalen, crls_oldlen;
2730Der_type crls_type;
2731int is_indefinite3;
2732e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crls_type, 1, &crls_datalen, &l);
2733if (e == 0 && crls_type != CONS) { e = ASN1_BAD_ID; }
2734if(e) {
2735(data)->crls = NULL;
2736} else {
2737(data)->crls = calloc(1, sizeof(*(data)->crls));
2738if ((data)->crls == NULL) { e = ENOMEM; goto fail; }
2739p += l; len -= l; ret += l;
2740crls_oldlen = len;
2741if((is_indefinite3 = _heim_fix_dce(crls_datalen, &len)) < 0)
2742{ e = ASN1_BAD_FORMAT; goto fail; }
2743if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_heim_any(p, len, (data)->crls, &l);
2744if(e) goto fail;
2745p += l; len -= l; ret += l;
2746if(is_indefinite3){
2747len += 2;
2748e = der_match_tag_and_length(p, len, (Der_class)0, &crls_type, UT_EndOfContent, &crls_datalen, &l);
2749if(e) goto fail;
2750p += l; len -= l; ret += l;
2751if (crls_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
2752} else
2753len = crls_oldlen - crls_datalen;
2754}
2755}
2756e = decode_SignerInfos(p, len, &(data)->signerInfos, &l);
2757if(e) goto fail;
2758p += l; len -= l; ret += l;
2759if(is_indefinite1){
2760len += 2;
2761e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
2762if(e) goto fail;
2763p += l; len -= l; ret += l;
2764if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
2765} else
2766len = Top_oldlen - Top_datalen;
2767}
2768if(size) *size = ret;
2769return 0;
2770fail:
2771free_SignedData(data);
2772return e;
2773}
2774
2775void ASN1CALL
2776free_SignedData(SignedData *data)
2777{
2778free_CMSVersion(&(data)->version);
2779free_DigestAlgorithmIdentifiers(&(data)->digestAlgorithms);
2780free_EncapsulatedContentInfo(&(data)->encapContentInfo);
2781if((data)->certificates) {
2782while(((data)->certificates)->len){
2783free_heim_any(&((data)->certificates)->val[((data)->certificates)->len-1]);
2784((data)->certificates)->len--;
2785}
2786free(((data)->certificates)->val);
2787((data)->certificates)->val = NULL;
2788free((data)->certificates);
2789(data)->certificates = NULL;
2790}
2791if((data)->crls) {
2792free_heim_any((data)->crls);
2793free((data)->crls);
2794(data)->crls = NULL;
2795}
2796free_SignerInfos(&(data)->signerInfos);
2797}
2798
2799size_t ASN1CALL
2800length_SignedData(const SignedData *data)
2801{
2802size_t ret = 0;
2803{
2804size_t Top_tag_oldret = ret;
2805ret = 0;
2806ret += length_CMSVersion(&(data)->version);
2807ret += Top_tag_oldret;
2808}
2809{
2810size_t Top_tag_oldret = ret;
2811ret = 0;
2812ret += length_DigestAlgorithmIdentifiers(&(data)->digestAlgorithms);
2813ret += Top_tag_oldret;
2814}
2815{
2816size_t Top_tag_oldret = ret;
2817ret = 0;
2818ret += length_EncapsulatedContentInfo(&(data)->encapContentInfo);
2819ret += Top_tag_oldret;
2820}
2821if((data)->certificates){
2822size_t Top_tag_oldret = ret;
2823ret = 0;
2824{
2825size_t certificates_tag_oldret = ret;
2826unsigned int n_certificates_tag;
2827ret = 0;
2828for(n_certificates_tag = ((data)->certificates)->len; n_certificates_tag > 0; --n_certificates_tag){
2829size_t certificates_tag_for_oldret = ret;
2830ret = 0;
2831ret += length_heim_any(&((data)->certificates)->val[n_certificates_tag - 1]);
2832ret += certificates_tag_for_oldret;
2833}
2834ret += certificates_tag_oldret;
2835}
2836ret += 1 + der_length_len (ret);
2837ret += Top_tag_oldret;
2838}
2839if((data)->crls){
2840size_t Top_tag_oldret = ret;
2841ret = 0;
2842ret += length_heim_any((data)->crls);
2843ret += 1 + der_length_len (ret);
2844ret += Top_tag_oldret;
2845}
2846{
2847size_t Top_tag_oldret = ret;
2848ret = 0;
2849ret += length_SignerInfos(&(data)->signerInfos);
2850ret += Top_tag_oldret;
2851}
2852ret += 1 + der_length_len (ret);
2853return ret;
2854}
2855
2856int ASN1CALL
2857copy_SignedData(const SignedData *from, SignedData *to)
2858{
2859memset(to, 0, sizeof(*to));
2860if(copy_CMSVersion(&(from)->version, &(to)->version)) goto fail;
2861if(copy_DigestAlgorithmIdentifiers(&(from)->digestAlgorithms, &(to)->digestAlgorithms)) goto fail;
2862if(copy_EncapsulatedContentInfo(&(from)->encapContentInfo, &(to)->encapContentInfo)) goto fail;
2863if((from)->certificates) {
2864(to)->certificates = malloc(sizeof(*(to)->certificates));
2865if((to)->certificates == NULL) goto fail;
2866if((((to)->certificates)->val = malloc(((from)->certificates)->len * sizeof(*((to)->certificates)->val))) == NULL && ((from)->certificates)->len != 0)
2867goto fail;
2868for(((to)->certificates)->len = 0; ((to)->certificates)->len < ((from)->certificates)->len; ((to)->certificates)->len++){
2869if(copy_heim_any(&((from)->certificates)->val[((to)->certificates)->len], &((to)->certificates)->val[((to)->certificates)->len])) goto fail;
2870}
2871}else
2872(to)->certificates = NULL;
2873if((from)->crls) {
2874(to)->crls = malloc(sizeof(*(to)->crls));
2875if((to)->crls == NULL) goto fail;
2876if(copy_heim_any((from)->crls, (to)->crls)) goto fail;
2877}else
2878(to)->crls = NULL;
2879if(copy_SignerInfos(&(from)->signerInfos, &(to)->signerInfos)) goto fail;
2880return 0;
2881fail:
2882free_SignedData(to);
2883return ENOMEM;
2884}
2885
2886int ASN1CALL
2887encode_OriginatorInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const OriginatorInfo *data, size_t *size)
2888{
2889size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2890size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2891int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2892
2893/* crls */
2894if((data)->crls) {
2895size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2896ret = 0;
2897e = encode_heim_any(p, len, (data)->crls, &l);
2898if (e) return e;
2899p -= l; len -= l; ret += l;
2900
2901e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2902if (e) return e;
2903p -= l; len -= l; ret += l;
2904
2905ret += Top_tag_oldret;
2906}
2907/* certs */
2908if((data)->certs) {
2909size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2910ret = 0;
2911{
2912heim_octet_string *val;
2913size_t elen = 0, totallen = 0;
2914int eret = 0;
2915if (((data)->certs)->len > UINT_MAX/sizeof(val[0]))
2916return ERANGE;
2917val = malloc(sizeof(val[0]) * ((data)->certs)->len);
2918if (val == NULL && ((data)->certs)->len != 0) return ENOMEM;
2919for(i = 0; i < (int)((data)->certs)->len; i++) {
2920ASN1_MALLOC_ENCODE(heim_any, val[i].data, val[i].length, &((data)->certs)->val[i], &elen, eret);
2921if(eret) {
2922i--;
2923while (i >= 0) {
2924free(val[i].data);
2925i--;
2926}
2927free(val);
2928return eret;
2929}
2930totallen += elen;
2931}
2932if (totallen > len) {
2933for (i = 0; i < (int)((data)->certs)->len; i++) {
2934free(val[i].data);
2935}
2936free(val);
2937return ASN1_OVERFLOW;
2938}
2939qsort(val, ((data)->certs)->len, sizeof(val[0]), _heim_der_set_sort);
2940for(i = (int)((data)->certs)->len - 1; i >= 0; --i) {
2941p -= val[i].length;
2942ret += val[i].length;
2943memcpy(p + 1, val[i].data, val[i].length);
2944free(val[i].data);
2945}
2946free(val);
2947}
2948e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2949if (e) return e;
2950p -= l; len -= l; ret += l;
2951
2952ret += Top_tag_oldret;
2953}
2954e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
2955if (e) return e;
2956p -= l; len -= l; ret += l;
2957
2958*size = ret;
2959return 0;
2960}
2961
2962int ASN1CALL
2963decode_OriginatorInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, OriginatorInfo *data, size_t *size)
2964{
2965size_t ret = 0;
2966size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2967int e HEIMDAL_UNUSED_ATTRIBUTE;
2968
2969memset(data, 0, sizeof(*data));
2970{
2971size_t Top_datalen, Top_oldlen;
2972Der_type Top_type;
2973int is_indefinite1;
2974e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
2975if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
2976if(e) goto fail;
2977p += l; len -= l; ret += l;
2978Top_oldlen = len;
2979if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
2980{ e = ASN1_BAD_FORMAT; goto fail; }
2981if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
2982size_t certs_datalen, certs_oldlen;
2983Der_type certs_type;
2984int is_indefinite3;
2985e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &certs_type, 0, &certs_datalen, &l);
2986if (e == 0 && certs_type != CONS) { e = ASN1_BAD_ID; }
2987if(e) {
2988(data)->certs = NULL;
2989} else {
2990(data)->certs = calloc(1, sizeof(*(data)->certs));
2991if ((data)->certs == NULL) { e = ENOMEM; goto fail; }
2992p += l; len -= l; ret += l;
2993certs_oldlen = len;
2994if((is_indefinite3 = _heim_fix_dce(certs_datalen, &len)) < 0)
2995{ e = ASN1_BAD_FORMAT; goto fail; }
2996if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
2997size_t certs_Tag_origlen = len;
2998size_t certs_Tag_oldret = ret;
2999size_t certs_Tag_olen = 0;
3000void *certs_Tag_tmp;
3001ret = 0;
3002((data)->certs)->len = 0;
3003((data)->certs)->val = NULL;
3004while(ret < certs_Tag_origlen) {
3005size_t certs_Tag_nlen = certs_Tag_olen + sizeof(*(((data)->certs)->val));
3006if (certs_Tag_olen > certs_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
3007certs_Tag_olen = certs_Tag_nlen;
3008certs_Tag_tmp = realloc(((data)->certs)->val, certs_Tag_olen);
3009if (certs_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
3010((data)->certs)->val = certs_Tag_tmp;
3011e = decode_heim_any(p, len, &((data)->certs)->val[((data)->certs)->len], &l);
3012if(e) goto fail;
3013p += l; len -= l; ret += l;
3014((data)->certs)->len++;
3015len = certs_Tag_origlen - ret;
3016}
3017ret += certs_Tag_oldret;
3018}
3019if(is_indefinite3){
3020len += 2;
3021e = der_match_tag_and_length(p, len, (Der_class)0, &certs_type, UT_EndOfContent, &certs_datalen, &l);
3022if(e) goto fail;
3023p += l; len -= l; ret += l;
3024if (certs_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3025} else
3026len = certs_oldlen - certs_datalen;
3027}
3028}
3029{
3030size_t crls_datalen, crls_oldlen;
3031Der_type crls_type;
3032int is_indefinite3;
3033e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crls_type, 1, &crls_datalen, &l);
3034if (e == 0 && crls_type != CONS) { e = ASN1_BAD_ID; }
3035if(e) {
3036(data)->crls = NULL;
3037} else {
3038(data)->crls = calloc(1, sizeof(*(data)->crls));
3039if ((data)->crls == NULL) { e = ENOMEM; goto fail; }
3040p += l; len -= l; ret += l;
3041crls_oldlen = len;
3042if((is_indefinite3 = _heim_fix_dce(crls_datalen, &len)) < 0)
3043{ e = ASN1_BAD_FORMAT; goto fail; }
3044if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_heim_any(p, len, (data)->crls, &l);
3045if(e) goto fail;
3046p += l; len -= l; ret += l;
3047if(is_indefinite3){
3048len += 2;
3049e = der_match_tag_and_length(p, len, (Der_class)0, &crls_type, UT_EndOfContent, &crls_datalen, &l);
3050if(e) goto fail;
3051p += l; len -= l; ret += l;
3052if (crls_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3053} else
3054len = crls_oldlen - crls_datalen;
3055}
3056}
3057if(is_indefinite1){
3058len += 2;
3059e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
3060if(e) goto fail;
3061p += l; len -= l; ret += l;
3062if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3063} else
3064len = Top_oldlen - Top_datalen;
3065}
3066if(size) *size = ret;
3067return 0;
3068fail:
3069free_OriginatorInfo(data);
3070return e;
3071}
3072
3073void ASN1CALL
3074free_OriginatorInfo(OriginatorInfo *data)
3075{
3076if((data)->certs) {
3077while(((data)->certs)->len){
3078free_heim_any(&((data)->certs)->val[((data)->certs)->len-1]);
3079((data)->certs)->len--;
3080}
3081free(((data)->certs)->val);
3082((data)->certs)->val = NULL;
3083free((data)->certs);
3084(data)->certs = NULL;
3085}
3086if((data)->crls) {
3087free_heim_any((data)->crls);
3088free((data)->crls);
3089(data)->crls = NULL;
3090}
3091}
3092
3093size_t ASN1CALL
3094length_OriginatorInfo(const OriginatorInfo *data)
3095{
3096size_t ret = 0;
3097if((data)->certs){
3098size_t Top_tag_oldret = ret;
3099ret = 0;
3100{
3101size_t certs_tag_oldret = ret;
3102unsigned int n_certs_tag;
3103ret = 0;
3104for(n_certs_tag = ((data)->certs)->len; n_certs_tag > 0; --n_certs_tag){
3105size_t certs_tag_for_oldret = ret;
3106ret = 0;
3107ret += length_heim_any(&((data)->certs)->val[n_certs_tag - 1]);
3108ret += certs_tag_for_oldret;
3109}
3110ret += certs_tag_oldret;
3111}
3112ret += 1 + der_length_len (ret);
3113ret += Top_tag_oldret;
3114}
3115if((data)->crls){
3116size_t Top_tag_oldret = ret;
3117ret = 0;
3118ret += length_heim_any((data)->crls);
3119ret += 1 + der_length_len (ret);
3120ret += Top_tag_oldret;
3121}
3122ret += 1 + der_length_len (ret);
3123return ret;
3124}
3125
3126int ASN1CALL
3127copy_OriginatorInfo(const OriginatorInfo *from, OriginatorInfo *to)
3128{
3129memset(to, 0, sizeof(*to));
3130if((from)->certs) {
3131(to)->certs = malloc(sizeof(*(to)->certs));
3132if((to)->certs == NULL) goto fail;
3133if((((to)->certs)->val = malloc(((from)->certs)->len * sizeof(*((to)->certs)->val))) == NULL && ((from)->certs)->len != 0)
3134goto fail;
3135for(((to)->certs)->len = 0; ((to)->certs)->len < ((from)->certs)->len; ((to)->certs)->len++){
3136if(copy_heim_any(&((from)->certs)->val[((to)->certs)->len], &((to)->certs)->val[((to)->certs)->len])) goto fail;
3137}
3138}else
3139(to)->certs = NULL;
3140if((from)->crls) {
3141(to)->crls = malloc(sizeof(*(to)->crls));
3142if((to)->crls == NULL) goto fail;
3143if(copy_heim_any((from)->crls, (to)->crls)) goto fail;
3144}else
3145(to)->crls = NULL;
3146return 0;
3147fail:
3148free_OriginatorInfo(to);
3149return ENOMEM;
3150}
3151
3152int ASN1CALL
3153encode_KeyEncryptionAlgorithmIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KeyEncryptionAlgorithmIdentifier *data, size_t *size)
3154{
3155size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3156size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3157int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3158
3159e = encode_AlgorithmIdentifier(p, len, data, &l);
3160if (e) return e;
3161p -= l; len -= l; ret += l;
3162
3163*size = ret;
3164return 0;
3165}
3166
3167int ASN1CALL
3168decode_KeyEncryptionAlgorithmIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KeyEncryptionAlgorithmIdentifier *data, size_t *size)
3169{
3170size_t ret = 0;
3171size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3172int e HEIMDAL_UNUSED_ATTRIBUTE;
3173
3174memset(data, 0, sizeof(*data));
3175e = decode_AlgorithmIdentifier(p, len, data, &l);
3176if(e) goto fail;
3177p += l; len -= l; ret += l;
3178if(size) *size = ret;
3179return 0;
3180fail:
3181free_KeyEncryptionAlgorithmIdentifier(data);
3182return e;
3183}
3184
3185void ASN1CALL
3186free_KeyEncryptionAlgorithmIdentifier(KeyEncryptionAlgorithmIdentifier *data)
3187{
3188free_AlgorithmIdentifier(data);
3189}
3190
3191size_t ASN1CALL
3192length_KeyEncryptionAlgorithmIdentifier(const KeyEncryptionAlgorithmIdentifier *data)
3193{
3194size_t ret = 0;
3195ret += length_AlgorithmIdentifier(data);
3196return ret;
3197}
3198
3199int ASN1CALL
3200copy_KeyEncryptionAlgorithmIdentifier(const KeyEncryptionAlgorithmIdentifier *from, KeyEncryptionAlgorithmIdentifier *to)
3201{
3202memset(to, 0, sizeof(*to));
3203if(copy_AlgorithmIdentifier(from, to)) goto fail;
3204return 0;
3205fail:
3206free_KeyEncryptionAlgorithmIdentifier(to);
3207return ENOMEM;
3208}
3209
3210int ASN1CALL
3211encode_ContentEncryptionAlgorithmIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ContentEncryptionAlgorithmIdentifier *data, size_t *size)
3212{
3213size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3214size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3215int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3216
3217e = encode_AlgorithmIdentifier(p, len, data, &l);
3218if (e) return e;
3219p -= l; len -= l; ret += l;
3220
3221*size = ret;
3222return 0;
3223}
3224
3225int ASN1CALL
3226decode_ContentEncryptionAlgorithmIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ContentEncryptionAlgorithmIdentifier *data, size_t *size)
3227{
3228size_t ret = 0;
3229size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3230int e HEIMDAL_UNUSED_ATTRIBUTE;
3231
3232memset(data, 0, sizeof(*data));
3233e = decode_AlgorithmIdentifier(p, len, data, &l);
3234if(e) goto fail;
3235p += l; len -= l; ret += l;
3236if(size) *size = ret;
3237return 0;
3238fail:
3239free_ContentEncryptionAlgorithmIdentifier(data);
3240return e;
3241}
3242
3243void ASN1CALL
3244free_ContentEncryptionAlgorithmIdentifier(ContentEncryptionAlgorithmIdentifier *data)
3245{
3246free_AlgorithmIdentifier(data);
3247}
3248
3249size_t ASN1CALL
3250length_ContentEncryptionAlgorithmIdentifier(const ContentEncryptionAlgorithmIdentifier *data)
3251{
3252size_t ret = 0;
3253ret += length_AlgorithmIdentifier(data);
3254return ret;
3255}
3256
3257int ASN1CALL
3258copy_ContentEncryptionAlgorithmIdentifier(const ContentEncryptionAlgorithmIdentifier *from, ContentEncryptionAlgorithmIdentifier *to)
3259{
3260memset(to, 0, sizeof(*to));
3261if(copy_AlgorithmIdentifier(from, to)) goto fail;
3262return 0;
3263fail:
3264free_ContentEncryptionAlgorithmIdentifier(to);
3265return ENOMEM;
3266}
3267
3268int ASN1CALL
3269encode_EncryptedKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncryptedKey *data, size_t *size)
3270{
3271size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3272size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3273int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3274
3275e = der_put_octet_string(p, len, data, &l);
3276if (e) return e;
3277p -= l; len -= l; ret += l;
3278
3279e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3280if (e) return e;
3281p -= l; len -= l; ret += l;
3282
3283*size = ret;
3284return 0;
3285}
3286
3287int ASN1CALL
3288decode_EncryptedKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncryptedKey *data, size_t *size)
3289{
3290size_t ret = 0;
3291size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3292int e HEIMDAL_UNUSED_ATTRIBUTE;
3293
3294memset(data, 0, sizeof(*data));
3295{
3296size_t Top_datalen, Top_oldlen;
3297Der_type Top_type;
3298int is_indefinite1;
3299e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
3300if(e) goto fail;
3301p += l; len -= l; ret += l;
3302Top_oldlen = len;
3303if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
3304{ e = ASN1_BAD_FORMAT; goto fail; }
3305if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }if (Top_type == CONS) {
3306e = der_get_octet_string_ber(p, len, data, &l);
3307if(e) goto fail;
3308p += l; len -= l; ret += l;
3309} else {
3310e = der_get_octet_string(p, len, data, &l);
3311if(e) goto fail;
3312p += l; len -= l; ret += l;
3313}
3314if(is_indefinite1){
3315len += 2;
3316e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
3317if(e) goto fail;
3318p += l; len -= l; ret += l;
3319if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3320} else
3321len = Top_oldlen - Top_datalen;
3322}
3323if(size) *size = ret;
3324return 0;
3325fail:
3326free_EncryptedKey(data);
3327return e;
3328}
3329
3330void ASN1CALL
3331free_EncryptedKey(EncryptedKey *data)
3332{
3333der_free_octet_string(data);
3334}
3335
3336size_t ASN1CALL
3337length_EncryptedKey(const EncryptedKey *data)
3338{
3339size_t ret = 0;
3340ret += der_length_octet_string(data);
3341ret += 1 + der_length_len (ret);
3342return ret;
3343}
3344
3345int ASN1CALL
3346copy_EncryptedKey(const EncryptedKey *from, EncryptedKey *to)
3347{
3348memset(to, 0, sizeof(*to));
3349if(der_copy_octet_string(from, to)) goto fail;
3350return 0;
3351fail:
3352free_EncryptedKey(to);
3353return ENOMEM;
3354}
3355
3356int ASN1CALL
3357encode_KeyTransRecipientInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KeyTransRecipientInfo *data, size_t *size)
3358{
3359size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3360size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3361int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3362
3363/* encryptedKey */
3364{
3365size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3366ret = 0;
3367e = encode_EncryptedKey(p, len, &(data)->encryptedKey, &l);
3368if (e) return e;
3369p -= l; len -= l; ret += l;
3370
3371ret += Top_tag_oldret;
3372}
3373/* keyEncryptionAlgorithm */
3374{
3375size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3376ret = 0;
3377e = encode_KeyEncryptionAlgorithmIdentifier(p, len, &(data)->keyEncryptionAlgorithm, &l);
3378if (e) return e;
3379p -= l; len -= l; ret += l;
3380
3381ret += Top_tag_oldret;
3382}
3383/* rid */
3384{
3385size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3386ret = 0;
3387e = encode_RecipientIdentifier(p, len, &(data)->rid, &l);
3388if (e) return e;
3389p -= l; len -= l; ret += l;
3390
3391ret += Top_tag_oldret;
3392}
3393/* version */
3394{
3395size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3396ret = 0;
3397e = encode_CMSVersion(p, len, &(data)->version, &l);
3398if (e) return e;
3399p -= l; len -= l; ret += l;
3400
3401ret += Top_tag_oldret;
3402}
3403e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3404if (e) return e;
3405p -= l; len -= l; ret += l;
3406
3407*size = ret;
3408return 0;
3409}
3410
3411int ASN1CALL
3412decode_KeyTransRecipientInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KeyTransRecipientInfo *data, size_t *size)
3413{
3414size_t ret = 0;
3415size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3416int e HEIMDAL_UNUSED_ATTRIBUTE;
3417
3418memset(data, 0, sizeof(*data));
3419{
3420size_t Top_datalen, Top_oldlen;
3421Der_type Top_type;
3422int is_indefinite1;
3423e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3424if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3425if(e) goto fail;
3426p += l; len -= l; ret += l;
3427Top_oldlen = len;
3428if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
3429{ e = ASN1_BAD_FORMAT; goto fail; }
3430if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_CMSVersion(p, len, &(data)->version, &l);
3431if(e) goto fail;
3432p += l; len -= l; ret += l;
3433e = decode_RecipientIdentifier(p, len, &(data)->rid, &l);
3434if(e) goto fail;
3435p += l; len -= l; ret += l;
3436e = decode_KeyEncryptionAlgorithmIdentifier(p, len, &(data)->keyEncryptionAlgorithm, &l);
3437if(e) goto fail;
3438p += l; len -= l; ret += l;
3439e = decode_EncryptedKey(p, len, &(data)->encryptedKey, &l);
3440if(e) goto fail;
3441p += l; len -= l; ret += l;
3442if(is_indefinite1){
3443len += 2;
3444e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
3445if(e) goto fail;
3446p += l; len -= l; ret += l;
3447if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3448} else
3449len = Top_oldlen - Top_datalen;
3450}
3451if(size) *size = ret;
3452return 0;
3453fail:
3454free_KeyTransRecipientInfo(data);
3455return e;
3456}
3457
3458void ASN1CALL
3459free_KeyTransRecipientInfo(KeyTransRecipientInfo *data)
3460{
3461free_CMSVersion(&(data)->version);
3462free_RecipientIdentifier(&(data)->rid);
3463free_KeyEncryptionAlgorithmIdentifier(&(data)->keyEncryptionAlgorithm);
3464free_EncryptedKey(&(data)->encryptedKey);
3465}
3466
3467size_t ASN1CALL
3468length_KeyTransRecipientInfo(const KeyTransRecipientInfo *data)
3469{
3470size_t ret = 0;
3471{
3472size_t Top_tag_oldret = ret;
3473ret = 0;
3474ret += length_CMSVersion(&(data)->version);
3475ret += Top_tag_oldret;
3476}
3477{
3478size_t Top_tag_oldret = ret;
3479ret = 0;
3480ret += length_RecipientIdentifier(&(data)->rid);
3481ret += Top_tag_oldret;
3482}
3483{
3484size_t Top_tag_oldret = ret;
3485ret = 0;
3486ret += length_KeyEncryptionAlgorithmIdentifier(&(data)->keyEncryptionAlgorithm);
3487ret += Top_tag_oldret;
3488}
3489{
3490size_t Top_tag_oldret = ret;
3491ret = 0;
3492ret += length_EncryptedKey(&(data)->encryptedKey);
3493ret += Top_tag_oldret;
3494}
3495ret += 1 + der_length_len (ret);
3496return ret;
3497}
3498
3499int ASN1CALL
3500copy_KeyTransRecipientInfo(const KeyTransRecipientInfo *from, KeyTransRecipientInfo *to)
3501{
3502memset(to, 0, sizeof(*to));
3503if(copy_CMSVersion(&(from)->version, &(to)->version)) goto fail;
3504if(copy_RecipientIdentifier(&(from)->rid, &(to)->rid)) goto fail;
3505if(copy_KeyEncryptionAlgorithmIdentifier(&(from)->keyEncryptionAlgorithm, &(to)->keyEncryptionAlgorithm)) goto fail;
3506if(copy_EncryptedKey(&(from)->encryptedKey, &(to)->encryptedKey)) goto fail;
3507return 0;
3508fail:
3509free_KeyTransRecipientInfo(to);
3510return ENOMEM;
3511}
3512
3513int ASN1CALL
3514encode_RecipientInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RecipientInfo *data, size_t *size)
3515{
3516size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3517size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3518int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3519
3520e = encode_KeyTransRecipientInfo(p, len, data, &l);
3521if (e) return e;
3522p -= l; len -= l; ret += l;
3523
3524*size = ret;
3525return 0;
3526}
3527
3528int ASN1CALL
3529decode_RecipientInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RecipientInfo *data, size_t *size)
3530{
3531size_t ret = 0;
3532size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3533int e HEIMDAL_UNUSED_ATTRIBUTE;
3534
3535memset(data, 0, sizeof(*data));
3536e = decode_KeyTransRecipientInfo(p, len, data, &l);
3537if(e) goto fail;
3538p += l; len -= l; ret += l;
3539if(size) *size = ret;
3540return 0;
3541fail:
3542free_RecipientInfo(data);
3543return e;
3544}
3545
3546void ASN1CALL
3547free_RecipientInfo(RecipientInfo *data)
3548{
3549free_KeyTransRecipientInfo(data);
3550}
3551
3552size_t ASN1CALL
3553length_RecipientInfo(const RecipientInfo *data)
3554{
3555size_t ret = 0;
3556ret += length_KeyTransRecipientInfo(data);
3557return ret;
3558}
3559
3560int ASN1CALL
3561copy_RecipientInfo(const RecipientInfo *from, RecipientInfo *to)
3562{
3563memset(to, 0, sizeof(*to));
3564if(copy_KeyTransRecipientInfo(from, to)) goto fail;
3565return 0;
3566fail:
3567free_RecipientInfo(to);
3568return ENOMEM;
3569}
3570
3571int ASN1CALL
3572encode_RecipientInfos(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RecipientInfos *data, size_t *size)
3573{
3574size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3575size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3576int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3577
3578{
3579heim_octet_string *val;
3580size_t elen = 0, totallen = 0;
3581int eret = 0;
3582if ((data)->len > UINT_MAX/sizeof(val[0]))
3583return ERANGE;
3584val = malloc(sizeof(val[0]) * (data)->len);
3585if (val == NULL && (data)->len != 0) return ENOMEM;
3586for(i = 0; i < (int)(data)->len; i++) {
3587ASN1_MALLOC_ENCODE(RecipientInfo, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
3588if(eret) {
3589i--;
3590while (i >= 0) {
3591free(val[i].data);
3592i--;
3593}
3594free(val);
3595return eret;
3596}
3597totallen += elen;
3598}
3599if (totallen > len) {
3600for (i = 0; i < (int)(data)->len; i++) {
3601free(val[i].data);
3602}
3603free(val);
3604return ASN1_OVERFLOW;
3605}
3606qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
3607for(i = (int)(data)->len - 1; i >= 0; --i) {
3608p -= val[i].length;
3609ret += val[i].length;
3610memcpy(p + 1, val[i].data, val[i].length);
3611free(val[i].data);
3612}
3613free(val);
3614}
3615e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
3616if (e) return e;
3617p -= l; len -= l; ret += l;
3618
3619*size = ret;
3620return 0;
3621}
3622
3623int ASN1CALL
3624decode_RecipientInfos(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RecipientInfos *data, size_t *size)
3625{
3626size_t ret = 0;
3627size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3628int e HEIMDAL_UNUSED_ATTRIBUTE;
3629
3630memset(data, 0, sizeof(*data));
3631{
3632size_t Top_datalen, Top_oldlen;
3633Der_type Top_type;
3634int is_indefinite1;
3635e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
3636if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3637if(e) goto fail;
3638p += l; len -= l; ret += l;
3639Top_oldlen = len;
3640if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
3641{ e = ASN1_BAD_FORMAT; goto fail; }
3642if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
3643size_t Top_Tag_origlen = len;
3644size_t Top_Tag_oldret = ret;
3645size_t Top_Tag_olen = 0;
3646void *Top_Tag_tmp;
3647ret = 0;
3648(data)->len = 0;
3649(data)->val = NULL;
3650while(ret < Top_Tag_origlen) {
3651size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
3652if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
3653Top_Tag_olen = Top_Tag_nlen;
3654Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
3655if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
3656(data)->val = Top_Tag_tmp;
3657e = decode_RecipientInfo(p, len, &(data)->val[(data)->len], &l);
3658if(e) goto fail;
3659p += l; len -= l; ret += l;
3660(data)->len++;
3661len = Top_Tag_origlen - ret;
3662}
3663ret += Top_Tag_oldret;
3664}
3665if(is_indefinite1){
3666len += 2;
3667e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
3668if(e) goto fail;
3669p += l; len -= l; ret += l;
3670if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3671} else
3672len = Top_oldlen - Top_datalen;
3673}
3674if(size) *size = ret;
3675return 0;
3676fail:
3677free_RecipientInfos(data);
3678return e;
3679}
3680
3681void ASN1CALL
3682free_RecipientInfos(RecipientInfos *data)
3683{
3684while((data)->len){
3685free_RecipientInfo(&(data)->val[(data)->len-1]);
3686(data)->len--;
3687}
3688free((data)->val);
3689(data)->val = NULL;
3690}
3691
3692size_t ASN1CALL
3693length_RecipientInfos(const RecipientInfos *data)
3694{
3695size_t ret = 0;
3696{
3697size_t Top_tag_oldret = ret;
3698unsigned int n_Top_tag;
3699ret = 0;
3700for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
3701size_t Top_tag_for_oldret = ret;
3702ret = 0;
3703ret += length_RecipientInfo(&(data)->val[n_Top_tag - 1]);
3704ret += Top_tag_for_oldret;
3705}
3706ret += Top_tag_oldret;
3707}
3708ret += 1 + der_length_len (ret);
3709return ret;
3710}
3711
3712int ASN1CALL
3713copy_RecipientInfos(const RecipientInfos *from, RecipientInfos *to)
3714{
3715memset(to, 0, sizeof(*to));
3716if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
3717goto fail;
3718for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
3719if(copy_RecipientInfo(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
3720}
3721return 0;
3722fail:
3723free_RecipientInfos(to);
3724return ENOMEM;
3725}
3726
3727int ASN1CALL
3728encode_EncryptedContent(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncryptedContent *data, size_t *size)
3729{
3730size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3731size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3732int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3733
3734e = der_put_octet_string(p, len, data, &l);
3735if (e) return e;
3736p -= l; len -= l; ret += l;
3737
3738e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
3739if (e) return e;
3740p -= l; len -= l; ret += l;
3741
3742*size = ret;
3743return 0;
3744}
3745
3746int ASN1CALL
3747decode_EncryptedContent(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncryptedContent *data, size_t *size)
3748{
3749size_t ret = 0;
3750size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3751int e HEIMDAL_UNUSED_ATTRIBUTE;
3752
3753memset(data, 0, sizeof(*data));
3754{
3755size_t Top_datalen, Top_oldlen;
3756Der_type Top_type;
3757int is_indefinite1;
3758e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
3759if(e) goto fail;
3760p += l; len -= l; ret += l;
3761Top_oldlen = len;
3762if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
3763{ e = ASN1_BAD_FORMAT; goto fail; }
3764if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }if (Top_type == CONS) {
3765e = der_get_octet_string_ber(p, len, data, &l);
3766if(e) goto fail;
3767p += l; len -= l; ret += l;
3768} else {
3769e = der_get_octet_string(p, len, data, &l);
3770if(e) goto fail;
3771p += l; len -= l; ret += l;
3772}
3773if(is_indefinite1){
3774len += 2;
3775e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
3776if(e) goto fail;
3777p += l; len -= l; ret += l;
3778if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3779} else
3780len = Top_oldlen - Top_datalen;
3781}
3782if(size) *size = ret;
3783return 0;
3784fail:
3785free_EncryptedContent(data);
3786return e;
3787}
3788
3789void ASN1CALL
3790free_EncryptedContent(EncryptedContent *data)
3791{
3792der_free_octet_string(data);
3793}
3794
3795size_t ASN1CALL
3796length_EncryptedContent(const EncryptedContent *data)
3797{
3798size_t ret = 0;
3799ret += der_length_octet_string(data);
3800ret += 1 + der_length_len (ret);
3801return ret;
3802}
3803
3804int ASN1CALL
3805copy_EncryptedContent(const EncryptedContent *from, EncryptedContent *to)
3806{
3807memset(to, 0, sizeof(*to));
3808if(der_copy_octet_string(from, to)) goto fail;
3809return 0;
3810fail:
3811free_EncryptedContent(to);
3812return ENOMEM;
3813}
3814
3815int ASN1CALL
3816encode_EncryptedContentInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EncryptedContentInfo *data, size_t *size)
3817{
3818size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3819size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3820int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3821
3822/* encryptedContent */
3823if((data)->encryptedContent) {
3824size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3825ret = 0;
3826e = der_put_octet_string(p, len, (data)->encryptedContent, &l);
3827if (e) return e;
3828p -= l; len -= l; ret += l;
3829
3830e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 0, &l);
3831if (e) return e;
3832p -= l; len -= l; ret += l;
3833
3834ret += Top_tag_oldret;
3835}
3836/* contentEncryptionAlgorithm */
3837{
3838size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3839ret = 0;
3840e = encode_ContentEncryptionAlgorithmIdentifier(p, len, &(data)->contentEncryptionAlgorithm, &l);
3841if (e) return e;
3842p -= l; len -= l; ret += l;
3843
3844ret += Top_tag_oldret;
3845}
3846/* contentType */
3847{
3848size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3849ret = 0;
3850e = encode_ContentType(p, len, &(data)->contentType, &l);
3851if (e) return e;
3852p -= l; len -= l; ret += l;
3853
3854ret += Top_tag_oldret;
3855}
3856e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
3857if (e) return e;
3858p -= l; len -= l; ret += l;
3859
3860*size = ret;
3861return 0;
3862}
3863
3864int ASN1CALL
3865decode_EncryptedContentInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EncryptedContentInfo *data, size_t *size)
3866{
3867size_t ret = 0;
3868size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3869int e HEIMDAL_UNUSED_ATTRIBUTE;
3870
3871memset(data, 0, sizeof(*data));
3872{
3873size_t Top_datalen, Top_oldlen;
3874Der_type Top_type;
3875int is_indefinite1;
3876e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
3877if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
3878if(e) goto fail;
3879p += l; len -= l; ret += l;
3880Top_oldlen = len;
3881if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
3882{ e = ASN1_BAD_FORMAT; goto fail; }
3883if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_ContentType(p, len, &(data)->contentType, &l);
3884if(e) goto fail;
3885p += l; len -= l; ret += l;
3886e = decode_ContentEncryptionAlgorithmIdentifier(p, len, &(data)->contentEncryptionAlgorithm, &l);
3887if(e) goto fail;
3888p += l; len -= l; ret += l;
3889{
3890size_t encryptedContent_datalen, encryptedContent_oldlen;
3891Der_type encryptedContent_type;
3892int is_indefinite3;
3893e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &encryptedContent_type, 0, &encryptedContent_datalen, &l);
3894if(e) {
3895(data)->encryptedContent = NULL;
3896} else {
3897(data)->encryptedContent = calloc(1, sizeof(*(data)->encryptedContent));
3898if ((data)->encryptedContent == NULL) { e = ENOMEM; goto fail; }
3899p += l; len -= l; ret += l;
3900encryptedContent_oldlen = len;
3901if((is_indefinite3 = _heim_fix_dce(encryptedContent_datalen, &len)) < 0)
3902{ e = ASN1_BAD_FORMAT; goto fail; }
3903if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }if (encryptedContent_type == CONS) {
3904e = der_get_octet_string_ber(p, len, (data)->encryptedContent, &l);
3905if(e) goto fail;
3906p += l; len -= l; ret += l;
3907} else {
3908e = der_get_octet_string(p, len, (data)->encryptedContent, &l);
3909if(e) goto fail;
3910p += l; len -= l; ret += l;
3911}
3912if(is_indefinite3){
3913len += 2;
3914e = der_match_tag_and_length(p, len, (Der_class)0, &encryptedContent_type, UT_EndOfContent, &encryptedContent_datalen, &l);
3915if(e) goto fail;
3916p += l; len -= l; ret += l;
3917if (encryptedContent_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3918} else
3919len = encryptedContent_oldlen - encryptedContent_datalen;
3920}
3921}
3922if(is_indefinite1){
3923len += 2;
3924e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
3925if(e) goto fail;
3926p += l; len -= l; ret += l;
3927if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
3928} else
3929len = Top_oldlen - Top_datalen;
3930}
3931if(size) *size = ret;
3932return 0;
3933fail:
3934free_EncryptedContentInfo(data);
3935return e;
3936}
3937
3938void ASN1CALL
3939free_EncryptedContentInfo(EncryptedContentInfo *data)
3940{
3941free_ContentType(&(data)->contentType);
3942free_ContentEncryptionAlgorithmIdentifier(&(data)->contentEncryptionAlgorithm);
3943if((data)->encryptedContent) {
3944der_free_octet_string((data)->encryptedContent);
3945free((data)->encryptedContent);
3946(data)->encryptedContent = NULL;
3947}
3948}
3949
3950size_t ASN1CALL
3951length_EncryptedContentInfo(const EncryptedContentInfo *data)
3952{
3953size_t ret = 0;
3954{
3955size_t Top_tag_oldret = ret;
3956ret = 0;
3957ret += length_ContentType(&(data)->contentType);
3958ret += Top_tag_oldret;
3959}
3960{
3961size_t Top_tag_oldret = ret;
3962ret = 0;
3963ret += length_ContentEncryptionAlgorithmIdentifier(&(data)->contentEncryptionAlgorithm);
3964ret += Top_tag_oldret;
3965}
3966if((data)->encryptedContent){
3967size_t Top_tag_oldret = ret;
3968ret = 0;
3969ret += der_length_octet_string((data)->encryptedContent);
3970ret += 1 + der_length_len (ret);
3971ret += Top_tag_oldret;
3972}
3973ret += 1 + der_length_len (ret);
3974return ret;
3975}
3976
3977int ASN1CALL
3978copy_EncryptedContentInfo(const EncryptedContentInfo *from, EncryptedContentInfo *to)
3979{
3980memset(to, 0, sizeof(*to));
3981if(copy_ContentType(&(from)->contentType, &(to)->contentType)) goto fail;
3982if(copy_ContentEncryptionAlgorithmIdentifier(&(from)->contentEncryptionAlgorithm, &(to)->contentEncryptionAlgorithm)) goto fail;
3983if((from)->encryptedContent) {
3984(to)->encryptedContent = malloc(sizeof(*(to)->encryptedContent));
3985if((to)->encryptedContent == NULL) goto fail;
3986if(der_copy_octet_string((from)->encryptedContent, (to)->encryptedContent)) goto fail;
3987}else
3988(to)->encryptedContent = NULL;
3989return 0;
3990fail:
3991free_EncryptedContentInfo(to);
3992return ENOMEM;
3993}
3994
3995int ASN1CALL
3996encode_UnprotectedAttributes(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const UnprotectedAttributes *data, size_t *size)
3997{
3998size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3999size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4000int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4001
4002{
4003heim_octet_string *val;
4004size_t elen = 0, totallen = 0;
4005int eret = 0;
4006if ((data)->len > UINT_MAX/sizeof(val[0]))
4007return ERANGE;
4008val = malloc(sizeof(val[0]) * (data)->len);
4009if (val == NULL && (data)->len != 0) return ENOMEM;
4010for(i = 0; i < (int)(data)->len; i++) {
4011ASN1_MALLOC_ENCODE(Attribute, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
4012if(eret) {
4013i--;
4014while (i >= 0) {
4015free(val[i].data);
4016i--;
4017}
4018free(val);
4019return eret;
4020}
4021totallen += elen;
4022}
4023if (totallen > len) {
4024for (i = 0; i < (int)(data)->len; i++) {
4025free(val[i].data);
4026}
4027free(val);
4028return ASN1_OVERFLOW;
4029}
4030qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
4031for(i = (int)(data)->len - 1; i >= 0; --i) {
4032p -= val[i].length;
4033ret += val[i].length;
4034memcpy(p + 1, val[i].data, val[i].length);
4035free(val[i].data);
4036}
4037free(val);
4038}
4039e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
4040if (e) return e;
4041p -= l; len -= l; ret += l;
4042
4043*size = ret;
4044return 0;
4045}
4046
4047int ASN1CALL
4048decode_UnprotectedAttributes(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, UnprotectedAttributes *data, size_t *size)
4049{
4050size_t ret = 0;
4051size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4052int e HEIMDAL_UNUSED_ATTRIBUTE;
4053
4054memset(data, 0, sizeof(*data));
4055{
4056size_t Top_datalen, Top_oldlen;
4057Der_type Top_type;
4058int is_indefinite1;
4059e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
4060if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4061if(e) goto fail;
4062p += l; len -= l; ret += l;
4063Top_oldlen = len;
4064if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
4065{ e = ASN1_BAD_FORMAT; goto fail; }
4066if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
4067size_t Top_Tag_origlen = len;
4068size_t Top_Tag_oldret = ret;
4069size_t Top_Tag_olen = 0;
4070void *Top_Tag_tmp;
4071ret = 0;
4072(data)->len = 0;
4073(data)->val = NULL;
4074while(ret < Top_Tag_origlen) {
4075size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
4076if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
4077Top_Tag_olen = Top_Tag_nlen;
4078Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
4079if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
4080(data)->val = Top_Tag_tmp;
4081e = decode_Attribute(p, len, &(data)->val[(data)->len], &l);
4082if(e) goto fail;
4083p += l; len -= l; ret += l;
4084(data)->len++;
4085len = Top_Tag_origlen - ret;
4086}
4087ret += Top_Tag_oldret;
4088}
4089if(is_indefinite1){
4090len += 2;
4091e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
4092if(e) goto fail;
4093p += l; len -= l; ret += l;
4094if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4095} else
4096len = Top_oldlen - Top_datalen;
4097}
4098if(size) *size = ret;
4099return 0;
4100fail:
4101free_UnprotectedAttributes(data);
4102return e;
4103}
4104
4105void ASN1CALL
4106free_UnprotectedAttributes(UnprotectedAttributes *data)
4107{
4108while((data)->len){
4109free_Attribute(&(data)->val[(data)->len-1]);
4110(data)->len--;
4111}
4112free((data)->val);
4113(data)->val = NULL;
4114}
4115
4116size_t ASN1CALL
4117length_UnprotectedAttributes(const UnprotectedAttributes *data)
4118{
4119size_t ret = 0;
4120{
4121size_t Top_tag_oldret = ret;
4122unsigned int n_Top_tag;
4123ret = 0;
4124for(n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag){
4125size_t Top_tag_for_oldret = ret;
4126ret = 0;
4127ret += length_Attribute(&(data)->val[n_Top_tag - 1]);
4128ret += Top_tag_for_oldret;
4129}
4130ret += Top_tag_oldret;
4131}
4132ret += 1 + der_length_len (ret);
4133return ret;
4134}
4135
4136int ASN1CALL
4137copy_UnprotectedAttributes(const UnprotectedAttributes *from, UnprotectedAttributes *to)
4138{
4139memset(to, 0, sizeof(*to));
4140if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
4141goto fail;
4142for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
4143if(copy_Attribute(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
4144}
4145return 0;
4146fail:
4147free_UnprotectedAttributes(to);
4148return ENOMEM;
4149}
4150
4151int ASN1CALL
4152encode_CMSEncryptedData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CMSEncryptedData *data, size_t *size)
4153{
4154size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4155size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4156int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4157
4158/* unprotectedAttrs */
4159if((data)->unprotectedAttrs) {
4160size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4161ret = 0;
4162e = encode_heim_any(p, len, (data)->unprotectedAttrs, &l);
4163if (e) return e;
4164p -= l; len -= l; ret += l;
4165
4166e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4167if (e) return e;
4168p -= l; len -= l; ret += l;
4169
4170ret += Top_tag_oldret;
4171}
4172/* encryptedContentInfo */
4173{
4174size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4175ret = 0;
4176e = encode_EncryptedContentInfo(p, len, &(data)->encryptedContentInfo, &l);
4177if (e) return e;
4178p -= l; len -= l; ret += l;
4179
4180ret += Top_tag_oldret;
4181}
4182/* version */
4183{
4184size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4185ret = 0;
4186e = encode_CMSVersion(p, len, &(data)->version, &l);
4187if (e) return e;
4188p -= l; len -= l; ret += l;
4189
4190ret += Top_tag_oldret;
4191}
4192e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4193if (e) return e;
4194p -= l; len -= l; ret += l;
4195
4196*size = ret;
4197return 0;
4198}
4199
4200int ASN1CALL
4201decode_CMSEncryptedData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CMSEncryptedData *data, size_t *size)
4202{
4203size_t ret = 0;
4204size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4205int e HEIMDAL_UNUSED_ATTRIBUTE;
4206
4207memset(data, 0, sizeof(*data));
4208{
4209size_t Top_datalen, Top_oldlen;
4210Der_type Top_type;
4211int is_indefinite1;
4212e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4213if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4214if(e) goto fail;
4215p += l; len -= l; ret += l;
4216Top_oldlen = len;
4217if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
4218{ e = ASN1_BAD_FORMAT; goto fail; }
4219if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_CMSVersion(p, len, &(data)->version, &l);
4220if(e) goto fail;
4221p += l; len -= l; ret += l;
4222e = decode_EncryptedContentInfo(p, len, &(data)->encryptedContentInfo, &l);
4223if(e) goto fail;
4224p += l; len -= l; ret += l;
4225{
4226size_t unprotectedAttrs_datalen, unprotectedAttrs_oldlen;
4227Der_type unprotectedAttrs_type;
4228int is_indefinite3;
4229e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &unprotectedAttrs_type, 1, &unprotectedAttrs_datalen, &l);
4230if (e == 0 && unprotectedAttrs_type != CONS) { e = ASN1_BAD_ID; }
4231if(e) {
4232(data)->unprotectedAttrs = NULL;
4233} else {
4234(data)->unprotectedAttrs = calloc(1, sizeof(*(data)->unprotectedAttrs));
4235if ((data)->unprotectedAttrs == NULL) { e = ENOMEM; goto fail; }
4236p += l; len -= l; ret += l;
4237unprotectedAttrs_oldlen = len;
4238if((is_indefinite3 = _heim_fix_dce(unprotectedAttrs_datalen, &len)) < 0)
4239{ e = ASN1_BAD_FORMAT; goto fail; }
4240if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_heim_any(p, len, (data)->unprotectedAttrs, &l);
4241if(e) goto fail;
4242p += l; len -= l; ret += l;
4243if(is_indefinite3){
4244len += 2;
4245e = der_match_tag_and_length(p, len, (Der_class)0, &unprotectedAttrs_type, UT_EndOfContent, &unprotectedAttrs_datalen, &l);
4246if(e) goto fail;
4247p += l; len -= l; ret += l;
4248if (unprotectedAttrs_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4249} else
4250len = unprotectedAttrs_oldlen - unprotectedAttrs_datalen;
4251}
4252}
4253if(is_indefinite1){
4254len += 2;
4255e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
4256if(e) goto fail;
4257p += l; len -= l; ret += l;
4258if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4259} else
4260len = Top_oldlen - Top_datalen;
4261}
4262if(size) *size = ret;
4263return 0;
4264fail:
4265free_CMSEncryptedData(data);
4266return e;
4267}
4268
4269void ASN1CALL
4270free_CMSEncryptedData(CMSEncryptedData *data)
4271{
4272free_CMSVersion(&(data)->version);
4273free_EncryptedContentInfo(&(data)->encryptedContentInfo);
4274if((data)->unprotectedAttrs) {
4275free_heim_any((data)->unprotectedAttrs);
4276free((data)->unprotectedAttrs);
4277(data)->unprotectedAttrs = NULL;
4278}
4279}
4280
4281size_t ASN1CALL
4282length_CMSEncryptedData(const CMSEncryptedData *data)
4283{
4284size_t ret = 0;
4285{
4286size_t Top_tag_oldret = ret;
4287ret = 0;
4288ret += length_CMSVersion(&(data)->version);
4289ret += Top_tag_oldret;
4290}
4291{
4292size_t Top_tag_oldret = ret;
4293ret = 0;
4294ret += length_EncryptedContentInfo(&(data)->encryptedContentInfo);
4295ret += Top_tag_oldret;
4296}
4297if((data)->unprotectedAttrs){
4298size_t Top_tag_oldret = ret;
4299ret = 0;
4300ret += length_heim_any((data)->unprotectedAttrs);
4301ret += 1 + der_length_len (ret);
4302ret += Top_tag_oldret;
4303}
4304ret += 1 + der_length_len (ret);
4305return ret;
4306}
4307
4308int ASN1CALL
4309copy_CMSEncryptedData(const CMSEncryptedData *from, CMSEncryptedData *to)
4310{
4311memset(to, 0, sizeof(*to));
4312if(copy_CMSVersion(&(from)->version, &(to)->version)) goto fail;
4313if(copy_EncryptedContentInfo(&(from)->encryptedContentInfo, &(to)->encryptedContentInfo)) goto fail;
4314if((from)->unprotectedAttrs) {
4315(to)->unprotectedAttrs = malloc(sizeof(*(to)->unprotectedAttrs));
4316if((to)->unprotectedAttrs == NULL) goto fail;
4317if(copy_heim_any((from)->unprotectedAttrs, (to)->unprotectedAttrs)) goto fail;
4318}else
4319(to)->unprotectedAttrs = NULL;
4320return 0;
4321fail:
4322free_CMSEncryptedData(to);
4323return ENOMEM;
4324}
4325
4326int ASN1CALL
4327encode_EnvelopedData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const EnvelopedData *data, size_t *size)
4328{
4329size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4330size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4331int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4332
4333/* unprotectedAttrs */
4334if((data)->unprotectedAttrs) {
4335size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4336ret = 0;
4337e = encode_heim_any(p, len, (data)->unprotectedAttrs, &l);
4338if (e) return e;
4339p -= l; len -= l; ret += l;
4340
4341e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
4342if (e) return e;
4343p -= l; len -= l; ret += l;
4344
4345ret += Top_tag_oldret;
4346}
4347/* encryptedContentInfo */
4348{
4349size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4350ret = 0;
4351e = encode_EncryptedContentInfo(p, len, &(data)->encryptedContentInfo, &l);
4352if (e) return e;
4353p -= l; len -= l; ret += l;
4354
4355ret += Top_tag_oldret;
4356}
4357/* recipientInfos */
4358{
4359size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4360ret = 0;
4361e = encode_RecipientInfos(p, len, &(data)->recipientInfos, &l);
4362if (e) return e;
4363p -= l; len -= l; ret += l;
4364
4365ret += Top_tag_oldret;
4366}
4367/* originatorInfo */
4368if((data)->originatorInfo) {
4369size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4370ret = 0;
4371e = encode_heim_any(p, len, (data)->originatorInfo, &l);
4372if (e) return e;
4373p -= l; len -= l; ret += l;
4374
4375e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
4376if (e) return e;
4377p -= l; len -= l; ret += l;
4378
4379ret += Top_tag_oldret;
4380}
4381/* version */
4382{
4383size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4384ret = 0;
4385e = encode_CMSVersion(p, len, &(data)->version, &l);
4386if (e) return e;
4387p -= l; len -= l; ret += l;
4388
4389ret += Top_tag_oldret;
4390}
4391e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4392if (e) return e;
4393p -= l; len -= l; ret += l;
4394
4395*size = ret;
4396return 0;
4397}
4398
4399int ASN1CALL
4400decode_EnvelopedData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, EnvelopedData *data, size_t *size)
4401{
4402size_t ret = 0;
4403size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4404int e HEIMDAL_UNUSED_ATTRIBUTE;
4405
4406memset(data, 0, sizeof(*data));
4407{
4408size_t Top_datalen, Top_oldlen;
4409Der_type Top_type;
4410int is_indefinite1;
4411e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4412if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4413if(e) goto fail;
4414p += l; len -= l; ret += l;
4415Top_oldlen = len;
4416if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
4417{ e = ASN1_BAD_FORMAT; goto fail; }
4418if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_CMSVersion(p, len, &(data)->version, &l);
4419if(e) goto fail;
4420p += l; len -= l; ret += l;
4421{
4422size_t originatorInfo_datalen, originatorInfo_oldlen;
4423Der_type originatorInfo_type;
4424int is_indefinite3;
4425e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &originatorInfo_type, 0, &originatorInfo_datalen, &l);
4426if (e == 0 && originatorInfo_type != CONS) { e = ASN1_BAD_ID; }
4427if(e) {
4428(data)->originatorInfo = NULL;
4429} else {
4430(data)->originatorInfo = calloc(1, sizeof(*(data)->originatorInfo));
4431if ((data)->originatorInfo == NULL) { e = ENOMEM; goto fail; }
4432p += l; len -= l; ret += l;
4433originatorInfo_oldlen = len;
4434if((is_indefinite3 = _heim_fix_dce(originatorInfo_datalen, &len)) < 0)
4435{ e = ASN1_BAD_FORMAT; goto fail; }
4436if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_heim_any(p, len, (data)->originatorInfo, &l);
4437if(e) goto fail;
4438p += l; len -= l; ret += l;
4439if(is_indefinite3){
4440len += 2;
4441e = der_match_tag_and_length(p, len, (Der_class)0, &originatorInfo_type, UT_EndOfContent, &originatorInfo_datalen, &l);
4442if(e) goto fail;
4443p += l; len -= l; ret += l;
4444if (originatorInfo_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4445} else
4446len = originatorInfo_oldlen - originatorInfo_datalen;
4447}
4448}
4449e = decode_RecipientInfos(p, len, &(data)->recipientInfos, &l);
4450if(e) goto fail;
4451p += l; len -= l; ret += l;
4452e = decode_EncryptedContentInfo(p, len, &(data)->encryptedContentInfo, &l);
4453if(e) goto fail;
4454p += l; len -= l; ret += l;
4455{
4456size_t unprotectedAttrs_datalen, unprotectedAttrs_oldlen;
4457Der_type unprotectedAttrs_type;
4458int is_indefinite3;
4459e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &unprotectedAttrs_type, 1, &unprotectedAttrs_datalen, &l);
4460if (e == 0 && unprotectedAttrs_type != CONS) { e = ASN1_BAD_ID; }
4461if(e) {
4462(data)->unprotectedAttrs = NULL;
4463} else {
4464(data)->unprotectedAttrs = calloc(1, sizeof(*(data)->unprotectedAttrs));
4465if ((data)->unprotectedAttrs == NULL) { e = ENOMEM; goto fail; }
4466p += l; len -= l; ret += l;
4467unprotectedAttrs_oldlen = len;
4468if((is_indefinite3 = _heim_fix_dce(unprotectedAttrs_datalen, &len)) < 0)
4469{ e = ASN1_BAD_FORMAT; goto fail; }
4470if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = decode_heim_any(p, len, (data)->unprotectedAttrs, &l);
4471if(e) goto fail;
4472p += l; len -= l; ret += l;
4473if(is_indefinite3){
4474len += 2;
4475e = der_match_tag_and_length(p, len, (Der_class)0, &unprotectedAttrs_type, UT_EndOfContent, &unprotectedAttrs_datalen, &l);
4476if(e) goto fail;
4477p += l; len -= l; ret += l;
4478if (unprotectedAttrs_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4479} else
4480len = unprotectedAttrs_oldlen - unprotectedAttrs_datalen;
4481}
4482}
4483if(is_indefinite1){
4484len += 2;
4485e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
4486if(e) goto fail;
4487p += l; len -= l; ret += l;
4488if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4489} else
4490len = Top_oldlen - Top_datalen;
4491}
4492if(size) *size = ret;
4493return 0;
4494fail:
4495free_EnvelopedData(data);
4496return e;
4497}
4498
4499void ASN1CALL
4500free_EnvelopedData(EnvelopedData *data)
4501{
4502free_CMSVersion(&(data)->version);
4503if((data)->originatorInfo) {
4504free_heim_any((data)->originatorInfo);
4505free((data)->originatorInfo);
4506(data)->originatorInfo = NULL;
4507}
4508free_RecipientInfos(&(data)->recipientInfos);
4509free_EncryptedContentInfo(&(data)->encryptedContentInfo);
4510if((data)->unprotectedAttrs) {
4511free_heim_any((data)->unprotectedAttrs);
4512free((data)->unprotectedAttrs);
4513(data)->unprotectedAttrs = NULL;
4514}
4515}
4516
4517size_t ASN1CALL
4518length_EnvelopedData(const EnvelopedData *data)
4519{
4520size_t ret = 0;
4521{
4522size_t Top_tag_oldret = ret;
4523ret = 0;
4524ret += length_CMSVersion(&(data)->version);
4525ret += Top_tag_oldret;
4526}
4527if((data)->originatorInfo){
4528size_t Top_tag_oldret = ret;
4529ret = 0;
4530ret += length_heim_any((data)->originatorInfo);
4531ret += 1 + der_length_len (ret);
4532ret += Top_tag_oldret;
4533}
4534{
4535size_t Top_tag_oldret = ret;
4536ret = 0;
4537ret += length_RecipientInfos(&(data)->recipientInfos);
4538ret += Top_tag_oldret;
4539}
4540{
4541size_t Top_tag_oldret = ret;
4542ret = 0;
4543ret += length_EncryptedContentInfo(&(data)->encryptedContentInfo);
4544ret += Top_tag_oldret;
4545}
4546if((data)->unprotectedAttrs){
4547size_t Top_tag_oldret = ret;
4548ret = 0;
4549ret += length_heim_any((data)->unprotectedAttrs);
4550ret += 1 + der_length_len (ret);
4551ret += Top_tag_oldret;
4552}
4553ret += 1 + der_length_len (ret);
4554return ret;
4555}
4556
4557int ASN1CALL
4558copy_EnvelopedData(const EnvelopedData *from, EnvelopedData *to)
4559{
4560memset(to, 0, sizeof(*to));
4561if(copy_CMSVersion(&(from)->version, &(to)->version)) goto fail;
4562if((from)->originatorInfo) {
4563(to)->originatorInfo = malloc(sizeof(*(to)->originatorInfo));
4564if((to)->originatorInfo == NULL) goto fail;
4565if(copy_heim_any((from)->originatorInfo, (to)->originatorInfo)) goto fail;
4566}else
4567(to)->originatorInfo = NULL;
4568if(copy_RecipientInfos(&(from)->recipientInfos, &(to)->recipientInfos)) goto fail;
4569if(copy_EncryptedContentInfo(&(from)->encryptedContentInfo, &(to)->encryptedContentInfo)) goto fail;
4570if((from)->unprotectedAttrs) {
4571(to)->unprotectedAttrs = malloc(sizeof(*(to)->unprotectedAttrs));
4572if((to)->unprotectedAttrs == NULL) goto fail;
4573if(copy_heim_any((from)->unprotectedAttrs, (to)->unprotectedAttrs)) goto fail;
4574}else
4575(to)->unprotectedAttrs = NULL;
4576return 0;
4577fail:
4578free_EnvelopedData(to);
4579return ENOMEM;
4580}
4581
4582int ASN1CALL
4583encode_CMSRC2CBCParameter(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CMSRC2CBCParameter *data, size_t *size)
4584{
4585size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4586size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4587int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4588
4589/* iv */
4590{
4591size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4592ret = 0;
4593e = der_put_octet_string(p, len, &(data)->iv, &l);
4594if (e) return e;
4595p -= l; len -= l; ret += l;
4596
4597e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4598if (e) return e;
4599p -= l; len -= l; ret += l;
4600
4601ret += Top_tag_oldret;
4602}
4603/* rc2ParameterVersion */
4604{
4605size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
4606ret = 0;
4607e = der_put_unsigned(p, len, &(data)->rc2ParameterVersion, &l);
4608if (e) return e;
4609p -= l; len -= l; ret += l;
4610
4611e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
4612if (e) return e;
4613p -= l; len -= l; ret += l;
4614
4615ret += Top_tag_oldret;
4616}
4617e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
4618if (e) return e;
4619p -= l; len -= l; ret += l;
4620
4621*size = ret;
4622return 0;
4623}
4624
4625int ASN1CALL
4626decode_CMSRC2CBCParameter(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CMSRC2CBCParameter *data, size_t *size)
4627{
4628size_t ret = 0;
4629size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4630int e HEIMDAL_UNUSED_ATTRIBUTE;
4631
4632memset(data, 0, sizeof(*data));
4633{
4634size_t Top_datalen, Top_oldlen;
4635Der_type Top_type;
4636int is_indefinite1;
4637e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
4638if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
4639if(e) goto fail;
4640p += l; len -= l; ret += l;
4641Top_oldlen = len;
4642if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
4643{ e = ASN1_BAD_FORMAT; goto fail; }
4644if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }{
4645size_t rc2ParameterVersion_datalen, rc2ParameterVersion_oldlen;
4646Der_type rc2ParameterVersion_type;
4647int is_indefinite3;
4648e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &rc2ParameterVersion_type, UT_Integer, &rc2ParameterVersion_datalen, &l);
4649if (e == 0 && rc2ParameterVersion_type != PRIM) { e = ASN1_BAD_ID; }
4650if(e) goto fail;
4651p += l; len -= l; ret += l;
4652rc2ParameterVersion_oldlen = len;
4653if((is_indefinite3 = _heim_fix_dce(rc2ParameterVersion_datalen, &len)) < 0)
4654{ e = ASN1_BAD_FORMAT; goto fail; }
4655if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }e = der_get_unsigned(p, len, &(data)->rc2ParameterVersion, &l);
4656if(e) goto fail;
4657p += l; len -= l; ret += l;
4658if(is_indefinite3){
4659len += 2;
4660e = der_match_tag_and_length(p, len, (Der_class)0, &rc2ParameterVersion_type, UT_EndOfContent, &rc2ParameterVersion_datalen, &l);
4661if(e) goto fail;
4662p += l; len -= l; ret += l;
4663if (rc2ParameterVersion_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4664} else
4665len = rc2ParameterVersion_oldlen - rc2ParameterVersion_datalen;
4666}
4667{
4668size_t iv_datalen, iv_oldlen;
4669Der_type iv_type;
4670int is_indefinite3;
4671e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &iv_type, UT_OctetString, &iv_datalen, &l);
4672if(e) goto fail;
4673p += l; len -= l; ret += l;
4674iv_oldlen = len;
4675if((is_indefinite3 = _heim_fix_dce(iv_datalen, &len)) < 0)
4676{ e = ASN1_BAD_FORMAT; goto fail; }
4677if (is_indefinite3) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }if (iv_type == CONS) {
4678e = der_get_octet_string_ber(p, len, &(data)->iv, &l);
4679if(e) goto fail;
4680p += l; len -= l; ret += l;
4681} else {
4682e = der_get_octet_string(p, len, &(data)->iv, &l);
4683if(e) goto fail;
4684p += l; len -= l; ret += l;
4685}
4686if(is_indefinite3){
4687len += 2;
4688e = der_match_tag_and_length(p, len, (Der_class)0, &iv_type, UT_EndOfContent, &iv_datalen, &l);
4689if(e) goto fail;
4690p += l; len -= l; ret += l;
4691if (iv_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4692} else
4693len = iv_oldlen - iv_datalen;
4694}
4695if(is_indefinite1){
4696len += 2;
4697e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
4698if(e) goto fail;
4699p += l; len -= l; ret += l;
4700if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4701} else
4702len = Top_oldlen - Top_datalen;
4703}
4704if(size) *size = ret;
4705return 0;
4706fail:
4707free_CMSRC2CBCParameter(data);
4708return e;
4709}
4710
4711void ASN1CALL
4712free_CMSRC2CBCParameter(CMSRC2CBCParameter *data)
4713{
4714der_free_octet_string(&(data)->iv);
4715}
4716
4717size_t ASN1CALL
4718length_CMSRC2CBCParameter(const CMSRC2CBCParameter *data)
4719{
4720size_t ret = 0;
4721{
4722size_t Top_tag_oldret = ret;
4723ret = 0;
4724ret += der_length_unsigned(&(data)->rc2ParameterVersion);
4725ret += 1 + der_length_len (ret);
4726ret += Top_tag_oldret;
4727}
4728{
4729size_t Top_tag_oldret = ret;
4730ret = 0;
4731ret += der_length_octet_string(&(data)->iv);
4732ret += 1 + der_length_len (ret);
4733ret += Top_tag_oldret;
4734}
4735ret += 1 + der_length_len (ret);
4736return ret;
4737}
4738
4739int ASN1CALL
4740copy_CMSRC2CBCParameter(const CMSRC2CBCParameter *from, CMSRC2CBCParameter *to)
4741{
4742memset(to, 0, sizeof(*to));
4743*(&(to)->rc2ParameterVersion) = *(&(from)->rc2ParameterVersion);
4744if(der_copy_octet_string(&(from)->iv, &(to)->iv)) goto fail;
4745return 0;
4746fail:
4747free_CMSRC2CBCParameter(to);
4748return ENOMEM;
4749}
4750
4751int ASN1CALL
4752encode_CMSCBCParameter(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CMSCBCParameter *data, size_t *size)
4753{
4754size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
4755size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4756int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
4757
4758e = der_put_octet_string(p, len, data, &l);
4759if (e) return e;
4760p -= l; len -= l; ret += l;
4761
4762e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
4763if (e) return e;
4764p -= l; len -= l; ret += l;
4765
4766*size = ret;
4767return 0;
4768}
4769
4770int ASN1CALL
4771decode_CMSCBCParameter(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CMSCBCParameter *data, size_t *size)
4772{
4773size_t ret = 0;
4774size_t l HEIMDAL_UNUSED_ATTRIBUTE;
4775int e HEIMDAL_UNUSED_ATTRIBUTE;
4776
4777memset(data, 0, sizeof(*data));
4778{
4779size_t Top_datalen, Top_oldlen;
4780Der_type Top_type;
4781int is_indefinite1;
4782e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
4783if(e) goto fail;
4784p += l; len -= l; ret += l;
4785Top_oldlen = len;
4786if((is_indefinite1 = _heim_fix_dce(Top_datalen, &len)) < 0)
4787{ e = ASN1_BAD_FORMAT; goto fail; }
4788if (is_indefinite1) { if (len < 2) { e = ASN1_OVERRUN; goto fail; } len -= 2; }if (Top_type == CONS) {
4789e = der_get_octet_string_ber(p, len, data, &l);
4790if(e) goto fail;
4791p += l; len -= l; ret += l;
4792} else {
4793e = der_get_octet_string(p, len, data, &l);
4794if(e) goto fail;
4795p += l; len -= l; ret += l;
4796}
4797if(is_indefinite1){
4798len += 2;
4799e = der_match_tag_and_length(p, len, (Der_class)0, &Top_type, UT_EndOfContent, &Top_datalen, &l);
4800if(e) goto fail;
4801p += l; len -= l; ret += l;
4802if (Top_type != (Der_type)0) { e = ASN1_BAD_ID; goto fail; }
4803} else
4804len = Top_oldlen - Top_datalen;
4805}
4806if(size) *size = ret;
4807return 0;
4808fail:
4809free_CMSCBCParameter(data);
4810return e;
4811}
4812
4813void ASN1CALL
4814free_CMSCBCParameter(CMSCBCParameter *data)
4815{
4816der_free_octet_string(data);
4817}
4818
4819size_t ASN1CALL
4820length_CMSCBCParameter(const CMSCBCParameter *data)
4821{
4822size_t ret = 0;
4823ret += der_length_octet_string(data);
4824ret += 1 + der_length_len (ret);
4825return ret;
4826}
4827
4828int ASN1CALL
4829copy_CMSCBCParameter(const CMSCBCParameter *from, CMSCBCParameter *to)
4830{
4831memset(to, 0, sizeof(*to));
4832if(der_copy_octet_string(from, to)) goto fail;
4833return 0;
4834fail:
4835free_CMSCBCParameter(to);
4836return ENOMEM;
4837}
4838
4839