LCOV - code coverage report
Current view: top level - bin/default/source4/heimdal/lib/asn1 - asn1_rfc2459_asn1.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 2082 6178 33.7 %
Date: 2021-09-23 10:06:22 Functions: 122 302 40.4 %

          Line data    Source code
       1             : #include "config.h"
       2             : /* Generated from /builds/samba-team/devel/samba/source4/heimdal/lib/asn1/rfc2459.asn1 */
       3             : /* Do not edit */
       4             : 
       5             : #define  ASN1_LIB
       6             : 
       7             : #include <stdio.h>
       8             : #include <stdlib.h>
       9             : #include <time.h>
      10             : #include <string.h>
      11             : #include <errno.h>
      12             : #include <limits.h>
      13             : #include <krb5-types.h>
      14             : #include <rfc2459_asn1.h>
      15             : #include <rfc2459_asn1-priv.h>
      16             : #include <asn1_err.h>
      17             : #include <der.h>
      18             : #include <der-private.h>
      19             : #include <asn1-template.h>
      20             : #include <parse_units.h>
      21             : 
      22             : int ASN1CALL
      23          66 : encode_Version(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Version *data, size_t *size)
      24             : {
      25          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
      26             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
      27             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
      28             : 
      29             : {
      30          66 : int enumint = (int)*data;
      31          66 : e = der_put_integer(p, len, &enumint, &l);
      32          66 : if (e) return e;
      33          66 : p -= l; len -= l; ret += l;
      34             : 
      35             : }
      36          66 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
      37          66 : if (e) return e;
      38          66 : p -= l; len -= l; ret += l;
      39             : 
      40          66 : *size = ret;
      41          66 : return 0;
      42             : }
      43             : 
      44             : int ASN1CALL
      45         248 : decode_Version(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Version *data, size_t *size)
      46             : {
      47         248 : size_t ret = 0;
      48             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
      49             : int e HEIMDAL_UNUSED_ATTRIBUTE;
      50             : 
      51         248 : memset(data, 0, sizeof(*data));
      52             : {
      53             : size_t Top_datalen, Top_oldlen;
      54             : Der_type Top_type;
      55         248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
      56         248 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
      57         248 : if(e) goto fail;
      58         248 : p += l; len -= l; ret += l;
      59         248 : Top_oldlen = len;
      60         248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
      61         248 : len = Top_datalen;
      62             : {
      63             : int enumint;
      64         248 : e = der_get_integer(p, len, &enumint, &l);
      65         248 : if(e) goto fail;
      66         248 : p += l; len -= l; ret += l;
      67         248 : *data = enumint;
      68             : }
      69         248 : len = Top_oldlen - Top_datalen;
      70             : }
      71         496 : if(size) *size = ret;
      72         232 : return 0;
      73           0 : fail:
      74           0 : free_Version(data);
      75           0 : return e;
      76             : }
      77             : 
      78             : void ASN1CALL
      79         378 : free_Version(Version *data)
      80             : {
      81         378 : }
      82             : 
      83             : size_t ASN1CALL
      84          66 : length_Version(const Version *data)
      85             : {
      86          66 : size_t ret = 0;
      87             : {
      88          66 : int enumint = *data;
      89          66 : ret += der_length_integer(&enumint);
      90             : }
      91          66 : ret += 1 + der_length_len (ret);
      92          66 : return ret;
      93             : }
      94             : 
      95             : int ASN1CALL
      96         248 : copy_Version(const Version *from, Version *to)
      97             : {
      98         248 : memset(to, 0, sizeof(*to));
      99         248 : *(to) = *(from);
     100         248 : return 0;
     101             : }
     102             : 
     103             : static unsigned oid_id_pkcs_1_variable_num[6] =  {1, 2, 840, 113549, 1, 1 };
     104             : const heim_oid asn1_oid_id_pkcs_1 = { 6, oid_id_pkcs_1_variable_num };
     105             : 
     106             : static unsigned oid_id_pkcs1_rsaEncryption_variable_num[7] =  {1, 2, 840, 113549, 1, 1, 1 };
     107             : const heim_oid asn1_oid_id_pkcs1_rsaEncryption = { 7, oid_id_pkcs1_rsaEncryption_variable_num };
     108             : 
     109             : static unsigned oid_id_pkcs1_md2WithRSAEncryption_variable_num[7] =  {1, 2, 840, 113549, 1, 1, 2 };
     110             : const heim_oid asn1_oid_id_pkcs1_md2WithRSAEncryption = { 7, oid_id_pkcs1_md2WithRSAEncryption_variable_num };
     111             : 
     112             : static unsigned oid_id_pkcs1_md5WithRSAEncryption_variable_num[7] =  {1, 2, 840, 113549, 1, 1, 4 };
     113             : const heim_oid asn1_oid_id_pkcs1_md5WithRSAEncryption = { 7, oid_id_pkcs1_md5WithRSAEncryption_variable_num };
     114             : 
     115             : static unsigned oid_id_pkcs1_sha1WithRSAEncryption_variable_num[7] =  {1, 2, 840, 113549, 1, 1, 5 };
     116             : const heim_oid asn1_oid_id_pkcs1_sha1WithRSAEncryption = { 7, oid_id_pkcs1_sha1WithRSAEncryption_variable_num };
     117             : 
     118             : static unsigned oid_id_pkcs1_sha256WithRSAEncryption_variable_num[7] =  {1, 2, 840, 113549, 1, 1, 11 };
     119             : const heim_oid asn1_oid_id_pkcs1_sha256WithRSAEncryption = { 7, oid_id_pkcs1_sha256WithRSAEncryption_variable_num };
     120             : 
     121             : static unsigned oid_id_pkcs1_sha384WithRSAEncryption_variable_num[7] =  {1, 2, 840, 113549, 1, 1, 12 };
     122             : const heim_oid asn1_oid_id_pkcs1_sha384WithRSAEncryption = { 7, oid_id_pkcs1_sha384WithRSAEncryption_variable_num };
     123             : 
     124             : static unsigned oid_id_pkcs1_sha512WithRSAEncryption_variable_num[7] =  {1, 2, 840, 113549, 1, 1, 13 };
     125             : const heim_oid asn1_oid_id_pkcs1_sha512WithRSAEncryption = { 7, oid_id_pkcs1_sha512WithRSAEncryption_variable_num };
     126             : 
     127             : static unsigned oid_id_heim_rsa_pkcs1_x509_variable_num[6] =  {1, 2, 752, 43, 16, 1 };
     128             : const heim_oid asn1_oid_id_heim_rsa_pkcs1_x509 = { 6, oid_id_heim_rsa_pkcs1_x509_variable_num };
     129             : 
     130             : static unsigned oid_id_pkcs_2_variable_num[6] =  {1, 2, 840, 113549, 1, 2 };
     131             : const heim_oid asn1_oid_id_pkcs_2 = { 6, oid_id_pkcs_2_variable_num };
     132             : 
     133             : static unsigned oid_id_pkcs2_md2_variable_num[7] =  {1, 2, 840, 113549, 1, 2, 2 };
     134             : const heim_oid asn1_oid_id_pkcs2_md2 = { 7, oid_id_pkcs2_md2_variable_num };
     135             : 
     136             : static unsigned oid_id_pkcs2_md4_variable_num[7] =  {1, 2, 840, 113549, 1, 2, 4 };
     137             : const heim_oid asn1_oid_id_pkcs2_md4 = { 7, oid_id_pkcs2_md4_variable_num };
     138             : 
     139             : static unsigned oid_id_pkcs2_md5_variable_num[7] =  {1, 2, 840, 113549, 1, 2, 5 };
     140             : const heim_oid asn1_oid_id_pkcs2_md5 = { 7, oid_id_pkcs2_md5_variable_num };
     141             : 
     142             : static unsigned oid_id_rsa_digestAlgorithm_variable_num[5] =  {1, 2, 840, 113549, 2 };
     143             : const heim_oid asn1_oid_id_rsa_digestAlgorithm = { 5, oid_id_rsa_digestAlgorithm_variable_num };
     144             : 
     145             : static unsigned oid_id_rsa_digest_md2_variable_num[6] =  {1, 2, 840, 113549, 2, 2 };
     146             : const heim_oid asn1_oid_id_rsa_digest_md2 = { 6, oid_id_rsa_digest_md2_variable_num };
     147             : 
     148             : static unsigned oid_id_rsa_digest_md4_variable_num[6] =  {1, 2, 840, 113549, 2, 4 };
     149             : const heim_oid asn1_oid_id_rsa_digest_md4 = { 6, oid_id_rsa_digest_md4_variable_num };
     150             : 
     151             : static unsigned oid_id_rsa_digest_md5_variable_num[6] =  {1, 2, 840, 113549, 2, 5 };
     152             : const heim_oid asn1_oid_id_rsa_digest_md5 = { 6, oid_id_rsa_digest_md5_variable_num };
     153             : 
     154             : static unsigned oid_id_pkcs_3_variable_num[6] =  {1, 2, 840, 113549, 1, 3 };
     155             : const heim_oid asn1_oid_id_pkcs_3 = { 6, oid_id_pkcs_3_variable_num };
     156             : 
     157             : static unsigned oid_id_pkcs3_rc2_cbc_variable_num[7] =  {1, 2, 840, 113549, 1, 3, 2 };
     158             : const heim_oid asn1_oid_id_pkcs3_rc2_cbc = { 7, oid_id_pkcs3_rc2_cbc_variable_num };
     159             : 
     160             : static unsigned oid_id_pkcs3_rc4_variable_num[7] =  {1, 2, 840, 113549, 1, 3, 4 };
     161             : const heim_oid asn1_oid_id_pkcs3_rc4 = { 7, oid_id_pkcs3_rc4_variable_num };
     162             : 
     163             : static unsigned oid_id_pkcs3_des_ede3_cbc_variable_num[7] =  {1, 2, 840, 113549, 1, 3, 7 };
     164             : const heim_oid asn1_oid_id_pkcs3_des_ede3_cbc = { 7, oid_id_pkcs3_des_ede3_cbc_variable_num };
     165             : 
     166             : static unsigned oid_id_rsadsi_encalg_variable_num[5] =  {1, 2, 840, 113549, 3 };
     167             : const heim_oid asn1_oid_id_rsadsi_encalg = { 5, oid_id_rsadsi_encalg_variable_num };
     168             : 
     169             : static unsigned oid_id_rsadsi_rc2_cbc_variable_num[6] =  {1, 2, 840, 113549, 3, 2 };
     170             : const heim_oid asn1_oid_id_rsadsi_rc2_cbc = { 6, oid_id_rsadsi_rc2_cbc_variable_num };
     171             : 
     172             : static unsigned oid_id_rsadsi_des_ede3_cbc_variable_num[6] =  {1, 2, 840, 113549, 3, 7 };
     173             : const heim_oid asn1_oid_id_rsadsi_des_ede3_cbc = { 6, oid_id_rsadsi_des_ede3_cbc_variable_num };
     174             : 
     175             : static unsigned oid_id_secsig_sha_1_variable_num[6] =  {1, 3, 14, 3, 2, 26 };
     176             : const heim_oid asn1_oid_id_secsig_sha_1 = { 6, oid_id_secsig_sha_1_variable_num };
     177             : 
     178             : static unsigned oid_id_secsig_sha_1WithRSAEncryption_variable_num[6] =  {1, 3, 14, 3, 2, 29 };
     179             : const heim_oid asn1_oid_id_secsig_sha_1WithRSAEncryption = { 6, oid_id_secsig_sha_1WithRSAEncryption_variable_num };
     180             : 
     181             : static unsigned oid_id_nistAlgorithm_variable_num[7] =  {2, 16, 840, 1, 101, 3, 4 };
     182             : const heim_oid asn1_oid_id_nistAlgorithm = { 7, oid_id_nistAlgorithm_variable_num };
     183             : 
     184             : static unsigned oid_id_nist_aes_algs_variable_num[8] =  {2, 16, 840, 1, 101, 3, 4, 1 };
     185             : const heim_oid asn1_oid_id_nist_aes_algs = { 8, oid_id_nist_aes_algs_variable_num };
     186             : 
     187             : static unsigned oid_id_aes_128_cbc_variable_num[9] =  {2, 16, 840, 1, 101, 3, 4, 1, 2 };
     188             : const heim_oid asn1_oid_id_aes_128_cbc = { 9, oid_id_aes_128_cbc_variable_num };
     189             : 
     190             : static unsigned oid_id_aes_192_cbc_variable_num[9] =  {2, 16, 840, 1, 101, 3, 4, 1, 22 };
     191             : const heim_oid asn1_oid_id_aes_192_cbc = { 9, oid_id_aes_192_cbc_variable_num };
     192             : 
     193             : static unsigned oid_id_aes_256_cbc_variable_num[9] =  {2, 16, 840, 1, 101, 3, 4, 1, 42 };
     194             : const heim_oid asn1_oid_id_aes_256_cbc = { 9, oid_id_aes_256_cbc_variable_num };
     195             : 
     196             : static unsigned oid_id_nist_sha_algs_variable_num[8] =  {2, 16, 840, 1, 101, 3, 4, 2 };
     197             : const heim_oid asn1_oid_id_nist_sha_algs = { 8, oid_id_nist_sha_algs_variable_num };
     198             : 
     199             : static unsigned oid_id_sha256_variable_num[9] =  {2, 16, 840, 1, 101, 3, 4, 2, 1 };
     200             : const heim_oid asn1_oid_id_sha256 = { 9, oid_id_sha256_variable_num };
     201             : 
     202             : static unsigned oid_id_sha224_variable_num[9] =  {2, 16, 840, 1, 101, 3, 4, 2, 4 };
     203             : const heim_oid asn1_oid_id_sha224 = { 9, oid_id_sha224_variable_num };
     204             : 
     205             : static unsigned oid_id_sha384_variable_num[9] =  {2, 16, 840, 1, 101, 3, 4, 2, 2 };
     206             : const heim_oid asn1_oid_id_sha384 = { 9, oid_id_sha384_variable_num };
     207             : 
     208             : static unsigned oid_id_sha512_variable_num[9] =  {2, 16, 840, 1, 101, 3, 4, 2, 3 };
     209             : const heim_oid asn1_oid_id_sha512 = { 9, oid_id_sha512_variable_num };
     210             : 
     211             : static unsigned oid_id_dhpublicnumber_variable_num[6] =  {1, 2, 840, 10046, 2, 1 };
     212             : const heim_oid asn1_oid_id_dhpublicnumber = { 6, oid_id_dhpublicnumber_variable_num };
     213             : 
     214             : static unsigned oid_id_ecPublicKey_variable_num[6] =  {1, 2, 840, 10045, 2, 1 };
     215             : const heim_oid asn1_oid_id_ecPublicKey = { 6, oid_id_ecPublicKey_variable_num };
     216             : 
     217             : static unsigned oid_id_ecDH_variable_num[5] =  {1, 3, 132, 1, 12 };
     218             : const heim_oid asn1_oid_id_ecDH = { 5, oid_id_ecDH_variable_num };
     219             : 
     220             : static unsigned oid_id_ecMQV_variable_num[5] =  {1, 3, 132, 1, 13 };
     221             : const heim_oid asn1_oid_id_ecMQV = { 5, oid_id_ecMQV_variable_num };
     222             : 
     223             : static unsigned oid_id_ecdsa_with_SHA256_variable_num[7] =  {1, 2, 840, 10045, 4, 3, 2 };
     224             : const heim_oid asn1_oid_id_ecdsa_with_SHA256 = { 7, oid_id_ecdsa_with_SHA256_variable_num };
     225             : 
     226             : static unsigned oid_id_ecdsa_with_SHA1_variable_num[6] =  {1, 2, 840, 10045, 4, 1 };
     227             : const heim_oid asn1_oid_id_ecdsa_with_SHA1 = { 6, oid_id_ecdsa_with_SHA1_variable_num };
     228             : 
     229             : static unsigned oid_id_ec_group_secp256r1_variable_num[7] =  {1, 2, 840, 10045, 3, 1, 7 };
     230             : const heim_oid asn1_oid_id_ec_group_secp256r1 = { 7, oid_id_ec_group_secp256r1_variable_num };
     231             : 
     232             : static unsigned oid_id_ec_group_secp160r1_variable_num[5] =  {1, 3, 132, 0, 8 };
     233             : const heim_oid asn1_oid_id_ec_group_secp160r1 = { 5, oid_id_ec_group_secp160r1_variable_num };
     234             : 
     235             : static unsigned oid_id_ec_group_secp160r2_variable_num[5] =  {1, 3, 132, 0, 30 };
     236             : const heim_oid asn1_oid_id_ec_group_secp160r2 = { 5, oid_id_ec_group_secp160r2_variable_num };
     237             : 
     238             : static unsigned oid_id_x9_57_variable_num[5] =  {1, 2, 840, 10046, 4 };
     239             : const heim_oid asn1_oid_id_x9_57 = { 5, oid_id_x9_57_variable_num };
     240             : 
     241             : static unsigned oid_id_dsa_variable_num[6] =  {1, 2, 840, 10046, 4, 1 };
     242             : const heim_oid asn1_oid_id_dsa = { 6, oid_id_dsa_variable_num };
     243             : 
     244             : static unsigned oid_id_dsa_with_sha1_variable_num[6] =  {1, 2, 840, 10046, 4, 3 };
     245             : const heim_oid asn1_oid_id_dsa_with_sha1 = { 6, oid_id_dsa_with_sha1_variable_num };
     246             : 
     247             : static unsigned oid_id_x520_at_variable_num[3] =  {2, 5, 4 };
     248             : const heim_oid asn1_oid_id_x520_at = { 3, oid_id_x520_at_variable_num };
     249             : 
     250             : static unsigned oid_id_at_commonName_variable_num[4] =  {2, 5, 4, 3 };
     251             : const heim_oid asn1_oid_id_at_commonName = { 4, oid_id_at_commonName_variable_num };
     252             : 
     253             : static unsigned oid_id_at_surname_variable_num[4] =  {2, 5, 4, 4 };
     254             : const heim_oid asn1_oid_id_at_surname = { 4, oid_id_at_surname_variable_num };
     255             : 
     256             : static unsigned oid_id_at_serialNumber_variable_num[4] =  {2, 5, 4, 5 };
     257             : const heim_oid asn1_oid_id_at_serialNumber = { 4, oid_id_at_serialNumber_variable_num };
     258             : 
     259             : static unsigned oid_id_at_countryName_variable_num[4] =  {2, 5, 4, 6 };
     260             : const heim_oid asn1_oid_id_at_countryName = { 4, oid_id_at_countryName_variable_num };
     261             : 
     262             : static unsigned oid_id_at_localityName_variable_num[4] =  {2, 5, 4, 7 };
     263             : const heim_oid asn1_oid_id_at_localityName = { 4, oid_id_at_localityName_variable_num };
     264             : 
     265             : static unsigned oid_id_at_stateOrProvinceName_variable_num[4] =  {2, 5, 4, 8 };
     266             : const heim_oid asn1_oid_id_at_stateOrProvinceName = { 4, oid_id_at_stateOrProvinceName_variable_num };
     267             : 
     268             : static unsigned oid_id_at_streetAddress_variable_num[4] =  {2, 5, 4, 9 };
     269             : const heim_oid asn1_oid_id_at_streetAddress = { 4, oid_id_at_streetAddress_variable_num };
     270             : 
     271             : static unsigned oid_id_at_organizationName_variable_num[4] =  {2, 5, 4, 10 };
     272             : const heim_oid asn1_oid_id_at_organizationName = { 4, oid_id_at_organizationName_variable_num };
     273             : 
     274             : static unsigned oid_id_at_organizationalUnitName_variable_num[4] =  {2, 5, 4, 11 };
     275             : const heim_oid asn1_oid_id_at_organizationalUnitName = { 4, oid_id_at_organizationalUnitName_variable_num };
     276             : 
     277             : static unsigned oid_id_at_name_variable_num[4] =  {2, 5, 4, 41 };
     278             : const heim_oid asn1_oid_id_at_name = { 4, oid_id_at_name_variable_num };
     279             : 
     280             : static unsigned oid_id_at_givenName_variable_num[4] =  {2, 5, 4, 42 };
     281             : const heim_oid asn1_oid_id_at_givenName = { 4, oid_id_at_givenName_variable_num };
     282             : 
     283             : static unsigned oid_id_at_initials_variable_num[4] =  {2, 5, 4, 43 };
     284             : const heim_oid asn1_oid_id_at_initials = { 4, oid_id_at_initials_variable_num };
     285             : 
     286             : static unsigned oid_id_at_generationQualifier_variable_num[4] =  {2, 5, 4, 44 };
     287             : const heim_oid asn1_oid_id_at_generationQualifier = { 4, oid_id_at_generationQualifier_variable_num };
     288             : 
     289             : static unsigned oid_id_at_pseudonym_variable_num[4] =  {2, 5, 4, 65 };
     290             : const heim_oid asn1_oid_id_at_pseudonym = { 4, oid_id_at_pseudonym_variable_num };
     291             : 
     292             : static unsigned oid_id_Userid_variable_num[7] =  {0, 9, 2342, 19200300, 100, 1, 1 };
     293             : const heim_oid asn1_oid_id_Userid = { 7, oid_id_Userid_variable_num };
     294             : 
     295             : static unsigned oid_id_domainComponent_variable_num[7] =  {0, 9, 2342, 19200300, 100, 1, 25 };
     296             : const heim_oid asn1_oid_id_domainComponent = { 7, oid_id_domainComponent_variable_num };
     297             : 
     298             : static unsigned oid_id_x509_ce_variable_num[3] =  {2, 5, 29 };
     299             : const heim_oid asn1_oid_id_x509_ce = { 3, oid_id_x509_ce_variable_num };
     300             : 
     301             : int ASN1CALL
     302        1142 : encode_AlgorithmIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AlgorithmIdentifier *data, size_t *size)
     303             : {
     304        1142 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     305             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     306             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     307             : 
     308             : /* parameters */
     309        1142 : if((data)->parameters) {
     310         702 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     311         702 : ret = 0;
     312         702 : e = encode_heim_any(p, len, (data)->parameters, &l);
     313         702 : if (e) return e;
     314         702 : p -= l; len -= l; ret += l;
     315             : 
     316         702 : ret += Top_tag_oldret;
     317             : }
     318             : /* algorithm */
     319             : {
     320        1142 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     321        1142 : ret = 0;
     322        1142 : e = der_put_oid(p, len, &(data)->algorithm, &l);
     323        1142 : if (e) return e;
     324        1142 : p -= l; len -= l; ret += l;
     325             : 
     326        1142 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
     327        1142 : if (e) return e;
     328        1142 : p -= l; len -= l; ret += l;
     329             : 
     330        1142 : ret += Top_tag_oldret;
     331             : }
     332        1142 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
     333        1142 : if (e) return e;
     334        1142 : p -= l; len -= l; ret += l;
     335             : 
     336        1142 : *size = ret;
     337        1142 : return 0;
     338             : }
     339             : 
     340             : int ASN1CALL
     341        1682 : decode_AlgorithmIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AlgorithmIdentifier *data, size_t *size)
     342             : {
     343        1682 : size_t ret = 0;
     344             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     345             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     346             : 
     347        1682 : memset(data, 0, sizeof(*data));
     348             : {
     349             : size_t Top_datalen, Top_oldlen;
     350             : Der_type Top_type;
     351        1682 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
     352        1682 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
     353        1682 : if(e) goto fail;
     354        1682 : p += l; len -= l; ret += l;
     355        1682 : Top_oldlen = len;
     356        1682 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     357        1682 : len = Top_datalen;
     358             : {
     359             : size_t algorithm_datalen, algorithm_oldlen;
     360             : Der_type algorithm_type;
     361        1682 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &algorithm_type, UT_OID, &algorithm_datalen, &l);
     362        1682 : if (e == 0 && algorithm_type != PRIM) { e = ASN1_BAD_ID; }
     363        1682 : if(e) goto fail;
     364        1682 : p += l; len -= l; ret += l;
     365        1682 : algorithm_oldlen = len;
     366        1682 : if (algorithm_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     367        1682 : len = algorithm_datalen;
     368        1682 : e = der_get_oid(p, len, &(data)->algorithm, &l);
     369        1682 : if(e) goto fail;
     370        1682 : p += l; len -= l; ret += l;
     371        1682 : len = algorithm_oldlen - algorithm_datalen;
     372             : }
     373        1682 : (data)->parameters = calloc(1, sizeof(*(data)->parameters));
     374        1682 : if ((data)->parameters == NULL) goto fail;
     375        1682 : e = decode_heim_any(p, len, (data)->parameters, &l);
     376        1682 : if(e) {
     377         374 : free((data)->parameters);
     378         374 : (data)->parameters = NULL;
     379             : } else {
     380        1308 : p += l; len -= l; ret += l;
     381             : }
     382        1682 : len = Top_oldlen - Top_datalen;
     383             : }
     384        3364 : if(size) *size = ret;
     385        1634 : return 0;
     386           0 : fail:
     387           0 : free_AlgorithmIdentifier(data);
     388           0 : return e;
     389             : }
     390             : 
     391             : void ASN1CALL
     392        3816 : free_AlgorithmIdentifier(AlgorithmIdentifier *data)
     393             : {
     394        3816 : der_free_oid(&(data)->algorithm);
     395        3816 : if((data)->parameters) {
     396        2468 : free_heim_any((data)->parameters);
     397        2468 : free((data)->parameters);
     398        2468 : (data)->parameters = NULL;
     399             : }
     400        3816 : }
     401             : 
     402             : size_t ASN1CALL
     403        1340 : length_AlgorithmIdentifier(const AlgorithmIdentifier *data)
     404             : {
     405        1340 : size_t ret = 0;
     406             : {
     407        1340 : size_t Top_tag_oldret = ret;
     408        1340 : ret = 0;
     409        1340 : ret += der_length_oid(&(data)->algorithm);
     410        1340 : ret += 1 + der_length_len (ret);
     411        1340 : ret += Top_tag_oldret;
     412             : }
     413        1340 : if((data)->parameters){
     414         900 : size_t Top_tag_oldret = ret;
     415         900 : ret = 0;
     416         900 : ret += length_heim_any((data)->parameters);
     417         900 : ret += Top_tag_oldret;
     418             : }
     419        1340 : ret += 1 + der_length_len (ret);
     420        1340 : return ret;
     421             : }
     422             : 
     423             : int ASN1CALL
     424        2316 : copy_AlgorithmIdentifier(const AlgorithmIdentifier *from, AlgorithmIdentifier *to)
     425             : {
     426        2316 : memset(to, 0, sizeof(*to));
     427        2316 : if(der_copy_oid(&(from)->algorithm, &(to)->algorithm)) goto fail;
     428        2316 : if((from)->parameters) {
     429        1342 : (to)->parameters = malloc(sizeof(*(to)->parameters));
     430        1342 : if((to)->parameters == NULL) goto fail;
     431        1342 : if(copy_heim_any((from)->parameters, (to)->parameters)) goto fail;
     432             : }else
     433         974 : (to)->parameters = NULL;
     434        2260 : return 0;
     435           0 : fail:
     436           0 : free_AlgorithmIdentifier(to);
     437           0 : return ENOMEM;
     438             : }
     439             : 
     440             : int ASN1CALL
     441        1522 : encode_AttributeType(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AttributeType *data, size_t *size)
     442             : {
     443        1522 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     444             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     445             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     446             : 
     447        1522 : e = der_put_oid(p, len, data, &l);
     448        1522 : if (e) return e;
     449        1522 : p -= l; len -= l; ret += l;
     450             : 
     451        1522 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
     452        1522 : if (e) return e;
     453        1522 : p -= l; len -= l; ret += l;
     454             : 
     455        1522 : *size = ret;
     456        1522 : return 0;
     457             : }
     458             : 
     459             : int ASN1CALL
     460        3676 : decode_AttributeType(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AttributeType *data, size_t *size)
     461             : {
     462        3676 : size_t ret = 0;
     463             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     464             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     465             : 
     466        3676 : memset(data, 0, sizeof(*data));
     467             : {
     468             : size_t Top_datalen, Top_oldlen;
     469             : Der_type Top_type;
     470        3676 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OID, &Top_datalen, &l);
     471        3676 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
     472        3676 : if(e) goto fail;
     473        3676 : p += l; len -= l; ret += l;
     474        3676 : Top_oldlen = len;
     475        3676 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     476        3676 : len = Top_datalen;
     477        3676 : e = der_get_oid(p, len, data, &l);
     478        3676 : if(e) goto fail;
     479        3676 : p += l; len -= l; ret += l;
     480        3676 : len = Top_oldlen - Top_datalen;
     481             : }
     482        7352 : if(size) *size = ret;
     483        3460 : return 0;
     484           0 : fail:
     485           0 : free_AttributeType(data);
     486           0 : return e;
     487             : }
     488             : 
     489             : void ASN1CALL
     490        7216 : free_AttributeType(AttributeType *data)
     491             : {
     492        7216 : der_free_oid(data);
     493        7216 : }
     494             : 
     495             : size_t ASN1CALL
     496        3176 : length_AttributeType(const AttributeType *data)
     497             : {
     498        3176 : size_t ret = 0;
     499        3176 : ret += der_length_oid(data);
     500        3176 : ret += 1 + der_length_len (ret);
     501        3176 : return ret;
     502             : }
     503             : 
     504             : int ASN1CALL
     505        4996 : copy_AttributeType(const AttributeType *from, AttributeType *to)
     506             : {
     507        4996 : memset(to, 0, sizeof(*to));
     508        4996 : if(der_copy_oid(from, to)) goto fail;
     509        4780 : return 0;
     510           0 : fail:
     511           0 : free_AttributeType(to);
     512           0 : return ENOMEM;
     513             : }
     514             : 
     515             : int ASN1CALL
     516           0 : encode_AttributeValue(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AttributeValue *data, size_t *size)
     517             : {
     518           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     519             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     520             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     521             : 
     522           0 : e = encode_heim_any(p, len, data, &l);
     523           0 : if (e) return e;
     524           0 : p -= l; len -= l; ret += l;
     525             : 
     526           0 : *size = ret;
     527           0 : return 0;
     528             : }
     529             : 
     530             : int ASN1CALL
     531           0 : decode_AttributeValue(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AttributeValue *data, size_t *size)
     532             : {
     533           0 : size_t ret = 0;
     534             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     535             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     536             : 
     537           0 : memset(data, 0, sizeof(*data));
     538           0 : e = decode_heim_any(p, len, data, &l);
     539           0 : if(e) goto fail;
     540           0 : p += l; len -= l; ret += l;
     541           0 : if(size) *size = ret;
     542           0 : return 0;
     543           0 : fail:
     544           0 : free_AttributeValue(data);
     545           0 : return e;
     546             : }
     547             : 
     548             : void ASN1CALL
     549           0 : free_AttributeValue(AttributeValue *data)
     550             : {
     551           0 : free_heim_any(data);
     552           0 : }
     553             : 
     554             : size_t ASN1CALL
     555           0 : length_AttributeValue(const AttributeValue *data)
     556             : {
     557           0 : size_t ret = 0;
     558           0 : ret += length_heim_any(data);
     559           0 : return ret;
     560             : }
     561             : 
     562             : int ASN1CALL
     563           0 : copy_AttributeValue(const AttributeValue *from, AttributeValue *to)
     564             : {
     565           0 : memset(to, 0, sizeof(*to));
     566           0 : if(copy_heim_any(from, to)) goto fail;
     567           0 : return 0;
     568           0 : fail:
     569           0 : free_AttributeValue(to);
     570           0 : return ENOMEM;
     571             : }
     572             : 
     573             : int ASN1CALL
     574        1138 : encode_DirectoryString(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DirectoryString *data, size_t *size)
     575             : {
     576        1138 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     577             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     578             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     579             : 
     580             : 
     581        1138 : switch((data)->element) {
     582           0 : case choice_DirectoryString_bmpString: {size_t Top_oldret = ret;
     583           0 : ret = 0;
     584           0 : e = der_put_bmp_string(p, len, &((data))->u.bmpString, &l);
     585           0 : if (e) return e;
     586           0 : p -= l; len -= l; ret += l;
     587             : 
     588           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BMPString, &l);
     589           0 : if (e) return e;
     590           0 : p -= l; len -= l; ret += l;
     591             : 
     592           0 : ret += Top_oldret;
     593           0 : break;
     594             : }
     595         794 : case choice_DirectoryString_utf8String: {size_t Top_oldret = ret;
     596         794 : ret = 0;
     597         794 : e = der_put_utf8string(p, len, &((data))->u.utf8String, &l);
     598         794 : if (e) return e;
     599         794 : p -= l; len -= l; ret += l;
     600             : 
     601         794 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
     602         794 : if (e) return e;
     603         794 : p -= l; len -= l; ret += l;
     604             : 
     605         794 : ret += Top_oldret;
     606         794 : break;
     607             : }
     608           0 : case choice_DirectoryString_universalString: {size_t Top_oldret = ret;
     609           0 : ret = 0;
     610           0 : e = der_put_universal_string(p, len, &((data))->u.universalString, &l);
     611           0 : if (e) return e;
     612           0 : p -= l; len -= l; ret += l;
     613             : 
     614           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GraphicString, &l);
     615           0 : if (e) return e;
     616           0 : p -= l; len -= l; ret += l;
     617             : 
     618           0 : ret += Top_oldret;
     619           0 : break;
     620             : }
     621         172 : case choice_DirectoryString_printableString: {size_t Top_oldret = ret;
     622         172 : ret = 0;
     623         172 : e = der_put_printable_string(p, len, &((data))->u.printableString, &l);
     624         172 : if (e) return e;
     625         172 : p -= l; len -= l; ret += l;
     626             : 
     627         172 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_PrintableString, &l);
     628         172 : if (e) return e;
     629         172 : p -= l; len -= l; ret += l;
     630             : 
     631         172 : ret += Top_oldret;
     632         172 : break;
     633             : }
     634           0 : case choice_DirectoryString_teletexString: {size_t Top_oldret = ret;
     635           0 : ret = 0;
     636           0 : e = der_put_general_string(p, len, &((data))->u.teletexString, &l);
     637           0 : if (e) return e;
     638           0 : p -= l; len -= l; ret += l;
     639             : 
     640           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_TeletexString, &l);
     641           0 : if (e) return e;
     642           0 : p -= l; len -= l; ret += l;
     643             : 
     644           0 : ret += Top_oldret;
     645           0 : break;
     646             : }
     647         172 : case choice_DirectoryString_ia5String: {size_t Top_oldret = ret;
     648         172 : ret = 0;
     649         172 : e = der_put_ia5_string(p, len, &((data))->u.ia5String, &l);
     650         172 : if (e) return e;
     651         172 : p -= l; len -= l; ret += l;
     652             : 
     653         172 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_IA5String, &l);
     654         172 : if (e) return e;
     655         172 : p -= l; len -= l; ret += l;
     656             : 
     657         172 : ret += Top_oldret;
     658         172 : break;
     659             : }
     660             : };
     661        1138 : *size = ret;
     662        1138 : return 0;
     663             : }
     664             : 
     665             : int ASN1CALL
     666        3556 : decode_DirectoryString(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DirectoryString *data, size_t *size)
     667             : {
     668        3556 : size_t ret = 0;
     669             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     670             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     671             : 
     672        3556 : memset(data, 0, sizeof(*data));
     673        3556 : if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_IA5String, NULL) == 0) {
     674             : {
     675             : size_t ia5String_datalen, ia5String_oldlen;
     676             : Der_type ia5String_type;
     677         530 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &ia5String_type, UT_IA5String, &ia5String_datalen, &l);
     678         530 : if (e == 0 && ia5String_type != PRIM) { e = ASN1_BAD_ID; }
     679         530 : if(e) goto fail;
     680         530 : p += l; len -= l; ret += l;
     681         530 : ia5String_oldlen = len;
     682         530 : if (ia5String_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     683         530 : len = ia5String_datalen;
     684         530 : e = der_get_ia5_string(p, len, &(data)->u.ia5String, &l);
     685         530 : if(e) goto fail;
     686         530 : p += l; len -= l; ret += l;
     687         530 : len = ia5String_oldlen - ia5String_datalen;
     688             : }
     689         530 : (data)->element = choice_DirectoryString_ia5String;
     690             : }
     691        3026 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_TeletexString, NULL) == 0) {
     692             : {
     693             : size_t teletexString_datalen, teletexString_oldlen;
     694             : Der_type teletexString_type;
     695           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &teletexString_type, UT_TeletexString, &teletexString_datalen, &l);
     696           0 : if (e == 0 && teletexString_type != PRIM) { e = ASN1_BAD_ID; }
     697           0 : if(e) goto fail;
     698           0 : p += l; len -= l; ret += l;
     699           0 : teletexString_oldlen = len;
     700           0 : if (teletexString_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     701           0 : len = teletexString_datalen;
     702           0 : e = der_get_general_string(p, len, &(data)->u.teletexString, &l);
     703           0 : if(e) goto fail;
     704           0 : p += l; len -= l; ret += l;
     705           0 : len = teletexString_oldlen - teletexString_datalen;
     706             : }
     707           0 : (data)->element = choice_DirectoryString_teletexString;
     708             : }
     709        3026 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_PrintableString, NULL) == 0) {
     710             : {
     711             : size_t printableString_datalen, printableString_oldlen;
     712             : Der_type printableString_type;
     713         530 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &printableString_type, UT_PrintableString, &printableString_datalen, &l);
     714         530 : if (e == 0 && printableString_type != PRIM) { e = ASN1_BAD_ID; }
     715         530 : if(e) goto fail;
     716         530 : p += l; len -= l; ret += l;
     717         530 : printableString_oldlen = len;
     718         530 : if (printableString_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     719         530 : len = printableString_datalen;
     720         530 : e = der_get_printable_string(p, len, &(data)->u.printableString, &l);
     721         530 : if(e) goto fail;
     722         530 : p += l; len -= l; ret += l;
     723         530 : len = printableString_oldlen - printableString_datalen;
     724             : }
     725         530 : (data)->element = choice_DirectoryString_printableString;
     726             : }
     727        2496 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_GraphicString, NULL) == 0) {
     728             : {
     729             : size_t universalString_datalen, universalString_oldlen;
     730             : Der_type universalString_type;
     731           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &universalString_type, UT_GraphicString, &universalString_datalen, &l);
     732           0 : if (e == 0 && universalString_type != PRIM) { e = ASN1_BAD_ID; }
     733           0 : if(e) goto fail;
     734           0 : p += l; len -= l; ret += l;
     735           0 : universalString_oldlen = len;
     736           0 : if (universalString_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     737           0 : len = universalString_datalen;
     738           0 : e = der_get_universal_string(p, len, &(data)->u.universalString, &l);
     739           0 : if(e) goto fail;
     740           0 : p += l; len -= l; ret += l;
     741           0 : len = universalString_oldlen - universalString_datalen;
     742             : }
     743           0 : (data)->element = choice_DirectoryString_universalString;
     744             : }
     745        2496 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_UTF8String, NULL) == 0) {
     746             : {
     747             : size_t utf8String_datalen, utf8String_oldlen;
     748             : Der_type utf8String_type;
     749        2496 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &utf8String_type, UT_UTF8String, &utf8String_datalen, &l);
     750        2496 : if (e == 0 && utf8String_type != PRIM) { e = ASN1_BAD_ID; }
     751        2496 : if(e) goto fail;
     752        2496 : p += l; len -= l; ret += l;
     753        2496 : utf8String_oldlen = len;
     754        2496 : if (utf8String_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     755        2496 : len = utf8String_datalen;
     756        2496 : e = der_get_utf8string(p, len, &(data)->u.utf8String, &l);
     757        2496 : if(e) goto fail;
     758        2496 : p += l; len -= l; ret += l;
     759        2496 : len = utf8String_oldlen - utf8String_datalen;
     760             : }
     761        2496 : (data)->element = choice_DirectoryString_utf8String;
     762             : }
     763           0 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_BMPString, NULL) == 0) {
     764             : {
     765             : size_t bmpString_datalen, bmpString_oldlen;
     766             : Der_type bmpString_type;
     767           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &bmpString_type, UT_BMPString, &bmpString_datalen, &l);
     768           0 : if (e == 0 && bmpString_type != PRIM) { e = ASN1_BAD_ID; }
     769           0 : if(e) goto fail;
     770           0 : p += l; len -= l; ret += l;
     771           0 : bmpString_oldlen = len;
     772           0 : if (bmpString_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     773           0 : len = bmpString_datalen;
     774           0 : e = der_get_bmp_string(p, len, &(data)->u.bmpString, &l);
     775           0 : if(e) goto fail;
     776           0 : p += l; len -= l; ret += l;
     777           0 : len = bmpString_oldlen - bmpString_datalen;
     778             : }
     779           0 : (data)->element = choice_DirectoryString_bmpString;
     780             : }
     781             : else {
     782           0 : e = ASN1_PARSE_ERROR;
     783           0 : goto fail;
     784             : }
     785        3556 : if(size) *size = ret;
     786        3340 : return 0;
     787           0 : fail:
     788           0 : free_DirectoryString(data);
     789           0 : return e;
     790             : }
     791             : 
     792             : void ASN1CALL
     793        6964 : free_DirectoryString(DirectoryString *data)
     794             : {
     795        6964 : switch((data)->element) {
     796        1044 : case choice_DirectoryString_ia5String:
     797        1044 : der_free_ia5_string(&(data)->u.ia5String);
     798        1044 : break;
     799           0 : case choice_DirectoryString_teletexString:
     800           0 : der_free_general_string(&(data)->u.teletexString);
     801           0 : break;
     802        1044 : case choice_DirectoryString_printableString:
     803        1044 : der_free_printable_string(&(data)->u.printableString);
     804        1044 : break;
     805           0 : case choice_DirectoryString_universalString:
     806           0 : der_free_universal_string(&(data)->u.universalString);
     807           0 : break;
     808        4876 : case choice_DirectoryString_utf8String:
     809        4876 : der_free_utf8string(&(data)->u.utf8String);
     810        4876 : break;
     811           0 : case choice_DirectoryString_bmpString:
     812           0 : der_free_bmp_string(&(data)->u.bmpString);
     813           0 : break;
     814             : }
     815        6964 : }
     816             : 
     817             : size_t ASN1CALL
     818        2276 : length_DirectoryString(const DirectoryString *data)
     819             : {
     820        2276 : size_t ret = 0;
     821        2276 : switch((data)->element) {
     822         344 : case choice_DirectoryString_ia5String:
     823             : {
     824         344 : size_t Top_oldret = ret;
     825         344 : ret = 0;
     826         344 : ret += der_length_ia5_string(&(data)->u.ia5String);
     827         344 : ret += 1 + der_length_len (ret);
     828         344 : ret += Top_oldret;
     829             : }
     830         344 : break;
     831           0 : case choice_DirectoryString_teletexString:
     832             : {
     833           0 : size_t Top_oldret = ret;
     834           0 : ret = 0;
     835           0 : ret += der_length_general_string(&(data)->u.teletexString);
     836           0 : ret += 1 + der_length_len (ret);
     837           0 : ret += Top_oldret;
     838             : }
     839           0 : break;
     840         344 : case choice_DirectoryString_printableString:
     841             : {
     842         344 : size_t Top_oldret = ret;
     843         344 : ret = 0;
     844         344 : ret += der_length_printable_string(&(data)->u.printableString);
     845         344 : ret += 1 + der_length_len (ret);
     846         344 : ret += Top_oldret;
     847             : }
     848         344 : break;
     849           0 : case choice_DirectoryString_universalString:
     850             : {
     851           0 : size_t Top_oldret = ret;
     852           0 : ret = 0;
     853           0 : ret += der_length_universal_string(&(data)->u.universalString);
     854           0 : ret += 1 + der_length_len (ret);
     855           0 : ret += Top_oldret;
     856             : }
     857           0 : break;
     858        1588 : case choice_DirectoryString_utf8String:
     859             : {
     860        1588 : size_t Top_oldret = ret;
     861        1588 : ret = 0;
     862        1588 : ret += der_length_utf8string(&(data)->u.utf8String);
     863        1588 : ret += 1 + der_length_len (ret);
     864        1588 : ret += Top_oldret;
     865             : }
     866        1588 : break;
     867           0 : case choice_DirectoryString_bmpString:
     868             : {
     869           0 : size_t Top_oldret = ret;
     870           0 : ret = 0;
     871           0 : ret += der_length_bmp_string(&(data)->u.bmpString);
     872           0 : ret += 1 + der_length_len (ret);
     873           0 : ret += Top_oldret;
     874             : }
     875           0 : break;
     876             : }
     877        2276 : return ret;
     878             : }
     879             : 
     880             : int ASN1CALL
     881        4996 : copy_DirectoryString(const DirectoryString *from, DirectoryString *to)
     882             : {
     883        4996 : memset(to, 0, sizeof(*to));
     884        4996 : (to)->element = (from)->element;
     885        4996 : switch((from)->element) {
     886         750 : case choice_DirectoryString_ia5String:
     887         750 : if(der_copy_ia5_string(&(from)->u.ia5String, &(to)->u.ia5String)) goto fail;
     888         718 : break;
     889           0 : case choice_DirectoryString_teletexString:
     890           0 : if(der_copy_general_string(&(from)->u.teletexString, &(to)->u.teletexString)) goto fail;
     891           0 : break;
     892         750 : case choice_DirectoryString_printableString:
     893         750 : if(der_copy_printable_string(&(from)->u.printableString, &(to)->u.printableString)) goto fail;
     894         718 : break;
     895           0 : case choice_DirectoryString_universalString:
     896           0 : if(der_copy_universal_string(&(from)->u.universalString, &(to)->u.universalString)) goto fail;
     897           0 : break;
     898        3496 : case choice_DirectoryString_utf8String:
     899        3496 : if(der_copy_utf8string(&(from)->u.utf8String, &(to)->u.utf8String)) goto fail;
     900        3344 : break;
     901           0 : case choice_DirectoryString_bmpString:
     902           0 : if(der_copy_bmp_string(&(from)->u.bmpString, &(to)->u.bmpString)) goto fail;
     903           0 : break;
     904             : }
     905        4780 : return 0;
     906           0 : fail:
     907           0 : free_DirectoryString(to);
     908           0 : return ENOMEM;
     909             : }
     910             : 
     911             : int ASN1CALL
     912         384 : encode_Attribute(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Attribute *data, size_t *size)
     913             : {
     914         384 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     915             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     916             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     917             : 
     918             : /* value */
     919             : {
     920         384 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     921         384 : ret = 0;
     922             : {
     923             : struct heim_octet_string *val;
     924         384 : size_t elen = 0, totallen = 0;
     925         384 : int eret = 0;
     926         384 : if ((&(data)->value)->len > UINT_MAX/sizeof(val[0]))
     927           0 : return ERANGE;
     928         384 : val = malloc(sizeof(val[0]) * (&(data)->value)->len);
     929         384 : if (val == NULL && (&(data)->value)->len != 0) return ENOMEM;
     930         768 : for(i = 0; i < (int)(&(data)->value)->len; i++) {
     931         384 : ASN1_MALLOC_ENCODE(heim_any, val[i].data, val[i].length, &(&(data)->value)->val[i], &elen, eret);
     932         384 : if(eret) {
     933           0 : i--;
     934           0 : while (i >= 0) {
     935           0 : free(val[i].data);
     936           0 : i--;
     937             : }
     938           0 : free(val);
     939           0 : return eret;
     940             : }
     941         384 : totallen += elen;
     942             : }
     943         384 : if (totallen > len) {
     944           0 : for (i = 0; i < (int)(&(data)->value)->len; i++) {
     945           0 : free(val[i].data);
     946             : }
     947           0 : free(val);
     948           0 : return ASN1_OVERFLOW;
     949             : }
     950         384 : qsort(val, (&(data)->value)->len, sizeof(val[0]), _heim_der_set_sort);
     951         768 : for(i = (int)(&(data)->value)->len - 1; i >= 0; --i) {
     952         384 : p -= val[i].length;
     953         384 : ret += val[i].length;
     954         384 : memcpy(p + 1, val[i].data, val[i].length);
     955         384 : free(val[i].data);
     956             : }
     957         384 : free(val);
     958             : }
     959         384 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
     960         384 : if (e) return e;
     961         384 : p -= l; len -= l; ret += l;
     962             : 
     963         384 : ret += Top_tag_oldret;
     964             : }
     965             : /* type */
     966             : {
     967         384 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     968         384 : ret = 0;
     969         384 : e = encode_AttributeType(p, len, &(data)->type, &l);
     970         384 : if (e) return e;
     971         384 : p -= l; len -= l; ret += l;
     972             : 
     973         384 : ret += Top_tag_oldret;
     974             : }
     975         384 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
     976         384 : if (e) return e;
     977         384 : p -= l; len -= l; ret += l;
     978             : 
     979         384 : *size = ret;
     980         384 : return 0;
     981             : }
     982             : 
     983             : int ASN1CALL
     984         120 : decode_Attribute(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Attribute *data, size_t *size)
     985             : {
     986         120 : size_t ret = 0;
     987             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     988             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     989             : 
     990         120 : memset(data, 0, sizeof(*data));
     991             : {
     992             : size_t Top_datalen, Top_oldlen;
     993             : Der_type Top_type;
     994         120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
     995         120 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
     996         120 : if(e) goto fail;
     997         120 : p += l; len -= l; ret += l;
     998         120 : Top_oldlen = len;
     999         120 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1000         120 : len = Top_datalen;
    1001         120 : e = decode_AttributeType(p, len, &(data)->type, &l);
    1002         120 : if(e) goto fail;
    1003         120 : p += l; len -= l; ret += l;
    1004             : {
    1005             : size_t value_datalen, value_oldlen;
    1006             : Der_type value_type;
    1007         120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &value_type, UT_Set, &value_datalen, &l);
    1008         120 : if (e == 0 && value_type != CONS) { e = ASN1_BAD_ID; }
    1009         120 : if(e) goto fail;
    1010         120 : p += l; len -= l; ret += l;
    1011         120 : value_oldlen = len;
    1012         120 : if (value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1013         120 : len = value_datalen;
    1014             : {
    1015         120 : size_t value_Tag_origlen = len;
    1016         120 : size_t value_Tag_oldret = ret;
    1017         120 : size_t value_Tag_olen = 0;
    1018             : void *value_Tag_tmp;
    1019         120 : ret = 0;
    1020         120 : (&(data)->value)->len = 0;
    1021         120 : (&(data)->value)->val = NULL;
    1022         360 : while(ret < value_Tag_origlen) {
    1023         120 : size_t value_Tag_nlen = value_Tag_olen + sizeof(*((&(data)->value)->val));
    1024         120 : if (value_Tag_olen > value_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    1025         120 : value_Tag_olen = value_Tag_nlen;
    1026         120 : value_Tag_tmp = realloc((&(data)->value)->val, value_Tag_olen);
    1027         120 : if (value_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    1028         120 : (&(data)->value)->val = value_Tag_tmp;
    1029         120 : e = decode_heim_any(p, len, &(&(data)->value)->val[(&(data)->value)->len], &l);
    1030         120 : if(e) goto fail;
    1031         120 : p += l; len -= l; ret += l;
    1032         120 : (&(data)->value)->len++;
    1033         120 : len = value_Tag_origlen - ret;
    1034             : }
    1035         120 : ret += value_Tag_oldret;
    1036             : }
    1037         120 : len = value_oldlen - value_datalen;
    1038             : }
    1039         120 : len = Top_oldlen - Top_datalen;
    1040             : }
    1041         240 : if(size) *size = ret;
    1042         120 : return 0;
    1043           0 : fail:
    1044           0 : free_Attribute(data);
    1045           0 : return e;
    1046             : }
    1047             : 
    1048             : void ASN1CALL
    1049         252 : free_Attribute(Attribute *data)
    1050             : {
    1051         252 : free_AttributeType(&(data)->type);
    1052         756 : while((&(data)->value)->len){
    1053         252 : free_heim_any(&(&(data)->value)->val[(&(data)->value)->len-1]);
    1054         252 : (&(data)->value)->len--;
    1055             : }
    1056         252 : free((&(data)->value)->val);
    1057         252 : (&(data)->value)->val = NULL;
    1058         252 : }
    1059             : 
    1060             : size_t ASN1CALL
    1061         900 : length_Attribute(const Attribute *data)
    1062             : {
    1063         900 : size_t ret = 0;
    1064             : {
    1065         900 : size_t Top_tag_oldret = ret;
    1066         900 : ret = 0;
    1067         900 : ret += length_AttributeType(&(data)->type);
    1068         900 : ret += Top_tag_oldret;
    1069             : }
    1070             : {
    1071         900 : size_t Top_tag_oldret = ret;
    1072         900 : ret = 0;
    1073             : {
    1074         900 : size_t value_tag_oldret = ret;
    1075             : int i;
    1076         900 : ret = 0;
    1077        1800 : for(i = (&(data)->value)->len - 1; i >= 0; --i){
    1078         900 : size_t value_tag_for_oldret = ret;
    1079         900 : ret = 0;
    1080         900 : ret += length_heim_any(&(&(data)->value)->val[i]);
    1081         900 : ret += value_tag_for_oldret;
    1082             : }
    1083         900 : ret += value_tag_oldret;
    1084             : }
    1085         900 : ret += 1 + der_length_len (ret);
    1086         900 : ret += Top_tag_oldret;
    1087             : }
    1088         900 : ret += 1 + der_length_len (ret);
    1089         900 : return ret;
    1090             : }
    1091             : 
    1092             : int ASN1CALL
    1093           0 : copy_Attribute(const Attribute *from, Attribute *to)
    1094             : {
    1095           0 : memset(to, 0, sizeof(*to));
    1096           0 : if(copy_AttributeType(&(from)->type, &(to)->type)) goto fail;
    1097           0 : if(((&(to)->value)->val = malloc((&(from)->value)->len * sizeof(*(&(to)->value)->val))) == NULL && (&(from)->value)->len != 0)
    1098           0 : goto fail;
    1099           0 : for((&(to)->value)->len = 0; (&(to)->value)->len < (&(from)->value)->len; (&(to)->value)->len++){
    1100           0 : if(copy_heim_any(&(&(from)->value)->val[(&(to)->value)->len], &(&(to)->value)->val[(&(to)->value)->len])) goto fail;
    1101             : }
    1102           0 : return 0;
    1103           0 : fail:
    1104           0 : free_Attribute(to);
    1105           0 : return ENOMEM;
    1106             : }
    1107             : 
    1108             : int ASN1CALL
    1109        1138 : encode_AttributeTypeAndValue(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AttributeTypeAndValue *data, size_t *size)
    1110             : {
    1111        1138 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1112             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1113             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1114             : 
    1115             : /* value */
    1116             : {
    1117        1138 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    1118        1138 : ret = 0;
    1119        1138 : e = encode_DirectoryString(p, len, &(data)->value, &l);
    1120        1138 : if (e) return e;
    1121        1138 : p -= l; len -= l; ret += l;
    1122             : 
    1123        1138 : ret += Top_tag_oldret;
    1124             : }
    1125             : /* type */
    1126             : {
    1127        1138 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    1128        1138 : ret = 0;
    1129        1138 : e = encode_AttributeType(p, len, &(data)->type, &l);
    1130        1138 : if (e) return e;
    1131        1138 : p -= l; len -= l; ret += l;
    1132             : 
    1133        1138 : ret += Top_tag_oldret;
    1134             : }
    1135        1138 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    1136        1138 : if (e) return e;
    1137        1138 : p -= l; len -= l; ret += l;
    1138             : 
    1139        1138 : *size = ret;
    1140        1138 : return 0;
    1141             : }
    1142             : 
    1143             : int ASN1CALL
    1144        3556 : decode_AttributeTypeAndValue(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AttributeTypeAndValue *data, size_t *size)
    1145             : {
    1146        3556 : size_t ret = 0;
    1147             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1148             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1149             : 
    1150        3556 : memset(data, 0, sizeof(*data));
    1151             : {
    1152             : size_t Top_datalen, Top_oldlen;
    1153             : Der_type Top_type;
    1154        3556 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    1155        3556 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    1156        3556 : if(e) goto fail;
    1157        3556 : p += l; len -= l; ret += l;
    1158        3556 : Top_oldlen = len;
    1159        3556 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1160        3556 : len = Top_datalen;
    1161        3556 : e = decode_AttributeType(p, len, &(data)->type, &l);
    1162        3556 : if(e) goto fail;
    1163        3556 : p += l; len -= l; ret += l;
    1164        3556 : e = decode_DirectoryString(p, len, &(data)->value, &l);
    1165        3556 : if(e) goto fail;
    1166        3556 : p += l; len -= l; ret += l;
    1167        3556 : len = Top_oldlen - Top_datalen;
    1168             : }
    1169        7112 : if(size) *size = ret;
    1170        3340 : return 0;
    1171           0 : fail:
    1172           0 : free_AttributeTypeAndValue(data);
    1173           0 : return e;
    1174             : }
    1175             : 
    1176             : void ASN1CALL
    1177        6964 : free_AttributeTypeAndValue(AttributeTypeAndValue *data)
    1178             : {
    1179        6964 : free_AttributeType(&(data)->type);
    1180        6964 : free_DirectoryString(&(data)->value);
    1181        6964 : }
    1182             : 
    1183             : size_t ASN1CALL
    1184        2276 : length_AttributeTypeAndValue(const AttributeTypeAndValue *data)
    1185             : {
    1186        2276 : size_t ret = 0;
    1187             : {
    1188        2276 : size_t Top_tag_oldret = ret;
    1189        2276 : ret = 0;
    1190        2276 : ret += length_AttributeType(&(data)->type);
    1191        2276 : ret += Top_tag_oldret;
    1192             : }
    1193             : {
    1194        2276 : size_t Top_tag_oldret = ret;
    1195        2276 : ret = 0;
    1196        2276 : ret += length_DirectoryString(&(data)->value);
    1197        2276 : ret += Top_tag_oldret;
    1198             : }
    1199        2276 : ret += 1 + der_length_len (ret);
    1200        2276 : return ret;
    1201             : }
    1202             : 
    1203             : int ASN1CALL
    1204        4996 : copy_AttributeTypeAndValue(const AttributeTypeAndValue *from, AttributeTypeAndValue *to)
    1205             : {
    1206        4996 : memset(to, 0, sizeof(*to));
    1207        4996 : if(copy_AttributeType(&(from)->type, &(to)->type)) goto fail;
    1208        4996 : if(copy_DirectoryString(&(from)->value, &(to)->value)) goto fail;
    1209        4780 : return 0;
    1210           0 : fail:
    1211           0 : free_AttributeTypeAndValue(to);
    1212           0 : return ENOMEM;
    1213             : }
    1214             : 
    1215             : int ASN1CALL
    1216        1138 : encode_RelativeDistinguishedName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RelativeDistinguishedName *data, size_t *size)
    1217             : {
    1218        1138 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1219             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1220             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1221             : 
    1222             : {
    1223             : struct heim_octet_string *val;
    1224        1138 : size_t elen = 0, totallen = 0;
    1225        1138 : int eret = 0;
    1226        1138 : if ((data)->len > UINT_MAX/sizeof(val[0]))
    1227           0 : return ERANGE;
    1228        1138 : val = malloc(sizeof(val[0]) * (data)->len);
    1229        1138 : if (val == NULL && (data)->len != 0) return ENOMEM;
    1230        2276 : for(i = 0; i < (int)(data)->len; i++) {
    1231        1138 : ASN1_MALLOC_ENCODE(AttributeTypeAndValue, val[i].data, val[i].length, &(data)->val[i], &elen, eret);
    1232        1138 : if(eret) {
    1233           0 : i--;
    1234           0 : while (i >= 0) {
    1235           0 : free(val[i].data);
    1236           0 : i--;
    1237             : }
    1238           0 : free(val);
    1239           0 : return eret;
    1240             : }
    1241        1138 : totallen += elen;
    1242             : }
    1243        1138 : if (totallen > len) {
    1244           0 : for (i = 0; i < (int)(data)->len; i++) {
    1245           0 : free(val[i].data);
    1246             : }
    1247           0 : free(val);
    1248           0 : return ASN1_OVERFLOW;
    1249             : }
    1250        1138 : qsort(val, (data)->len, sizeof(val[0]), _heim_der_set_sort);
    1251        2276 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    1252        1138 : p -= val[i].length;
    1253        1138 : ret += val[i].length;
    1254        1138 : memcpy(p + 1, val[i].data, val[i].length);
    1255        1138 : free(val[i].data);
    1256             : }
    1257        1138 : free(val);
    1258             : }
    1259        1138 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Set, &l);
    1260        1138 : if (e) return e;
    1261        1138 : p -= l; len -= l; ret += l;
    1262             : 
    1263        1138 : *size = ret;
    1264        1138 : return 0;
    1265             : }
    1266             : 
    1267             : int ASN1CALL
    1268        3556 : decode_RelativeDistinguishedName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RelativeDistinguishedName *data, size_t *size)
    1269             : {
    1270        3556 : size_t ret = 0;
    1271             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1272             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1273             : 
    1274        3556 : memset(data, 0, sizeof(*data));
    1275             : {
    1276             : size_t Top_datalen, Top_oldlen;
    1277             : Der_type Top_type;
    1278        3556 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Set, &Top_datalen, &l);
    1279        3556 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    1280        3556 : if(e) goto fail;
    1281        3556 : p += l; len -= l; ret += l;
    1282        3556 : Top_oldlen = len;
    1283        3556 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1284        3556 : len = Top_datalen;
    1285             : {
    1286        3556 : size_t Top_Tag_origlen = len;
    1287        3556 : size_t Top_Tag_oldret = ret;
    1288        3556 : size_t Top_Tag_olen = 0;
    1289             : void *Top_Tag_tmp;
    1290        3556 : ret = 0;
    1291        3556 : (data)->len = 0;
    1292        3556 : (data)->val = NULL;
    1293       10668 : while(ret < Top_Tag_origlen) {
    1294        3556 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    1295        3556 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    1296        3556 : Top_Tag_olen = Top_Tag_nlen;
    1297        3556 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    1298        3556 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    1299        3556 : (data)->val = Top_Tag_tmp;
    1300        3556 : e = decode_AttributeTypeAndValue(p, len, &(data)->val[(data)->len], &l);
    1301        3556 : if(e) goto fail;
    1302        3556 : p += l; len -= l; ret += l;
    1303        3556 : (data)->len++;
    1304        3556 : len = Top_Tag_origlen - ret;
    1305             : }
    1306        3556 : ret += Top_Tag_oldret;
    1307             : }
    1308        3556 : len = Top_oldlen - Top_datalen;
    1309             : }
    1310        7112 : if(size) *size = ret;
    1311        3340 : return 0;
    1312           0 : fail:
    1313           0 : free_RelativeDistinguishedName(data);
    1314           0 : return e;
    1315             : }
    1316             : 
    1317             : void ASN1CALL
    1318        6964 : free_RelativeDistinguishedName(RelativeDistinguishedName *data)
    1319             : {
    1320       20892 : while((data)->len){
    1321        6964 : free_AttributeTypeAndValue(&(data)->val[(data)->len-1]);
    1322        6964 : (data)->len--;
    1323             : }
    1324        6964 : free((data)->val);
    1325        6964 : (data)->val = NULL;
    1326        6964 : }
    1327             : 
    1328             : size_t ASN1CALL
    1329        1138 : length_RelativeDistinguishedName(const RelativeDistinguishedName *data)
    1330             : {
    1331        1138 : size_t ret = 0;
    1332             : {
    1333        1138 : size_t Top_tag_oldret = ret;
    1334             : int i;
    1335        1138 : ret = 0;
    1336        2276 : for(i = (data)->len - 1; i >= 0; --i){
    1337        1138 : size_t Top_tag_for_oldret = ret;
    1338        1138 : ret = 0;
    1339        1138 : ret += length_AttributeTypeAndValue(&(data)->val[i]);
    1340        1138 : ret += Top_tag_for_oldret;
    1341             : }
    1342        1138 : ret += Top_tag_oldret;
    1343             : }
    1344        1138 : ret += 1 + der_length_len (ret);
    1345        1138 : return ret;
    1346             : }
    1347             : 
    1348             : int ASN1CALL
    1349        4996 : copy_RelativeDistinguishedName(const RelativeDistinguishedName *from, RelativeDistinguishedName *to)
    1350             : {
    1351        4996 : memset(to, 0, sizeof(*to));
    1352        4996 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    1353           0 : goto fail;
    1354        9992 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    1355        4996 : if(copy_AttributeTypeAndValue(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    1356             : }
    1357        4780 : return 0;
    1358           0 : fail:
    1359           0 : free_RelativeDistinguishedName(to);
    1360           0 : return ENOMEM;
    1361             : }
    1362             : 
    1363             : int ASN1CALL
    1364         172 : encode_RDNSequence(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RDNSequence *data, size_t *size)
    1365             : {
    1366         172 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1367             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1368             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1369             : 
    1370        1310 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    1371        1138 : size_t Top_tag_for_oldret = ret;
    1372        1138 : ret = 0;
    1373        1138 : e = encode_RelativeDistinguishedName(p, len, &(data)->val[i], &l);
    1374        1138 : if (e) return e;
    1375        1138 : p -= l; len -= l; ret += l;
    1376             : 
    1377        1138 : ret += Top_tag_for_oldret;
    1378             : }
    1379         172 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    1380         172 : if (e) return e;
    1381         172 : p -= l; len -= l; ret += l;
    1382             : 
    1383         172 : *size = ret;
    1384         172 : return 0;
    1385             : }
    1386             : 
    1387             : int ASN1CALL
    1388         530 : decode_RDNSequence(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RDNSequence *data, size_t *size)
    1389             : {
    1390         530 : size_t ret = 0;
    1391             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1392             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1393             : 
    1394         530 : memset(data, 0, sizeof(*data));
    1395             : {
    1396             : size_t Top_datalen, Top_oldlen;
    1397             : Der_type Top_type;
    1398         530 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    1399         530 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    1400         530 : if(e) goto fail;
    1401         530 : p += l; len -= l; ret += l;
    1402         530 : Top_oldlen = len;
    1403         530 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1404         530 : len = Top_datalen;
    1405             : {
    1406         530 : size_t Top_Tag_origlen = len;
    1407         530 : size_t Top_Tag_oldret = ret;
    1408         530 : size_t Top_Tag_olen = 0;
    1409             : void *Top_Tag_tmp;
    1410         530 : ret = 0;
    1411         530 : (data)->len = 0;
    1412         530 : (data)->val = NULL;
    1413        4616 : while(ret < Top_Tag_origlen) {
    1414        3556 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    1415        3556 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    1416        3556 : Top_Tag_olen = Top_Tag_nlen;
    1417        3556 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    1418        3556 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    1419        3556 : (data)->val = Top_Tag_tmp;
    1420        3556 : e = decode_RelativeDistinguishedName(p, len, &(data)->val[(data)->len], &l);
    1421        3556 : if(e) goto fail;
    1422        3556 : p += l; len -= l; ret += l;
    1423        3556 : (data)->len++;
    1424        3556 : len = Top_Tag_origlen - ret;
    1425             : }
    1426         530 : ret += Top_Tag_oldret;
    1427             : }
    1428         530 : len = Top_oldlen - Top_datalen;
    1429             : }
    1430        1060 : if(size) *size = ret;
    1431         498 : return 0;
    1432           0 : fail:
    1433           0 : free_RDNSequence(data);
    1434           0 : return e;
    1435             : }
    1436             : 
    1437             : void ASN1CALL
    1438        1044 : free_RDNSequence(RDNSequence *data)
    1439             : {
    1440        9052 : while((data)->len){
    1441        6964 : free_RelativeDistinguishedName(&(data)->val[(data)->len-1]);
    1442        6964 : (data)->len--;
    1443             : }
    1444        1044 : free((data)->val);
    1445        1044 : (data)->val = NULL;
    1446        1044 : }
    1447             : 
    1448             : size_t ASN1CALL
    1449         172 : length_RDNSequence(const RDNSequence *data)
    1450             : {
    1451         172 : size_t ret = 0;
    1452             : {
    1453         172 : size_t Top_tag_oldret = ret;
    1454             : int i;
    1455         172 : ret = 0;
    1456        1310 : for(i = (data)->len - 1; i >= 0; --i){
    1457        1138 : size_t Top_tag_for_oldret = ret;
    1458        1138 : ret = 0;
    1459        1138 : ret += length_RelativeDistinguishedName(&(data)->val[i]);
    1460        1138 : ret += Top_tag_for_oldret;
    1461             : }
    1462         172 : ret += Top_tag_oldret;
    1463             : }
    1464         172 : ret += 1 + der_length_len (ret);
    1465         172 : return ret;
    1466             : }
    1467             : 
    1468             : int ASN1CALL
    1469         750 : copy_RDNSequence(const RDNSequence *from, RDNSequence *to)
    1470             : {
    1471         750 : memset(to, 0, sizeof(*to));
    1472         750 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    1473           0 : goto fail;
    1474        5746 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    1475        4996 : if(copy_RelativeDistinguishedName(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    1476             : }
    1477         718 : return 0;
    1478           0 : fail:
    1479           0 : free_RDNSequence(to);
    1480           0 : return ENOMEM;
    1481             : }
    1482             : 
    1483             : int ASN1CALL
    1484         172 : encode_Name(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Name *data, size_t *size)
    1485             : {
    1486         172 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1487             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1488             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1489             : 
    1490             : 
    1491         172 : switch((data)->element) {
    1492         172 : case choice_Name_rdnSequence: {size_t Top_oldret = ret;
    1493         172 : ret = 0;
    1494         172 : e = encode_RDNSequence(p, len, &((data))->u.rdnSequence, &l);
    1495         172 : if (e) return e;
    1496         172 : p -= l; len -= l; ret += l;
    1497             : 
    1498         172 : ret += Top_oldret;
    1499         172 : break;
    1500             : }
    1501             : };
    1502         172 : *size = ret;
    1503         172 : return 0;
    1504             : }
    1505             : 
    1506             : int ASN1CALL
    1507         530 : decode_Name(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Name *data, size_t *size)
    1508             : {
    1509         530 : size_t ret = 0;
    1510             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1511             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1512         530 : const unsigned char *begin = p;
    1513             : 
    1514         530 : memset(data, 0, sizeof(*data));
    1515         530 : if (der_match_tag(p, len, ASN1_C_UNIV, CONS, UT_Sequence, NULL) == 0) {
    1516         530 : e = decode_RDNSequence(p, len, &(data)->u.rdnSequence, &l);
    1517         530 : if(e) goto fail;
    1518         530 : p += l; len -= l; ret += l;
    1519         530 : (data)->element = choice_Name_rdnSequence;
    1520             : }
    1521             : else {
    1522           0 : e = ASN1_PARSE_ERROR;
    1523           0 : goto fail;
    1524             : }
    1525         530 : data->_save.data = calloc(1, ret);
    1526         530 : if (data->_save.data == NULL) { 
    1527           0 : e = ENOMEM; goto fail; 
    1528             : }
    1529         530 : data->_save.length = ret;
    1530         562 : memcpy(data->_save.data, begin, ret);
    1531         530 : if(size) *size = ret;
    1532         498 : return 0;
    1533           0 : fail:
    1534           0 : free_Name(data);
    1535           0 : return e;
    1536             : }
    1537             : 
    1538             : void ASN1CALL
    1539        1104 : free_Name(Name *data)
    1540             : {
    1541        1104 : der_free_octet_string(&data->_save);
    1542        1104 : switch((data)->element) {
    1543        1044 : case choice_Name_rdnSequence:
    1544        1044 : free_RDNSequence(&(data)->u.rdnSequence);
    1545        1044 : break;
    1546             : }
    1547        1104 : }
    1548             : 
    1549             : size_t ASN1CALL
    1550         172 : length_Name(const Name *data)
    1551             : {
    1552         172 : size_t ret = 0;
    1553         172 : switch((data)->element) {
    1554         172 : case choice_Name_rdnSequence:
    1555             : {
    1556         172 : size_t Top_oldret = ret;
    1557         172 : ret = 0;
    1558         172 : ret += length_RDNSequence(&(data)->u.rdnSequence);
    1559         172 : ret += Top_oldret;
    1560             : }
    1561         172 : break;
    1562             : }
    1563         172 : return ret;
    1564             : }
    1565             : 
    1566             : int ASN1CALL
    1567         750 : copy_Name(const Name *from, Name *to)
    1568             : {
    1569         750 : memset(to, 0, sizeof(*to));
    1570             : { int ret;
    1571         750 : ret = der_copy_octet_string(&(from)->_save, &(to)->_save);
    1572         750 : if (ret) goto fail;
    1573             : }
    1574         750 : (to)->element = (from)->element;
    1575         750 : switch((from)->element) {
    1576         750 : case choice_Name_rdnSequence:
    1577         750 : if(copy_RDNSequence(&(from)->u.rdnSequence, &(to)->u.rdnSequence)) goto fail;
    1578         718 : break;
    1579             : }
    1580         718 : return 0;
    1581           0 : fail:
    1582           0 : free_Name(to);
    1583           0 : return ENOMEM;
    1584             : }
    1585             : 
    1586             : int ASN1CALL
    1587         106 : encode_CertificateSerialNumber(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CertificateSerialNumber *data, size_t *size)
    1588             : {
    1589         106 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1590             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1591             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1592             : 
    1593         106 : e = der_put_heim_integer(p, len, data, &l);
    1594         106 : if (e) return e;
    1595         106 : p -= l; len -= l; ret += l;
    1596             : 
    1597         106 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    1598         106 : if (e) return e;
    1599         106 : p -= l; len -= l; ret += l;
    1600             : 
    1601         106 : *size = ret;
    1602         106 : return 0;
    1603             : }
    1604             : 
    1605             : int ASN1CALL
    1606         282 : decode_CertificateSerialNumber(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CertificateSerialNumber *data, size_t *size)
    1607             : {
    1608         282 : size_t ret = 0;
    1609             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1610             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1611             : 
    1612         282 : memset(data, 0, sizeof(*data));
    1613             : {
    1614             : size_t Top_datalen, Top_oldlen;
    1615             : Der_type Top_type;
    1616         282 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
    1617         282 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    1618         282 : if(e) goto fail;
    1619         282 : p += l; len -= l; ret += l;
    1620         282 : Top_oldlen = len;
    1621         282 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1622         282 : len = Top_datalen;
    1623         282 : e = der_get_heim_integer(p, len, data, &l);
    1624         282 : if(e) goto fail;
    1625         282 : p += l; len -= l; ret += l;
    1626         282 : len = Top_oldlen - Top_datalen;
    1627             : }
    1628         564 : if(size) *size = ret;
    1629         266 : return 0;
    1630           0 : fail:
    1631           0 : free_CertificateSerialNumber(data);
    1632           0 : return e;
    1633             : }
    1634             : 
    1635             : void ASN1CALL
    1636         452 : free_CertificateSerialNumber(CertificateSerialNumber *data)
    1637             : {
    1638         452 : der_free_heim_integer(data);
    1639         452 : }
    1640             : 
    1641             : size_t ASN1CALL
    1642         106 : length_CertificateSerialNumber(const CertificateSerialNumber *data)
    1643             : {
    1644         106 : size_t ret = 0;
    1645         106 : ret += der_length_heim_integer(data);
    1646         106 : ret += 1 + der_length_len (ret);
    1647         106 : return ret;
    1648             : }
    1649             : 
    1650             : int ASN1CALL
    1651         248 : copy_CertificateSerialNumber(const CertificateSerialNumber *from, CertificateSerialNumber *to)
    1652             : {
    1653         248 : memset(to, 0, sizeof(*to));
    1654         248 : if(der_copy_heim_integer(from, to)) goto fail;
    1655         232 : return 0;
    1656           0 : fail:
    1657           0 : free_CertificateSerialNumber(to);
    1658           0 : return ENOMEM;
    1659             : }
    1660             : 
    1661             : int ASN1CALL
    1662         132 : encode_Time(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Time *data, size_t *size)
    1663             : {
    1664         132 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1665             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1666             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1667             : 
    1668             : 
    1669         132 : switch((data)->element) {
    1670           0 : case choice_Time_generalTime: {size_t Top_oldret = ret;
    1671           0 : ret = 0;
    1672           0 : e = der_put_generalized_time(p, len, &((data))->u.generalTime, &l);
    1673           0 : if (e) return e;
    1674           0 : p -= l; len -= l; ret += l;
    1675             : 
    1676           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralizedTime, &l);
    1677           0 : if (e) return e;
    1678           0 : p -= l; len -= l; ret += l;
    1679             : 
    1680           0 : ret += Top_oldret;
    1681           0 : break;
    1682             : }
    1683         132 : case choice_Time_utcTime: {size_t Top_oldret = ret;
    1684         132 : ret = 0;
    1685         132 : e = der_put_utctime(p, len, &((data))->u.utcTime, &l);
    1686         132 : if (e) return e;
    1687         132 : p -= l; len -= l; ret += l;
    1688             : 
    1689         132 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTCTime, &l);
    1690         132 : if (e) return e;
    1691         132 : p -= l; len -= l; ret += l;
    1692             : 
    1693         132 : ret += Top_oldret;
    1694         132 : break;
    1695             : }
    1696             : };
    1697         132 : *size = ret;
    1698         132 : return 0;
    1699             : }
    1700             : 
    1701             : int ASN1CALL
    1702         496 : decode_Time(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Time *data, size_t *size)
    1703             : {
    1704         496 : size_t ret = 0;
    1705             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1706             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1707             : 
    1708         496 : memset(data, 0, sizeof(*data));
    1709         496 : if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_UTCTime, NULL) == 0) {
    1710             : {
    1711             : size_t utcTime_datalen, utcTime_oldlen;
    1712             : Der_type utcTime_type;
    1713         496 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &utcTime_type, UT_UTCTime, &utcTime_datalen, &l);
    1714         496 : if (e == 0 && utcTime_type != PRIM) { e = ASN1_BAD_ID; }
    1715         496 : if(e) goto fail;
    1716         496 : p += l; len -= l; ret += l;
    1717         496 : utcTime_oldlen = len;
    1718         496 : if (utcTime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1719         496 : len = utcTime_datalen;
    1720         496 : e = der_get_utctime(p, len, &(data)->u.utcTime, &l);
    1721         496 : if(e) goto fail;
    1722         496 : p += l; len -= l; ret += l;
    1723         496 : len = utcTime_oldlen - utcTime_datalen;
    1724             : }
    1725         496 : (data)->element = choice_Time_utcTime;
    1726             : }
    1727           0 : else if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_GeneralizedTime, NULL) == 0) {
    1728             : {
    1729             : size_t generalTime_datalen, generalTime_oldlen;
    1730             : Der_type generalTime_type;
    1731           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &generalTime_type, UT_GeneralizedTime, &generalTime_datalen, &l);
    1732           0 : if (e == 0 && generalTime_type != PRIM) { e = ASN1_BAD_ID; }
    1733           0 : if(e) goto fail;
    1734           0 : p += l; len -= l; ret += l;
    1735           0 : generalTime_oldlen = len;
    1736           0 : if (generalTime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1737           0 : len = generalTime_datalen;
    1738           0 : e = der_get_generalized_time(p, len, &(data)->u.generalTime, &l);
    1739           0 : if(e) goto fail;
    1740           0 : p += l; len -= l; ret += l;
    1741           0 : len = generalTime_oldlen - generalTime_datalen;
    1742             : }
    1743           0 : (data)->element = choice_Time_generalTime;
    1744             : }
    1745             : else {
    1746           0 : e = ASN1_PARSE_ERROR;
    1747           0 : goto fail;
    1748             : }
    1749         496 : if(size) *size = ret;
    1750         464 : return 0;
    1751           0 : fail:
    1752           0 : free_Time(data);
    1753           0 : return e;
    1754             : }
    1755             : 
    1756             : void ASN1CALL
    1757         756 : free_Time(Time *data)
    1758             : {
    1759         724 : switch((data)->element) {
    1760         724 : case choice_Time_utcTime:
    1761         724 : break;
    1762           0 : case choice_Time_generalTime:
    1763           0 : break;
    1764             : }
    1765         756 : }
    1766             : 
    1767             : size_t ASN1CALL
    1768         132 : length_Time(const Time *data)
    1769             : {
    1770         132 : size_t ret = 0;
    1771         132 : switch((data)->element) {
    1772         132 : case choice_Time_utcTime:
    1773             : {
    1774         132 : size_t Top_oldret = ret;
    1775         132 : ret = 0;
    1776         132 : ret += der_length_utctime(&(data)->u.utcTime);
    1777         132 : ret += 1 + der_length_len (ret);
    1778         132 : ret += Top_oldret;
    1779             : }
    1780         132 : break;
    1781           0 : case choice_Time_generalTime:
    1782             : {
    1783           0 : size_t Top_oldret = ret;
    1784           0 : ret = 0;
    1785           0 : ret += der_length_generalized_time(&(data)->u.generalTime);
    1786           0 : ret += 1 + der_length_len (ret);
    1787           0 : ret += Top_oldret;
    1788             : }
    1789           0 : break;
    1790             : }
    1791         132 : return ret;
    1792             : }
    1793             : 
    1794             : int ASN1CALL
    1795         496 : copy_Time(const Time *from, Time *to)
    1796             : {
    1797         496 : memset(to, 0, sizeof(*to));
    1798         496 : (to)->element = (from)->element;
    1799         496 : switch((from)->element) {
    1800         496 : case choice_Time_utcTime:
    1801         496 : *(&(to)->u.utcTime) = *(&(from)->u.utcTime);
    1802         496 : break;
    1803           0 : case choice_Time_generalTime:
    1804           0 : *(&(to)->u.generalTime) = *(&(from)->u.generalTime);
    1805           0 : break;
    1806             : }
    1807         496 : return 0;
    1808             : }
    1809             : 
    1810             : int ASN1CALL
    1811          66 : encode_Validity(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Validity *data, size_t *size)
    1812             : {
    1813          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1814             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1815             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1816             : 
    1817             : /* notAfter */
    1818             : {
    1819          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    1820          66 : ret = 0;
    1821          66 : e = encode_Time(p, len, &(data)->notAfter, &l);
    1822          66 : if (e) return e;
    1823          66 : p -= l; len -= l; ret += l;
    1824             : 
    1825          66 : ret += Top_tag_oldret;
    1826             : }
    1827             : /* notBefore */
    1828             : {
    1829          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    1830          66 : ret = 0;
    1831          66 : e = encode_Time(p, len, &(data)->notBefore, &l);
    1832          66 : if (e) return e;
    1833          66 : p -= l; len -= l; ret += l;
    1834             : 
    1835          66 : ret += Top_tag_oldret;
    1836             : }
    1837          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    1838          66 : if (e) return e;
    1839          66 : p -= l; len -= l; ret += l;
    1840             : 
    1841          66 : *size = ret;
    1842          66 : return 0;
    1843             : }
    1844             : 
    1845             : int ASN1CALL
    1846         248 : decode_Validity(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Validity *data, size_t *size)
    1847             : {
    1848         248 : size_t ret = 0;
    1849             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1850             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1851             : 
    1852         248 : memset(data, 0, sizeof(*data));
    1853             : {
    1854             : size_t Top_datalen, Top_oldlen;
    1855             : Der_type Top_type;
    1856         248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    1857         248 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    1858         248 : if(e) goto fail;
    1859         248 : p += l; len -= l; ret += l;
    1860         248 : Top_oldlen = len;
    1861         248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1862         248 : len = Top_datalen;
    1863         248 : e = decode_Time(p, len, &(data)->notBefore, &l);
    1864         248 : if(e) goto fail;
    1865         248 : p += l; len -= l; ret += l;
    1866         248 : e = decode_Time(p, len, &(data)->notAfter, &l);
    1867         248 : if(e) goto fail;
    1868         248 : p += l; len -= l; ret += l;
    1869         248 : len = Top_oldlen - Top_datalen;
    1870             : }
    1871         496 : if(size) *size = ret;
    1872         232 : return 0;
    1873           0 : fail:
    1874           0 : free_Validity(data);
    1875           0 : return e;
    1876             : }
    1877             : 
    1878             : void ASN1CALL
    1879         378 : free_Validity(Validity *data)
    1880             : {
    1881         378 : free_Time(&(data)->notBefore);
    1882         378 : free_Time(&(data)->notAfter);
    1883         378 : }
    1884             : 
    1885             : size_t ASN1CALL
    1886          66 : length_Validity(const Validity *data)
    1887             : {
    1888          66 : size_t ret = 0;
    1889             : {
    1890          66 : size_t Top_tag_oldret = ret;
    1891          66 : ret = 0;
    1892          66 : ret += length_Time(&(data)->notBefore);
    1893          66 : ret += Top_tag_oldret;
    1894             : }
    1895             : {
    1896          66 : size_t Top_tag_oldret = ret;
    1897          66 : ret = 0;
    1898          66 : ret += length_Time(&(data)->notAfter);
    1899          66 : ret += Top_tag_oldret;
    1900             : }
    1901          66 : ret += 1 + der_length_len (ret);
    1902          66 : return ret;
    1903             : }
    1904             : 
    1905             : int ASN1CALL
    1906         248 : copy_Validity(const Validity *from, Validity *to)
    1907             : {
    1908         248 : memset(to, 0, sizeof(*to));
    1909         248 : if(copy_Time(&(from)->notBefore, &(to)->notBefore)) goto fail;
    1910         248 : if(copy_Time(&(from)->notAfter, &(to)->notAfter)) goto fail;
    1911         232 : return 0;
    1912           0 : fail:
    1913           0 : free_Validity(to);
    1914           0 : return ENOMEM;
    1915             : }
    1916             : 
    1917             : int ASN1CALL
    1918           0 : encode_UniqueIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const UniqueIdentifier *data, size_t *size)
    1919             : {
    1920           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1921             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1922             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1923             : 
    1924           0 : e = der_put_bit_string(p, len, data, &l);
    1925           0 : if (e) return e;
    1926           0 : p -= l; len -= l; ret += l;
    1927             : 
    1928           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
    1929           0 : if (e) return e;
    1930           0 : p -= l; len -= l; ret += l;
    1931             : 
    1932           0 : *size = ret;
    1933           0 : return 0;
    1934             : }
    1935             : 
    1936             : int ASN1CALL
    1937           0 : decode_UniqueIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, UniqueIdentifier *data, size_t *size)
    1938             : {
    1939           0 : size_t ret = 0;
    1940             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1941             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1942             : 
    1943           0 : memset(data, 0, sizeof(*data));
    1944             : {
    1945             : size_t Top_datalen, Top_oldlen;
    1946             : Der_type Top_type;
    1947           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
    1948           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    1949           0 : if(e) goto fail;
    1950           0 : p += l; len -= l; ret += l;
    1951           0 : Top_oldlen = len;
    1952           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1953           0 : len = Top_datalen;
    1954           0 : e = der_get_bit_string(p, len, data, &l);
    1955           0 : if(e) goto fail;
    1956           0 : p += l; len -= l; ret += l;
    1957           0 : len = Top_oldlen - Top_datalen;
    1958             : }
    1959           0 : if(size) *size = ret;
    1960           0 : return 0;
    1961           0 : fail:
    1962           0 : free_UniqueIdentifier(data);
    1963           0 : return e;
    1964             : }
    1965             : 
    1966             : void ASN1CALL
    1967           0 : free_UniqueIdentifier(UniqueIdentifier *data)
    1968             : {
    1969           0 : der_free_bit_string(data);
    1970           0 : }
    1971             : 
    1972             : size_t ASN1CALL
    1973           0 : length_UniqueIdentifier(const UniqueIdentifier *data)
    1974             : {
    1975           0 : size_t ret = 0;
    1976           0 : ret += der_length_bit_string(data);
    1977           0 : ret += 1 + der_length_len (ret);
    1978           0 : return ret;
    1979             : }
    1980             : 
    1981             : int ASN1CALL
    1982           0 : copy_UniqueIdentifier(const UniqueIdentifier *from, UniqueIdentifier *to)
    1983             : {
    1984           0 : memset(to, 0, sizeof(*to));
    1985           0 : if(der_copy_bit_string(from, to)) goto fail;
    1986           0 : return 0;
    1987           0 : fail:
    1988           0 : free_UniqueIdentifier(to);
    1989           0 : return ENOMEM;
    1990             : }
    1991             : 
    1992             : int ASN1CALL
    1993         106 : encode_SubjectPublicKeyInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SubjectPublicKeyInfo *data, size_t *size)
    1994             : {
    1995         106 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1996             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1997             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1998             : 
    1999             : /* subjectPublicKey */
    2000             : {
    2001         106 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2002         106 : ret = 0;
    2003         106 : e = der_put_bit_string(p, len, &(data)->subjectPublicKey, &l);
    2004         106 : if (e) return e;
    2005         106 : p -= l; len -= l; ret += l;
    2006             : 
    2007         106 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
    2008         106 : if (e) return e;
    2009         106 : p -= l; len -= l; ret += l;
    2010             : 
    2011         106 : ret += Top_tag_oldret;
    2012             : }
    2013             : /* algorithm */
    2014             : {
    2015         106 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2016         106 : ret = 0;
    2017         106 : e = encode_AlgorithmIdentifier(p, len, &(data)->algorithm, &l);
    2018         106 : if (e) return e;
    2019         106 : p -= l; len -= l; ret += l;
    2020             : 
    2021         106 : ret += Top_tag_oldret;
    2022             : }
    2023         106 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    2024         106 : if (e) return e;
    2025         106 : p -= l; len -= l; ret += l;
    2026             : 
    2027         106 : *size = ret;
    2028         106 : return 0;
    2029             : }
    2030             : 
    2031             : int ASN1CALL
    2032         282 : decode_SubjectPublicKeyInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SubjectPublicKeyInfo *data, size_t *size)
    2033             : {
    2034         282 : size_t ret = 0;
    2035             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2036             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    2037             : 
    2038         282 : memset(data, 0, sizeof(*data));
    2039             : {
    2040             : size_t Top_datalen, Top_oldlen;
    2041             : Der_type Top_type;
    2042         282 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    2043         282 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    2044         282 : if(e) goto fail;
    2045         282 : p += l; len -= l; ret += l;
    2046         282 : Top_oldlen = len;
    2047         282 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2048         282 : len = Top_datalen;
    2049         282 : e = decode_AlgorithmIdentifier(p, len, &(data)->algorithm, &l);
    2050         282 : if(e) goto fail;
    2051         282 : p += l; len -= l; ret += l;
    2052             : {
    2053             : size_t subjectPublicKey_datalen, subjectPublicKey_oldlen;
    2054             : Der_type subjectPublicKey_type;
    2055         282 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &subjectPublicKey_type, UT_BitString, &subjectPublicKey_datalen, &l);
    2056         282 : if (e == 0 && subjectPublicKey_type != PRIM) { e = ASN1_BAD_ID; }
    2057         282 : if(e) goto fail;
    2058         282 : p += l; len -= l; ret += l;
    2059         282 : subjectPublicKey_oldlen = len;
    2060         282 : if (subjectPublicKey_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2061         282 : len = subjectPublicKey_datalen;
    2062         282 : e = der_get_bit_string(p, len, &(data)->subjectPublicKey, &l);
    2063         282 : if(e) goto fail;
    2064         282 : p += l; len -= l; ret += l;
    2065         282 : len = subjectPublicKey_oldlen - subjectPublicKey_datalen;
    2066             : }
    2067         282 : len = Top_oldlen - Top_datalen;
    2068             : }
    2069         564 : if(size) *size = ret;
    2070         266 : return 0;
    2071           0 : fail:
    2072           0 : free_SubjectPublicKeyInfo(data);
    2073           0 : return e;
    2074             : }
    2075             : 
    2076             : void ASN1CALL
    2077         452 : free_SubjectPublicKeyInfo(SubjectPublicKeyInfo *data)
    2078             : {
    2079         452 : free_AlgorithmIdentifier(&(data)->algorithm);
    2080         452 : der_free_bit_string(&(data)->subjectPublicKey);
    2081         452 : }
    2082             : 
    2083             : size_t ASN1CALL
    2084         106 : length_SubjectPublicKeyInfo(const SubjectPublicKeyInfo *data)
    2085             : {
    2086         106 : size_t ret = 0;
    2087             : {
    2088         106 : size_t Top_tag_oldret = ret;
    2089         106 : ret = 0;
    2090         106 : ret += length_AlgorithmIdentifier(&(data)->algorithm);
    2091         106 : ret += Top_tag_oldret;
    2092             : }
    2093             : {
    2094         106 : size_t Top_tag_oldret = ret;
    2095         106 : ret = 0;
    2096         106 : ret += der_length_bit_string(&(data)->subjectPublicKey);
    2097         106 : ret += 1 + der_length_len (ret);
    2098         106 : ret += Top_tag_oldret;
    2099             : }
    2100         106 : ret += 1 + der_length_len (ret);
    2101         106 : return ret;
    2102             : }
    2103             : 
    2104             : int ASN1CALL
    2105         248 : copy_SubjectPublicKeyInfo(const SubjectPublicKeyInfo *from, SubjectPublicKeyInfo *to)
    2106             : {
    2107         248 : memset(to, 0, sizeof(*to));
    2108         248 : if(copy_AlgorithmIdentifier(&(from)->algorithm, &(to)->algorithm)) goto fail;
    2109         248 : if(der_copy_bit_string(&(from)->subjectPublicKey, &(to)->subjectPublicKey)) goto fail;
    2110         232 : return 0;
    2111           0 : fail:
    2112           0 : free_SubjectPublicKeyInfo(to);
    2113           0 : return ENOMEM;
    2114             : }
    2115             : 
    2116             : int ASN1CALL
    2117         726 : encode_Extension(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Extension *data, size_t *size)
    2118             : {
    2119         726 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    2120             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2121             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    2122             : 
    2123             : /* extnValue */
    2124             : {
    2125         726 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2126         726 : ret = 0;
    2127         726 : e = der_put_octet_string(p, len, &(data)->extnValue, &l);
    2128         726 : if (e) return e;
    2129         726 : p -= l; len -= l; ret += l;
    2130             : 
    2131         726 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
    2132         726 : if (e) return e;
    2133         726 : p -= l; len -= l; ret += l;
    2134             : 
    2135         726 : ret += Top_tag_oldret;
    2136             : }
    2137             : /* critical */
    2138         726 : if((data)->critical) {
    2139           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2140           0 : ret = 0;
    2141           0 : e = der_put_boolean(p, len, (data)->critical, &l);
    2142           0 : if (e) return e;
    2143           0 : p -= l; len -= l; ret += l;
    2144             : 
    2145           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
    2146           0 : if (e) return e;
    2147           0 : p -= l; len -= l; ret += l;
    2148             : 
    2149           0 : ret += Top_tag_oldret;
    2150             : }
    2151             : /* extnID */
    2152             : {
    2153         726 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2154         726 : ret = 0;
    2155         726 : e = der_put_oid(p, len, &(data)->extnID, &l);
    2156         726 : if (e) return e;
    2157         726 : p -= l; len -= l; ret += l;
    2158             : 
    2159         726 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
    2160         726 : if (e) return e;
    2161         726 : p -= l; len -= l; ret += l;
    2162             : 
    2163         726 : ret += Top_tag_oldret;
    2164             : }
    2165         726 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    2166         726 : if (e) return e;
    2167         726 : p -= l; len -= l; ret += l;
    2168             : 
    2169         726 : *size = ret;
    2170         726 : return 0;
    2171             : }
    2172             : 
    2173             : int ASN1CALL
    2174        2446 : decode_Extension(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Extension *data, size_t *size)
    2175             : {
    2176        2446 : size_t ret = 0;
    2177             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2178             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    2179             : 
    2180        2446 : memset(data, 0, sizeof(*data));
    2181             : {
    2182             : size_t Top_datalen, Top_oldlen;
    2183             : Der_type Top_type;
    2184        2446 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    2185        2446 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    2186        2446 : if(e) goto fail;
    2187        2446 : p += l; len -= l; ret += l;
    2188        2446 : Top_oldlen = len;
    2189        2446 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2190        2446 : len = Top_datalen;
    2191             : {
    2192             : size_t extnID_datalen, extnID_oldlen;
    2193             : Der_type extnID_type;
    2194        2446 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &extnID_type, UT_OID, &extnID_datalen, &l);
    2195        2446 : if (e == 0 && extnID_type != PRIM) { e = ASN1_BAD_ID; }
    2196        2446 : if(e) goto fail;
    2197        2446 : p += l; len -= l; ret += l;
    2198        2446 : extnID_oldlen = len;
    2199        2446 : if (extnID_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2200        2446 : len = extnID_datalen;
    2201        2446 : e = der_get_oid(p, len, &(data)->extnID, &l);
    2202        2446 : if(e) goto fail;
    2203        2446 : p += l; len -= l; ret += l;
    2204        2446 : len = extnID_oldlen - extnID_datalen;
    2205             : }
    2206             : {
    2207             : size_t critical_datalen, critical_oldlen;
    2208             : Der_type critical_type;
    2209        2446 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &critical_type, UT_Boolean, &critical_datalen, &l);
    2210        2446 : if (e == 0 && critical_type != PRIM) { e = ASN1_BAD_ID; }
    2211        2446 : if(e) {
    2212        2446 : (data)->critical = NULL;
    2213             : } else {
    2214           0 : (data)->critical = calloc(1, sizeof(*(data)->critical));
    2215           0 : if ((data)->critical == NULL) { e = ENOMEM; goto fail; }
    2216           0 : p += l; len -= l; ret += l;
    2217           0 : critical_oldlen = len;
    2218           0 : if (critical_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2219           0 : len = critical_datalen;
    2220           0 : e = der_get_boolean(p, len, (data)->critical, &l);
    2221           0 : if(e) goto fail;
    2222           0 : p += l; len -= l; ret += l;
    2223           0 : len = critical_oldlen - critical_datalen;
    2224             : }
    2225             : }
    2226             : {
    2227             : size_t extnValue_datalen, extnValue_oldlen;
    2228             : Der_type extnValue_type;
    2229        2446 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &extnValue_type, UT_OctetString, &extnValue_datalen, &l);
    2230        4892 : if (e == 0 && extnValue_type != PRIM) { e = ASN1_BAD_ID; }
    2231        2446 : if(e) goto fail;
    2232        2446 : p += l; len -= l; ret += l;
    2233        2446 : extnValue_oldlen = len;
    2234        2446 : if (extnValue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2235        2446 : len = extnValue_datalen;
    2236        2446 : e = der_get_octet_string(p, len, &(data)->extnValue, &l);
    2237        2446 : if(e) goto fail;
    2238        2446 : p += l; len -= l; ret += l;
    2239        2446 : len = extnValue_oldlen - extnValue_datalen;
    2240             : }
    2241        2446 : len = Top_oldlen - Top_datalen;
    2242             : }
    2243        4892 : if(size) *size = ret;
    2244        2294 : return 0;
    2245           0 : fail:
    2246           0 : free_Extension(data);
    2247           0 : return e;
    2248             : }
    2249             : 
    2250             : void ASN1CALL
    2251        3756 : free_Extension(Extension *data)
    2252             : {
    2253        3756 : der_free_oid(&(data)->extnID);
    2254        3756 : if((data)->critical) {
    2255           0 : free((data)->critical);
    2256           0 : (data)->critical = NULL;
    2257             : }
    2258        3756 : der_free_octet_string(&(data)->extnValue);
    2259        3756 : }
    2260             : 
    2261             : size_t ASN1CALL
    2262         726 : length_Extension(const Extension *data)
    2263             : {
    2264         726 : size_t ret = 0;
    2265             : {
    2266         726 : size_t Top_tag_oldret = ret;
    2267         726 : ret = 0;
    2268         726 : ret += der_length_oid(&(data)->extnID);
    2269         726 : ret += 1 + der_length_len (ret);
    2270         726 : ret += Top_tag_oldret;
    2271             : }
    2272         726 : if((data)->critical){
    2273           0 : size_t Top_tag_oldret = ret;
    2274           0 : ret = 0;
    2275           0 : ret += 1;
    2276           0 : ret += 1 + der_length_len (ret);
    2277           0 : ret += Top_tag_oldret;
    2278             : }
    2279             : {
    2280         726 : size_t Top_tag_oldret = ret;
    2281         726 : ret = 0;
    2282         726 : ret += der_length_octet_string(&(data)->extnValue);
    2283         726 : ret += 1 + der_length_len (ret);
    2284         726 : ret += Top_tag_oldret;
    2285             : }
    2286         726 : ret += 1 + der_length_len (ret);
    2287         726 : return ret;
    2288             : }
    2289             : 
    2290             : int ASN1CALL
    2291        2446 : copy_Extension(const Extension *from, Extension *to)
    2292             : {
    2293        2446 : memset(to, 0, sizeof(*to));
    2294        2446 : if(der_copy_oid(&(from)->extnID, &(to)->extnID)) goto fail;
    2295        2446 : if((from)->critical) {
    2296           0 : (to)->critical = malloc(sizeof(*(to)->critical));
    2297           0 : if((to)->critical == NULL) goto fail;
    2298           0 : *((to)->critical) = *((from)->critical);
    2299             : }else
    2300        2446 : (to)->critical = NULL;
    2301        2446 : if(der_copy_octet_string(&(from)->extnValue, &(to)->extnValue)) goto fail;
    2302        2294 : return 0;
    2303           0 : fail:
    2304           0 : free_Extension(to);
    2305           0 : return ENOMEM;
    2306             : }
    2307             : 
    2308             : int ASN1CALL
    2309          66 : encode_Extensions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Extensions *data, size_t *size)
    2310             : {
    2311          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    2312             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2313             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    2314             : 
    2315         792 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    2316         726 : size_t Top_tag_for_oldret = ret;
    2317         726 : ret = 0;
    2318         726 : e = encode_Extension(p, len, &(data)->val[i], &l);
    2319         726 : if (e) return e;
    2320         726 : p -= l; len -= l; ret += l;
    2321             : 
    2322         726 : ret += Top_tag_for_oldret;
    2323             : }
    2324          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    2325          66 : if (e) return e;
    2326          66 : p -= l; len -= l; ret += l;
    2327             : 
    2328          66 : *size = ret;
    2329          66 : return 0;
    2330             : }
    2331             : 
    2332             : int ASN1CALL
    2333         248 : decode_Extensions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Extensions *data, size_t *size)
    2334             : {
    2335         248 : size_t ret = 0;
    2336             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2337             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    2338             : 
    2339         248 : memset(data, 0, sizeof(*data));
    2340             : {
    2341             : size_t Top_datalen, Top_oldlen;
    2342             : Der_type Top_type;
    2343         248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    2344         248 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    2345         248 : if(e) goto fail;
    2346         248 : p += l; len -= l; ret += l;
    2347         248 : Top_oldlen = len;
    2348         248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2349         248 : len = Top_datalen;
    2350             : {
    2351         248 : size_t Top_Tag_origlen = len;
    2352         248 : size_t Top_Tag_oldret = ret;
    2353         248 : size_t Top_Tag_olen = 0;
    2354             : void *Top_Tag_tmp;
    2355         248 : ret = 0;
    2356         248 : (data)->len = 0;
    2357         248 : (data)->val = NULL;
    2358        2942 : while(ret < Top_Tag_origlen) {
    2359        2446 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    2360        2446 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    2361        2446 : Top_Tag_olen = Top_Tag_nlen;
    2362        2446 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    2363        2446 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    2364        2446 : (data)->val = Top_Tag_tmp;
    2365        2446 : e = decode_Extension(p, len, &(data)->val[(data)->len], &l);
    2366        2446 : if(e) goto fail;
    2367        2446 : p += l; len -= l; ret += l;
    2368        2446 : (data)->len++;
    2369        2446 : len = Top_Tag_origlen - ret;
    2370             : }
    2371         248 : ret += Top_Tag_oldret;
    2372             : }
    2373         248 : if ((data)->len < 1) {
    2374           0 : e = ASN1_MIN_CONSTRAINT; goto fail;
    2375             : }
    2376         248 : len = Top_oldlen - Top_datalen;
    2377             : }
    2378         496 : if(size) *size = ret;
    2379         232 : return 0;
    2380           0 : fail:
    2381           0 : free_Extensions(data);
    2382           0 : return e;
    2383             : }
    2384             : 
    2385             : void ASN1CALL
    2386         378 : free_Extensions(Extensions *data)
    2387             : {
    2388        4512 : while((data)->len){
    2389        3756 : free_Extension(&(data)->val[(data)->len-1]);
    2390        3756 : (data)->len--;
    2391             : }
    2392         378 : free((data)->val);
    2393         378 : (data)->val = NULL;
    2394         378 : }
    2395             : 
    2396             : size_t ASN1CALL
    2397          66 : length_Extensions(const Extensions *data)
    2398             : {
    2399          66 : size_t ret = 0;
    2400             : {
    2401          66 : size_t Top_tag_oldret = ret;
    2402             : int i;
    2403          66 : ret = 0;
    2404         792 : for(i = (data)->len - 1; i >= 0; --i){
    2405         726 : size_t Top_tag_for_oldret = ret;
    2406         726 : ret = 0;
    2407         726 : ret += length_Extension(&(data)->val[i]);
    2408         726 : ret += Top_tag_for_oldret;
    2409             : }
    2410          66 : ret += Top_tag_oldret;
    2411             : }
    2412          66 : ret += 1 + der_length_len (ret);
    2413          66 : return ret;
    2414             : }
    2415             : 
    2416             : int ASN1CALL
    2417         248 : copy_Extensions(const Extensions *from, Extensions *to)
    2418             : {
    2419         248 : memset(to, 0, sizeof(*to));
    2420         248 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    2421           0 : goto fail;
    2422        2694 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    2423        2446 : if(copy_Extension(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    2424             : }
    2425         232 : return 0;
    2426           0 : fail:
    2427           0 : free_Extensions(to);
    2428           0 : return ENOMEM;
    2429             : }
    2430             : 
    2431             : int ASN1CALL
    2432           0 : add_Extensions(Extensions *data, const Extension *element)
    2433             : {
    2434             : int ret;
    2435             : void *ptr;
    2436             : 
    2437           0 : ptr = realloc(data->val, 
    2438           0 :         (data->len + 1) * sizeof(data->val[0]));
    2439           0 : if (ptr == NULL) return ENOMEM;
    2440           0 : data->val = ptr;
    2441             : 
    2442           0 : ret = copy_Extension(element, &data->val[data->len]);
    2443           0 : if (ret) return ret;
    2444           0 : data->len++;
    2445           0 : return 0;
    2446             : }
    2447             : 
    2448             : int ASN1CALL
    2449           0 : remove_Extensions(Extensions *data, unsigned int element)
    2450             : {
    2451             : void *ptr;
    2452             : 
    2453           0 : if (data->len == 0 || element >= data->len)
    2454           0 :         return ASN1_OVERRUN;
    2455           0 : free_Extension(&data->val[element]);
    2456           0 : data->len--;
    2457           0 : if (element < data->len)
    2458           0 :         memmove(&data->val[element], &data->val[element + 1], 
    2459           0 :                 sizeof(data->val[0]) * data->len);
    2460           0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
    2461           0 : if (ptr != NULL || data->len == 0) data->val = ptr;
    2462           0 : return 0;
    2463             : }
    2464             : 
    2465             : int ASN1CALL
    2466          66 : encode_TBSCertificate(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TBSCertificate *data, size_t *size)
    2467             : {
    2468          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    2469             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2470             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    2471             : 
    2472             : /* extensions */
    2473          66 : if((data)->extensions) {
    2474          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2475          66 : ret = 0;
    2476          66 : e = encode_Extensions(p, len, (data)->extensions, &l);
    2477          66 : if (e) return e;
    2478          66 : p -= l; len -= l; ret += l;
    2479             : 
    2480          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
    2481          66 : if (e) return e;
    2482          66 : p -= l; len -= l; ret += l;
    2483             : 
    2484          66 : ret += Top_tag_oldret;
    2485             : }
    2486             : /* subjectUniqueID */
    2487          66 : if((data)->subjectUniqueID) {
    2488           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2489           0 : ret = 0;
    2490           0 : e = der_put_bit_string(p, len, (data)->subjectUniqueID, &l);
    2491           0 : if (e) return e;
    2492           0 : p -= l; len -= l; ret += l;
    2493             : 
    2494           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 2, &l);
    2495           0 : if (e) return e;
    2496           0 : p -= l; len -= l; ret += l;
    2497             : 
    2498           0 : ret += Top_tag_oldret;
    2499             : }
    2500             : /* issuerUniqueID */
    2501          66 : if((data)->issuerUniqueID) {
    2502           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2503           0 : ret = 0;
    2504           0 : e = der_put_bit_string(p, len, (data)->issuerUniqueID, &l);
    2505           0 : if (e) return e;
    2506           0 : p -= l; len -= l; ret += l;
    2507             : 
    2508           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 1, &l);
    2509           0 : if (e) return e;
    2510           0 : p -= l; len -= l; ret += l;
    2511             : 
    2512           0 : ret += Top_tag_oldret;
    2513             : }
    2514             : /* subjectPublicKeyInfo */
    2515             : {
    2516          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2517          66 : ret = 0;
    2518          66 : e = encode_SubjectPublicKeyInfo(p, len, &(data)->subjectPublicKeyInfo, &l);
    2519          66 : if (e) return e;
    2520          66 : p -= l; len -= l; ret += l;
    2521             : 
    2522          66 : ret += Top_tag_oldret;
    2523             : }
    2524             : /* subject */
    2525             : {
    2526          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2527          66 : ret = 0;
    2528          66 : e = encode_Name(p, len, &(data)->subject, &l);
    2529          66 : if (e) return e;
    2530          66 : p -= l; len -= l; ret += l;
    2531             : 
    2532          66 : ret += Top_tag_oldret;
    2533             : }
    2534             : /* validity */
    2535             : {
    2536          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2537          66 : ret = 0;
    2538          66 : e = encode_Validity(p, len, &(data)->validity, &l);
    2539          66 : if (e) return e;
    2540          66 : p -= l; len -= l; ret += l;
    2541             : 
    2542          66 : ret += Top_tag_oldret;
    2543             : }
    2544             : /* issuer */
    2545             : {
    2546          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2547          66 : ret = 0;
    2548          66 : e = encode_Name(p, len, &(data)->issuer, &l);
    2549          66 : if (e) return e;
    2550          66 : p -= l; len -= l; ret += l;
    2551             : 
    2552          66 : ret += Top_tag_oldret;
    2553             : }
    2554             : /* signature */
    2555             : {
    2556          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2557          66 : ret = 0;
    2558          66 : e = encode_AlgorithmIdentifier(p, len, &(data)->signature, &l);
    2559          66 : if (e) return e;
    2560          66 : p -= l; len -= l; ret += l;
    2561             : 
    2562          66 : ret += Top_tag_oldret;
    2563             : }
    2564             : /* serialNumber */
    2565             : {
    2566          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2567          66 : ret = 0;
    2568          66 : e = encode_CertificateSerialNumber(p, len, &(data)->serialNumber, &l);
    2569          66 : if (e) return e;
    2570          66 : p -= l; len -= l; ret += l;
    2571             : 
    2572          66 : ret += Top_tag_oldret;
    2573             : }
    2574             : /* version */
    2575          66 : if((data)->version) {
    2576          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2577          66 : ret = 0;
    2578          66 : e = encode_Version(p, len, (data)->version, &l);
    2579          66 : if (e) return e;
    2580          66 : p -= l; len -= l; ret += l;
    2581             : 
    2582          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    2583          66 : if (e) return e;
    2584          66 : p -= l; len -= l; ret += l;
    2585             : 
    2586          66 : ret += Top_tag_oldret;
    2587             : }
    2588          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    2589          66 : if (e) return e;
    2590          66 : p -= l; len -= l; ret += l;
    2591             : 
    2592          66 : *size = ret;
    2593          66 : return 0;
    2594             : }
    2595             : 
    2596             : int ASN1CALL
    2597         248 : decode_TBSCertificate(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TBSCertificate *data, size_t *size)
    2598             : {
    2599         248 : size_t ret = 0;
    2600             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2601             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    2602         248 : const unsigned char *begin = p;
    2603             : 
    2604         248 : memset(data, 0, sizeof(*data));
    2605             : {
    2606             : size_t Top_datalen, Top_oldlen;
    2607             : Der_type Top_type;
    2608         248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    2609         248 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    2610         248 : if(e) goto fail;
    2611         248 : p += l; len -= l; ret += l;
    2612         248 : Top_oldlen = len;
    2613         248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2614         248 : len = Top_datalen;
    2615             : {
    2616             : size_t version_datalen, version_oldlen;
    2617             : Der_type version_type;
    2618         248 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &version_type, 0, &version_datalen, &l);
    2619         248 : if (e == 0 && version_type != CONS) { e = ASN1_BAD_ID; }
    2620         248 : if(e) {
    2621           0 : (data)->version = NULL;
    2622             : } else {
    2623         248 : (data)->version = calloc(1, sizeof(*(data)->version));
    2624         248 : if ((data)->version == NULL) { e = ENOMEM; goto fail; }
    2625         248 : p += l; len -= l; ret += l;
    2626         248 : version_oldlen = len;
    2627         248 : if (version_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2628         248 : len = version_datalen;
    2629         248 : e = decode_Version(p, len, (data)->version, &l);
    2630         248 : if(e) goto fail;
    2631         248 : p += l; len -= l; ret += l;
    2632         248 : len = version_oldlen - version_datalen;
    2633             : }
    2634             : }
    2635         248 : e = decode_CertificateSerialNumber(p, len, &(data)->serialNumber, &l);
    2636         248 : if(e) goto fail;
    2637         248 : p += l; len -= l; ret += l;
    2638         248 : e = decode_AlgorithmIdentifier(p, len, &(data)->signature, &l);
    2639         248 : if(e) goto fail;
    2640         248 : p += l; len -= l; ret += l;
    2641         248 : e = decode_Name(p, len, &(data)->issuer, &l);
    2642         248 : if(e) goto fail;
    2643         248 : p += l; len -= l; ret += l;
    2644         248 : e = decode_Validity(p, len, &(data)->validity, &l);
    2645         248 : if(e) goto fail;
    2646         248 : p += l; len -= l; ret += l;
    2647         248 : e = decode_Name(p, len, &(data)->subject, &l);
    2648         248 : if(e) goto fail;
    2649         248 : p += l; len -= l; ret += l;
    2650         248 : e = decode_SubjectPublicKeyInfo(p, len, &(data)->subjectPublicKeyInfo, &l);
    2651         248 : if(e) goto fail;
    2652         248 : p += l; len -= l; ret += l;
    2653             : {
    2654             : size_t issuerUniqueID_datalen, issuerUniqueID_oldlen;
    2655             : Der_type issuerUniqueID_type;
    2656         248 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &issuerUniqueID_type, 1, &issuerUniqueID_datalen, &l);
    2657         248 : if (e == 0 && issuerUniqueID_type != PRIM) { e = ASN1_BAD_ID; }
    2658         248 : if(e) {
    2659         248 : (data)->issuerUniqueID = NULL;
    2660             : } else {
    2661           0 : (data)->issuerUniqueID = calloc(1, sizeof(*(data)->issuerUniqueID));
    2662           0 : if ((data)->issuerUniqueID == NULL) { e = ENOMEM; goto fail; }
    2663           0 : p += l; len -= l; ret += l;
    2664           0 : issuerUniqueID_oldlen = len;
    2665           0 : if (issuerUniqueID_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2666           0 : len = issuerUniqueID_datalen;
    2667           0 : e = der_get_bit_string(p, len, (data)->issuerUniqueID, &l);
    2668           0 : if(e) goto fail;
    2669           0 : p += l; len -= l; ret += l;
    2670           0 : len = issuerUniqueID_oldlen - issuerUniqueID_datalen;
    2671             : }
    2672             : }
    2673             : {
    2674             : size_t subjectUniqueID_datalen, subjectUniqueID_oldlen;
    2675             : Der_type subjectUniqueID_type;
    2676         248 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &subjectUniqueID_type, 2, &subjectUniqueID_datalen, &l);
    2677         248 : if (e == 0 && subjectUniqueID_type != PRIM) { e = ASN1_BAD_ID; }
    2678         248 : if(e) {
    2679         248 : (data)->subjectUniqueID = NULL;
    2680             : } else {
    2681           0 : (data)->subjectUniqueID = calloc(1, sizeof(*(data)->subjectUniqueID));
    2682           0 : if ((data)->subjectUniqueID == NULL) { e = ENOMEM; goto fail; }
    2683           0 : p += l; len -= l; ret += l;
    2684           0 : subjectUniqueID_oldlen = len;
    2685           0 : if (subjectUniqueID_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2686           0 : len = subjectUniqueID_datalen;
    2687           0 : e = der_get_bit_string(p, len, (data)->subjectUniqueID, &l);
    2688           0 : if(e) goto fail;
    2689           0 : p += l; len -= l; ret += l;
    2690           0 : len = subjectUniqueID_oldlen - subjectUniqueID_datalen;
    2691             : }
    2692             : }
    2693             : {
    2694             : size_t extensions_datalen, extensions_oldlen;
    2695             : Der_type extensions_type;
    2696         248 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &extensions_type, 3, &extensions_datalen, &l);
    2697         496 : if (e == 0 && extensions_type != CONS) { e = ASN1_BAD_ID; }
    2698         248 : if(e) {
    2699           0 : (data)->extensions = NULL;
    2700             : } else {
    2701         248 : (data)->extensions = calloc(1, sizeof(*(data)->extensions));
    2702         248 : if ((data)->extensions == NULL) { e = ENOMEM; goto fail; }
    2703         248 : p += l; len -= l; ret += l;
    2704         248 : extensions_oldlen = len;
    2705         248 : if (extensions_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2706         248 : len = extensions_datalen;
    2707         248 : e = decode_Extensions(p, len, (data)->extensions, &l);
    2708         248 : if(e) goto fail;
    2709         248 : p += l; len -= l; ret += l;
    2710         248 : len = extensions_oldlen - extensions_datalen;
    2711             : }
    2712             : }
    2713         248 : len = Top_oldlen - Top_datalen;
    2714             : }
    2715         248 : data->_save.data = calloc(1, ret);
    2716         248 : if (data->_save.data == NULL) { 
    2717           0 : e = ENOMEM; goto fail; 
    2718             : }
    2719         248 : data->_save.length = ret;
    2720         264 : memcpy(data->_save.data, begin, ret);
    2721         248 : if(size) *size = ret;
    2722         232 : return 0;
    2723           0 : fail:
    2724           0 : free_TBSCertificate(data);
    2725           0 : return e;
    2726             : }
    2727             : 
    2728             : void ASN1CALL
    2729         378 : free_TBSCertificate(TBSCertificate *data)
    2730             : {
    2731         378 : der_free_octet_string(&data->_save);
    2732         378 : if((data)->version) {
    2733         378 : free_Version((data)->version);
    2734         378 : free((data)->version);
    2735         378 : (data)->version = NULL;
    2736             : }
    2737         378 : free_CertificateSerialNumber(&(data)->serialNumber);
    2738         378 : free_AlgorithmIdentifier(&(data)->signature);
    2739         378 : free_Name(&(data)->issuer);
    2740         378 : free_Validity(&(data)->validity);
    2741         378 : free_Name(&(data)->subject);
    2742         378 : free_SubjectPublicKeyInfo(&(data)->subjectPublicKeyInfo);
    2743         378 : if((data)->issuerUniqueID) {
    2744           0 : der_free_bit_string((data)->issuerUniqueID);
    2745           0 : free((data)->issuerUniqueID);
    2746           0 : (data)->issuerUniqueID = NULL;
    2747             : }
    2748         378 : if((data)->subjectUniqueID) {
    2749           0 : der_free_bit_string((data)->subjectUniqueID);
    2750           0 : free((data)->subjectUniqueID);
    2751           0 : (data)->subjectUniqueID = NULL;
    2752             : }
    2753         378 : if((data)->extensions) {
    2754         378 : free_Extensions((data)->extensions);
    2755         378 : free((data)->extensions);
    2756         378 : (data)->extensions = NULL;
    2757             : }
    2758         378 : }
    2759             : 
    2760             : size_t ASN1CALL
    2761          66 : length_TBSCertificate(const TBSCertificate *data)
    2762             : {
    2763          66 : size_t ret = 0;
    2764          66 : if((data)->version){
    2765          66 : size_t Top_tag_oldret = ret;
    2766          66 : ret = 0;
    2767          66 : ret += length_Version((data)->version);
    2768          66 : ret += 1 + der_length_len (ret);
    2769          66 : ret += Top_tag_oldret;
    2770             : }
    2771             : {
    2772          66 : size_t Top_tag_oldret = ret;
    2773          66 : ret = 0;
    2774          66 : ret += length_CertificateSerialNumber(&(data)->serialNumber);
    2775          66 : ret += Top_tag_oldret;
    2776             : }
    2777             : {
    2778          66 : size_t Top_tag_oldret = ret;
    2779          66 : ret = 0;
    2780          66 : ret += length_AlgorithmIdentifier(&(data)->signature);
    2781          66 : ret += Top_tag_oldret;
    2782             : }
    2783             : {
    2784          66 : size_t Top_tag_oldret = ret;
    2785          66 : ret = 0;
    2786          66 : ret += length_Name(&(data)->issuer);
    2787          66 : ret += Top_tag_oldret;
    2788             : }
    2789             : {
    2790          66 : size_t Top_tag_oldret = ret;
    2791          66 : ret = 0;
    2792          66 : ret += length_Validity(&(data)->validity);
    2793          66 : ret += Top_tag_oldret;
    2794             : }
    2795             : {
    2796          66 : size_t Top_tag_oldret = ret;
    2797          66 : ret = 0;
    2798          66 : ret += length_Name(&(data)->subject);
    2799          66 : ret += Top_tag_oldret;
    2800             : }
    2801             : {
    2802          66 : size_t Top_tag_oldret = ret;
    2803          66 : ret = 0;
    2804          66 : ret += length_SubjectPublicKeyInfo(&(data)->subjectPublicKeyInfo);
    2805          66 : ret += Top_tag_oldret;
    2806             : }
    2807          66 : if((data)->issuerUniqueID){
    2808           0 : size_t Top_tag_oldret = ret;
    2809           0 : ret = 0;
    2810           0 : ret += der_length_bit_string((data)->issuerUniqueID);
    2811           0 : ret += 1 + der_length_len (ret);
    2812           0 : ret += Top_tag_oldret;
    2813             : }
    2814          66 : if((data)->subjectUniqueID){
    2815           0 : size_t Top_tag_oldret = ret;
    2816           0 : ret = 0;
    2817           0 : ret += der_length_bit_string((data)->subjectUniqueID);
    2818           0 : ret += 1 + der_length_len (ret);
    2819           0 : ret += Top_tag_oldret;
    2820             : }
    2821          66 : if((data)->extensions){
    2822          66 : size_t Top_tag_oldret = ret;
    2823          66 : ret = 0;
    2824          66 : ret += length_Extensions((data)->extensions);
    2825          66 : ret += 1 + der_length_len (ret);
    2826          66 : ret += Top_tag_oldret;
    2827             : }
    2828          66 : ret += 1 + der_length_len (ret);
    2829          66 : return ret;
    2830             : }
    2831             : 
    2832             : int ASN1CALL
    2833         248 : copy_TBSCertificate(const TBSCertificate *from, TBSCertificate *to)
    2834             : {
    2835         248 : memset(to, 0, sizeof(*to));
    2836             : { int ret;
    2837         248 : ret = der_copy_octet_string(&(from)->_save, &(to)->_save);
    2838         248 : if (ret) goto fail;
    2839             : }
    2840         248 : if((from)->version) {
    2841         248 : (to)->version = malloc(sizeof(*(to)->version));
    2842         248 : if((to)->version == NULL) goto fail;
    2843         248 : if(copy_Version((from)->version, (to)->version)) goto fail;
    2844             : }else
    2845           0 : (to)->version = NULL;
    2846         248 : if(copy_CertificateSerialNumber(&(from)->serialNumber, &(to)->serialNumber)) goto fail;
    2847         248 : if(copy_AlgorithmIdentifier(&(from)->signature, &(to)->signature)) goto fail;
    2848         248 : if(copy_Name(&(from)->issuer, &(to)->issuer)) goto fail;
    2849         248 : if(copy_Validity(&(from)->validity, &(to)->validity)) goto fail;
    2850         248 : if(copy_Name(&(from)->subject, &(to)->subject)) goto fail;
    2851         248 : if(copy_SubjectPublicKeyInfo(&(from)->subjectPublicKeyInfo, &(to)->subjectPublicKeyInfo)) goto fail;
    2852         248 : if((from)->issuerUniqueID) {
    2853           0 : (to)->issuerUniqueID = malloc(sizeof(*(to)->issuerUniqueID));
    2854           0 : if((to)->issuerUniqueID == NULL) goto fail;
    2855           0 : if(der_copy_bit_string((from)->issuerUniqueID, (to)->issuerUniqueID)) goto fail;
    2856             : }else
    2857         248 : (to)->issuerUniqueID = NULL;
    2858         248 : if((from)->subjectUniqueID) {
    2859           0 : (to)->subjectUniqueID = malloc(sizeof(*(to)->subjectUniqueID));
    2860           0 : if((to)->subjectUniqueID == NULL) goto fail;
    2861           0 : if(der_copy_bit_string((from)->subjectUniqueID, (to)->subjectUniqueID)) goto fail;
    2862             : }else
    2863         248 : (to)->subjectUniqueID = NULL;
    2864         248 : if((from)->extensions) {
    2865         248 : (to)->extensions = malloc(sizeof(*(to)->extensions));
    2866         248 : if((to)->extensions == NULL) goto fail;
    2867         248 : if(copy_Extensions((from)->extensions, (to)->extensions)) goto fail;
    2868             : }else
    2869           0 : (to)->extensions = NULL;
    2870         232 : return 0;
    2871           0 : fail:
    2872           0 : free_TBSCertificate(to);
    2873           0 : return ENOMEM;
    2874             : }
    2875             : 
    2876             : int ASN1CALL
    2877          66 : encode_Certificate(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Certificate *data, size_t *size)
    2878             : {
    2879          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    2880             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2881             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    2882             : 
    2883             : /* signatureValue */
    2884             : {
    2885          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2886          66 : ret = 0;
    2887          66 : e = der_put_bit_string(p, len, &(data)->signatureValue, &l);
    2888          66 : if (e) return e;
    2889          66 : p -= l; len -= l; ret += l;
    2890             : 
    2891          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
    2892          66 : if (e) return e;
    2893          66 : p -= l; len -= l; ret += l;
    2894             : 
    2895          66 : ret += Top_tag_oldret;
    2896             : }
    2897             : /* signatureAlgorithm */
    2898             : {
    2899          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2900          66 : ret = 0;
    2901          66 : e = encode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
    2902          66 : if (e) return e;
    2903          66 : p -= l; len -= l; ret += l;
    2904             : 
    2905          66 : ret += Top_tag_oldret;
    2906             : }
    2907             : /* tbsCertificate */
    2908             : {
    2909          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    2910          66 : ret = 0;
    2911          66 : e = encode_TBSCertificate(p, len, &(data)->tbsCertificate, &l);
    2912          66 : if (e) return e;
    2913          66 : p -= l; len -= l; ret += l;
    2914             : 
    2915          66 : ret += Top_tag_oldret;
    2916             : }
    2917          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    2918          66 : if (e) return e;
    2919          66 : p -= l; len -= l; ret += l;
    2920             : 
    2921          66 : *size = ret;
    2922          66 : return 0;
    2923             : }
    2924             : 
    2925             : int ASN1CALL
    2926         248 : decode_Certificate(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Certificate *data, size_t *size)
    2927             : {
    2928         248 : size_t ret = 0;
    2929             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    2930             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    2931             : 
    2932         248 : memset(data, 0, sizeof(*data));
    2933             : {
    2934             : size_t Top_datalen, Top_oldlen;
    2935             : Der_type Top_type;
    2936         248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    2937         248 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    2938         248 : if(e) goto fail;
    2939         248 : p += l; len -= l; ret += l;
    2940         248 : Top_oldlen = len;
    2941         248 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2942         248 : len = Top_datalen;
    2943         248 : e = decode_TBSCertificate(p, len, &(data)->tbsCertificate, &l);
    2944         248 : if(e) goto fail;
    2945         248 : p += l; len -= l; ret += l;
    2946         248 : e = decode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
    2947         248 : if(e) goto fail;
    2948         248 : p += l; len -= l; ret += l;
    2949             : {
    2950             : size_t signatureValue_datalen, signatureValue_oldlen;
    2951             : Der_type signatureValue_type;
    2952         248 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &signatureValue_type, UT_BitString, &signatureValue_datalen, &l);
    2953         248 : if (e == 0 && signatureValue_type != PRIM) { e = ASN1_BAD_ID; }
    2954         248 : if(e) goto fail;
    2955         248 : p += l; len -= l; ret += l;
    2956         248 : signatureValue_oldlen = len;
    2957         248 : if (signatureValue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    2958         248 : len = signatureValue_datalen;
    2959         248 : e = der_get_bit_string(p, len, &(data)->signatureValue, &l);
    2960         248 : if(e) goto fail;
    2961         248 : p += l; len -= l; ret += l;
    2962         248 : len = signatureValue_oldlen - signatureValue_datalen;
    2963             : }
    2964         248 : len = Top_oldlen - Top_datalen;
    2965             : }
    2966         496 : if(size) *size = ret;
    2967         232 : return 0;
    2968           0 : fail:
    2969           0 : free_Certificate(data);
    2970           0 : return e;
    2971             : }
    2972             : 
    2973             : void ASN1CALL
    2974         378 : free_Certificate(Certificate *data)
    2975             : {
    2976         378 : free_TBSCertificate(&(data)->tbsCertificate);
    2977         378 : free_AlgorithmIdentifier(&(data)->signatureAlgorithm);
    2978         378 : der_free_bit_string(&(data)->signatureValue);
    2979         378 : }
    2980             : 
    2981             : size_t ASN1CALL
    2982          66 : length_Certificate(const Certificate *data)
    2983             : {
    2984          66 : size_t ret = 0;
    2985             : {
    2986          66 : size_t Top_tag_oldret = ret;
    2987          66 : ret = 0;
    2988          66 : ret += length_TBSCertificate(&(data)->tbsCertificate);
    2989          66 : ret += Top_tag_oldret;
    2990             : }
    2991             : {
    2992          66 : size_t Top_tag_oldret = ret;
    2993          66 : ret = 0;
    2994          66 : ret += length_AlgorithmIdentifier(&(data)->signatureAlgorithm);
    2995          66 : ret += Top_tag_oldret;
    2996             : }
    2997             : {
    2998          66 : size_t Top_tag_oldret = ret;
    2999          66 : ret = 0;
    3000          66 : ret += der_length_bit_string(&(data)->signatureValue);
    3001          66 : ret += 1 + der_length_len (ret);
    3002          66 : ret += Top_tag_oldret;
    3003             : }
    3004          66 : ret += 1 + der_length_len (ret);
    3005          66 : return ret;
    3006             : }
    3007             : 
    3008             : int ASN1CALL
    3009         248 : copy_Certificate(const Certificate *from, Certificate *to)
    3010             : {
    3011         248 : memset(to, 0, sizeof(*to));
    3012         248 : if(copy_TBSCertificate(&(from)->tbsCertificate, &(to)->tbsCertificate)) goto fail;
    3013         248 : if(copy_AlgorithmIdentifier(&(from)->signatureAlgorithm, &(to)->signatureAlgorithm)) goto fail;
    3014         248 : if(der_copy_bit_string(&(from)->signatureValue, &(to)->signatureValue)) goto fail;
    3015         232 : return 0;
    3016           0 : fail:
    3017           0 : free_Certificate(to);
    3018           0 : return ENOMEM;
    3019             : }
    3020             : 
    3021             : int ASN1CALL
    3022           0 : encode_Certificates(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Certificates *data, size_t *size)
    3023             : {
    3024           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    3025             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3026             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    3027             : 
    3028           0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    3029           0 : size_t Top_tag_for_oldret = ret;
    3030           0 : ret = 0;
    3031           0 : e = encode_Certificate(p, len, &(data)->val[i], &l);
    3032           0 : if (e) return e;
    3033           0 : p -= l; len -= l; ret += l;
    3034             : 
    3035           0 : ret += Top_tag_for_oldret;
    3036             : }
    3037           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    3038           0 : if (e) return e;
    3039           0 : p -= l; len -= l; ret += l;
    3040             : 
    3041           0 : *size = ret;
    3042           0 : return 0;
    3043             : }
    3044             : 
    3045             : int ASN1CALL
    3046           0 : decode_Certificates(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, Certificates *data, size_t *size)
    3047             : {
    3048           0 : size_t ret = 0;
    3049             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3050             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    3051             : 
    3052           0 : memset(data, 0, sizeof(*data));
    3053             : {
    3054             : size_t Top_datalen, Top_oldlen;
    3055             : Der_type Top_type;
    3056           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    3057           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    3058           0 : if(e) goto fail;
    3059           0 : p += l; len -= l; ret += l;
    3060           0 : Top_oldlen = len;
    3061           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3062           0 : len = Top_datalen;
    3063             : {
    3064           0 : size_t Top_Tag_origlen = len;
    3065           0 : size_t Top_Tag_oldret = ret;
    3066           0 : size_t Top_Tag_olen = 0;
    3067             : void *Top_Tag_tmp;
    3068           0 : ret = 0;
    3069           0 : (data)->len = 0;
    3070           0 : (data)->val = NULL;
    3071           0 : while(ret < Top_Tag_origlen) {
    3072           0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    3073           0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    3074           0 : Top_Tag_olen = Top_Tag_nlen;
    3075           0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    3076           0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    3077           0 : (data)->val = Top_Tag_tmp;
    3078           0 : e = decode_Certificate(p, len, &(data)->val[(data)->len], &l);
    3079           0 : if(e) goto fail;
    3080           0 : p += l; len -= l; ret += l;
    3081           0 : (data)->len++;
    3082           0 : len = Top_Tag_origlen - ret;
    3083             : }
    3084           0 : ret += Top_Tag_oldret;
    3085             : }
    3086           0 : len = Top_oldlen - Top_datalen;
    3087             : }
    3088           0 : if(size) *size = ret;
    3089           0 : return 0;
    3090           0 : fail:
    3091           0 : free_Certificates(data);
    3092           0 : return e;
    3093             : }
    3094             : 
    3095             : void ASN1CALL
    3096           0 : free_Certificates(Certificates *data)
    3097             : {
    3098           0 : while((data)->len){
    3099           0 : free_Certificate(&(data)->val[(data)->len-1]);
    3100           0 : (data)->len--;
    3101             : }
    3102           0 : free((data)->val);
    3103           0 : (data)->val = NULL;
    3104           0 : }
    3105             : 
    3106             : size_t ASN1CALL
    3107           0 : length_Certificates(const Certificates *data)
    3108             : {
    3109           0 : size_t ret = 0;
    3110             : {
    3111           0 : size_t Top_tag_oldret = ret;
    3112             : int i;
    3113           0 : ret = 0;
    3114           0 : for(i = (data)->len - 1; i >= 0; --i){
    3115           0 : size_t Top_tag_for_oldret = ret;
    3116           0 : ret = 0;
    3117           0 : ret += length_Certificate(&(data)->val[i]);
    3118           0 : ret += Top_tag_for_oldret;
    3119             : }
    3120           0 : ret += Top_tag_oldret;
    3121             : }
    3122           0 : ret += 1 + der_length_len (ret);
    3123           0 : return ret;
    3124             : }
    3125             : 
    3126             : int ASN1CALL
    3127           0 : copy_Certificates(const Certificates *from, Certificates *to)
    3128             : {
    3129           0 : memset(to, 0, sizeof(*to));
    3130           0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    3131           0 : goto fail;
    3132           0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    3133           0 : if(copy_Certificate(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    3134             : }
    3135           0 : return 0;
    3136           0 : fail:
    3137           0 : free_Certificates(to);
    3138           0 : return ENOMEM;
    3139             : }
    3140             : 
    3141             : int ASN1CALL
    3142           0 : encode_ValidationParms(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ValidationParms *data, size_t *size)
    3143             : {
    3144           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    3145             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3146             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    3147             : 
    3148             : /* pgenCounter */
    3149             : {
    3150           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3151           0 : ret = 0;
    3152           0 : e = der_put_heim_integer(p, len, &(data)->pgenCounter, &l);
    3153           0 : if (e) return e;
    3154           0 : p -= l; len -= l; ret += l;
    3155             : 
    3156           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3157           0 : if (e) return e;
    3158           0 : p -= l; len -= l; ret += l;
    3159             : 
    3160           0 : ret += Top_tag_oldret;
    3161             : }
    3162             : /* seed */
    3163             : {
    3164           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3165           0 : ret = 0;
    3166           0 : e = der_put_bit_string(p, len, &(data)->seed, &l);
    3167           0 : if (e) return e;
    3168           0 : p -= l; len -= l; ret += l;
    3169             : 
    3170           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
    3171           0 : if (e) return e;
    3172           0 : p -= l; len -= l; ret += l;
    3173             : 
    3174           0 : ret += Top_tag_oldret;
    3175             : }
    3176           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    3177           0 : if (e) return e;
    3178           0 : p -= l; len -= l; ret += l;
    3179             : 
    3180           0 : *size = ret;
    3181           0 : return 0;
    3182             : }
    3183             : 
    3184             : int ASN1CALL
    3185          34 : decode_ValidationParms(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ValidationParms *data, size_t *size)
    3186             : {
    3187          34 : size_t ret = 0;
    3188             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3189             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    3190             : 
    3191          34 : memset(data, 0, sizeof(*data));
    3192             : {
    3193             : size_t Top_datalen, Top_oldlen;
    3194             : Der_type Top_type;
    3195          34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    3196          34 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    3197          68 : if(e) goto fail;
    3198           0 : p += l; len -= l; ret += l;
    3199           0 : Top_oldlen = len;
    3200           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3201           0 : len = Top_datalen;
    3202             : {
    3203             : size_t seed_datalen, seed_oldlen;
    3204             : Der_type seed_type;
    3205           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &seed_type, UT_BitString, &seed_datalen, &l);
    3206           0 : if (e == 0 && seed_type != PRIM) { e = ASN1_BAD_ID; }
    3207           0 : if(e) goto fail;
    3208           0 : p += l; len -= l; ret += l;
    3209           0 : seed_oldlen = len;
    3210           0 : if (seed_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3211           0 : len = seed_datalen;
    3212           0 : e = der_get_bit_string(p, len, &(data)->seed, &l);
    3213           0 : if(e) goto fail;
    3214           0 : p += l; len -= l; ret += l;
    3215           0 : len = seed_oldlen - seed_datalen;
    3216             : }
    3217             : {
    3218             : size_t pgenCounter_datalen, pgenCounter_oldlen;
    3219             : Der_type pgenCounter_type;
    3220           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &pgenCounter_type, UT_Integer, &pgenCounter_datalen, &l);
    3221           0 : if (e == 0 && pgenCounter_type != PRIM) { e = ASN1_BAD_ID; }
    3222           0 : if(e) goto fail;
    3223           0 : p += l; len -= l; ret += l;
    3224           0 : pgenCounter_oldlen = len;
    3225           0 : if (pgenCounter_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3226           0 : len = pgenCounter_datalen;
    3227           0 : e = der_get_heim_integer(p, len, &(data)->pgenCounter, &l);
    3228           0 : if(e) goto fail;
    3229           0 : p += l; len -= l; ret += l;
    3230           0 : len = pgenCounter_oldlen - pgenCounter_datalen;
    3231             : }
    3232           0 : len = Top_oldlen - Top_datalen;
    3233             : }
    3234           0 : if(size) *size = ret;
    3235           0 : return 0;
    3236          34 : fail:
    3237          34 : free_ValidationParms(data);
    3238          34 : return e;
    3239             : }
    3240             : 
    3241             : void ASN1CALL
    3242          34 : free_ValidationParms(ValidationParms *data)
    3243             : {
    3244          34 : der_free_bit_string(&(data)->seed);
    3245          34 : der_free_heim_integer(&(data)->pgenCounter);
    3246          34 : }
    3247             : 
    3248             : size_t ASN1CALL
    3249           0 : length_ValidationParms(const ValidationParms *data)
    3250             : {
    3251           0 : size_t ret = 0;
    3252             : {
    3253           0 : size_t Top_tag_oldret = ret;
    3254           0 : ret = 0;
    3255           0 : ret += der_length_bit_string(&(data)->seed);
    3256           0 : ret += 1 + der_length_len (ret);
    3257           0 : ret += Top_tag_oldret;
    3258             : }
    3259             : {
    3260           0 : size_t Top_tag_oldret = ret;
    3261           0 : ret = 0;
    3262           0 : ret += der_length_heim_integer(&(data)->pgenCounter);
    3263           0 : ret += 1 + der_length_len (ret);
    3264           0 : ret += Top_tag_oldret;
    3265             : }
    3266           0 : ret += 1 + der_length_len (ret);
    3267           0 : return ret;
    3268             : }
    3269             : 
    3270             : int ASN1CALL
    3271           0 : copy_ValidationParms(const ValidationParms *from, ValidationParms *to)
    3272             : {
    3273           0 : memset(to, 0, sizeof(*to));
    3274           0 : if(der_copy_bit_string(&(from)->seed, &(to)->seed)) goto fail;
    3275           0 : if(der_copy_heim_integer(&(from)->pgenCounter, &(to)->pgenCounter)) goto fail;
    3276           0 : return 0;
    3277           0 : fail:
    3278           0 : free_ValidationParms(to);
    3279           0 : return ENOMEM;
    3280             : }
    3281             : 
    3282             : int ASN1CALL
    3283          40 : encode_DomainParameters(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DomainParameters *data, size_t *size)
    3284             : {
    3285          40 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    3286             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3287             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    3288             : 
    3289             : /* validationParms */
    3290          40 : if((data)->validationParms) {
    3291           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3292           0 : ret = 0;
    3293           0 : e = encode_ValidationParms(p, len, (data)->validationParms, &l);
    3294           0 : if (e) return e;
    3295           0 : p -= l; len -= l; ret += l;
    3296             : 
    3297           0 : ret += Top_tag_oldret;
    3298             : }
    3299             : /* j */
    3300          40 : if((data)->j) {
    3301           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3302           0 : ret = 0;
    3303           0 : e = der_put_heim_integer(p, len, (data)->j, &l);
    3304           0 : if (e) return e;
    3305           0 : p -= l; len -= l; ret += l;
    3306             : 
    3307           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3308           0 : if (e) return e;
    3309           0 : p -= l; len -= l; ret += l;
    3310             : 
    3311           0 : ret += Top_tag_oldret;
    3312             : }
    3313             : /* q */
    3314          40 : if((data)->q) {
    3315          40 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3316          40 : ret = 0;
    3317          40 : e = der_put_heim_integer(p, len, (data)->q, &l);
    3318          40 : if (e) return e;
    3319          40 : p -= l; len -= l; ret += l;
    3320             : 
    3321          40 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3322          40 : if (e) return e;
    3323          40 : p -= l; len -= l; ret += l;
    3324             : 
    3325          40 : ret += Top_tag_oldret;
    3326             : }
    3327             : /* g */
    3328             : {
    3329          40 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3330          40 : ret = 0;
    3331          40 : e = der_put_heim_integer(p, len, &(data)->g, &l);
    3332          40 : if (e) return e;
    3333          40 : p -= l; len -= l; ret += l;
    3334             : 
    3335          40 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3336          40 : if (e) return e;
    3337          40 : p -= l; len -= l; ret += l;
    3338             : 
    3339          40 : ret += Top_tag_oldret;
    3340             : }
    3341             : /* p */
    3342             : {
    3343          40 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3344          40 : ret = 0;
    3345          40 : e = der_put_heim_integer(p, len, &(data)->p, &l);
    3346          40 : if (e) return e;
    3347          40 : p -= l; len -= l; ret += l;
    3348             : 
    3349          40 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3350          40 : if (e) return e;
    3351          40 : p -= l; len -= l; ret += l;
    3352             : 
    3353          40 : ret += Top_tag_oldret;
    3354             : }
    3355          40 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    3356          40 : if (e) return e;
    3357          40 : p -= l; len -= l; ret += l;
    3358             : 
    3359          40 : *size = ret;
    3360          40 : return 0;
    3361             : }
    3362             : 
    3363             : int ASN1CALL
    3364          34 : decode_DomainParameters(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DomainParameters *data, size_t *size)
    3365             : {
    3366          34 : size_t ret = 0;
    3367             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3368             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    3369             : 
    3370          34 : memset(data, 0, sizeof(*data));
    3371             : {
    3372             : size_t Top_datalen, Top_oldlen;
    3373             : Der_type Top_type;
    3374          34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    3375          34 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    3376          34 : if(e) goto fail;
    3377          34 : p += l; len -= l; ret += l;
    3378          34 : Top_oldlen = len;
    3379          34 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3380          34 : len = Top_datalen;
    3381             : {
    3382             : size_t p_datalen, p_oldlen;
    3383             : Der_type p_type;
    3384          34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &p_type, UT_Integer, &p_datalen, &l);
    3385          34 : if (e == 0 && p_type != PRIM) { e = ASN1_BAD_ID; }
    3386          34 : if(e) goto fail;
    3387          34 : p += l; len -= l; ret += l;
    3388          34 : p_oldlen = len;
    3389          34 : if (p_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3390          34 : len = p_datalen;
    3391          34 : e = der_get_heim_integer(p, len, &(data)->p, &l);
    3392          34 : if(e) goto fail;
    3393          34 : p += l; len -= l; ret += l;
    3394          34 : len = p_oldlen - p_datalen;
    3395             : }
    3396             : {
    3397             : size_t g_datalen, g_oldlen;
    3398             : Der_type g_type;
    3399          34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &g_type, UT_Integer, &g_datalen, &l);
    3400          68 : if (e == 0 && g_type != PRIM) { e = ASN1_BAD_ID; }
    3401          34 : if(e) goto fail;
    3402          34 : p += l; len -= l; ret += l;
    3403          34 : g_oldlen = len;
    3404          34 : if (g_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3405          34 : len = g_datalen;
    3406          34 : e = der_get_heim_integer(p, len, &(data)->g, &l);
    3407          34 : if(e) goto fail;
    3408          34 : p += l; len -= l; ret += l;
    3409          34 : len = g_oldlen - g_datalen;
    3410             : }
    3411             : {
    3412             : size_t q_datalen, q_oldlen;
    3413             : Der_type q_type;
    3414          34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &q_type, UT_Integer, &q_datalen, &l);
    3415          68 : if (e == 0 && q_type != PRIM) { e = ASN1_BAD_ID; }
    3416          34 : if(e) {
    3417           0 : (data)->q = NULL;
    3418             : } else {
    3419          34 : (data)->q = calloc(1, sizeof(*(data)->q));
    3420          34 : if ((data)->q == NULL) { e = ENOMEM; goto fail; }
    3421          34 : p += l; len -= l; ret += l;
    3422          34 : q_oldlen = len;
    3423          34 : if (q_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3424          34 : len = q_datalen;
    3425          34 : e = der_get_heim_integer(p, len, (data)->q, &l);
    3426          34 : if(e) goto fail;
    3427          34 : p += l; len -= l; ret += l;
    3428          34 : len = q_oldlen - q_datalen;
    3429             : }
    3430             : }
    3431             : {
    3432             : size_t j_datalen, j_oldlen;
    3433             : Der_type j_type;
    3434          34 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &j_type, UT_Integer, &j_datalen, &l);
    3435          34 : if (e == 0 && j_type != PRIM) { e = ASN1_BAD_ID; }
    3436          34 : if(e) {
    3437          34 : (data)->j = NULL;
    3438             : } else {
    3439           0 : (data)->j = calloc(1, sizeof(*(data)->j));
    3440           0 : if ((data)->j == NULL) { e = ENOMEM; goto fail; }
    3441           0 : p += l; len -= l; ret += l;
    3442           0 : j_oldlen = len;
    3443           0 : if (j_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3444           0 : len = j_datalen;
    3445           0 : e = der_get_heim_integer(p, len, (data)->j, &l);
    3446           0 : if(e) goto fail;
    3447           0 : p += l; len -= l; ret += l;
    3448           0 : len = j_oldlen - j_datalen;
    3449             : }
    3450             : }
    3451          34 : (data)->validationParms = calloc(1, sizeof(*(data)->validationParms));
    3452          34 : if ((data)->validationParms == NULL) goto fail;
    3453          34 : e = decode_ValidationParms(p, len, (data)->validationParms, &l);
    3454          34 : if(e) {
    3455          34 : free((data)->validationParms);
    3456          34 : (data)->validationParms = NULL;
    3457             : } else {
    3458           0 : p += l; len -= l; ret += l;
    3459             : }
    3460          34 : len = Top_oldlen - Top_datalen;
    3461             : }
    3462          34 : if(size) *size = ret;
    3463          34 : return 0;
    3464           0 : fail:
    3465           0 : free_DomainParameters(data);
    3466           0 : return e;
    3467             : }
    3468             : 
    3469             : void ASN1CALL
    3470          74 : free_DomainParameters(DomainParameters *data)
    3471             : {
    3472          74 : der_free_heim_integer(&(data)->p);
    3473          74 : der_free_heim_integer(&(data)->g);
    3474          74 : if((data)->q) {
    3475          74 : der_free_heim_integer((data)->q);
    3476          74 : free((data)->q);
    3477          74 : (data)->q = NULL;
    3478             : }
    3479          74 : if((data)->j) {
    3480           0 : der_free_heim_integer((data)->j);
    3481           0 : free((data)->j);
    3482           0 : (data)->j = NULL;
    3483             : }
    3484          74 : if((data)->validationParms) {
    3485           0 : free_ValidationParms((data)->validationParms);
    3486           0 : free((data)->validationParms);
    3487           0 : (data)->validationParms = NULL;
    3488             : }
    3489          74 : }
    3490             : 
    3491             : size_t ASN1CALL
    3492          40 : length_DomainParameters(const DomainParameters *data)
    3493             : {
    3494          40 : size_t ret = 0;
    3495             : {
    3496          40 : size_t Top_tag_oldret = ret;
    3497          40 : ret = 0;
    3498          40 : ret += der_length_heim_integer(&(data)->p);
    3499          40 : ret += 1 + der_length_len (ret);
    3500          40 : ret += Top_tag_oldret;
    3501             : }
    3502             : {
    3503          40 : size_t Top_tag_oldret = ret;
    3504          40 : ret = 0;
    3505          40 : ret += der_length_heim_integer(&(data)->g);
    3506          40 : ret += 1 + der_length_len (ret);
    3507          40 : ret += Top_tag_oldret;
    3508             : }
    3509          40 : if((data)->q){
    3510          40 : size_t Top_tag_oldret = ret;
    3511          40 : ret = 0;
    3512          40 : ret += der_length_heim_integer((data)->q);
    3513          40 : ret += 1 + der_length_len (ret);
    3514          40 : ret += Top_tag_oldret;
    3515             : }
    3516          40 : if((data)->j){
    3517           0 : size_t Top_tag_oldret = ret;
    3518           0 : ret = 0;
    3519           0 : ret += der_length_heim_integer((data)->j);
    3520           0 : ret += 1 + der_length_len (ret);
    3521           0 : ret += Top_tag_oldret;
    3522             : }
    3523          40 : if((data)->validationParms){
    3524           0 : size_t Top_tag_oldret = ret;
    3525           0 : ret = 0;
    3526           0 : ret += length_ValidationParms((data)->validationParms);
    3527           0 : ret += Top_tag_oldret;
    3528             : }
    3529          40 : ret += 1 + der_length_len (ret);
    3530          40 : return ret;
    3531             : }
    3532             : 
    3533             : int ASN1CALL
    3534           0 : copy_DomainParameters(const DomainParameters *from, DomainParameters *to)
    3535             : {
    3536           0 : memset(to, 0, sizeof(*to));
    3537           0 : if(der_copy_heim_integer(&(from)->p, &(to)->p)) goto fail;
    3538           0 : if(der_copy_heim_integer(&(from)->g, &(to)->g)) goto fail;
    3539           0 : if((from)->q) {
    3540           0 : (to)->q = malloc(sizeof(*(to)->q));
    3541           0 : if((to)->q == NULL) goto fail;
    3542           0 : if(der_copy_heim_integer((from)->q, (to)->q)) goto fail;
    3543             : }else
    3544           0 : (to)->q = NULL;
    3545           0 : if((from)->j) {
    3546           0 : (to)->j = malloc(sizeof(*(to)->j));
    3547           0 : if((to)->j == NULL) goto fail;
    3548           0 : if(der_copy_heim_integer((from)->j, (to)->j)) goto fail;
    3549             : }else
    3550           0 : (to)->j = NULL;
    3551           0 : if((from)->validationParms) {
    3552           0 : (to)->validationParms = malloc(sizeof(*(to)->validationParms));
    3553           0 : if((to)->validationParms == NULL) goto fail;
    3554           0 : if(copy_ValidationParms((from)->validationParms, (to)->validationParms)) goto fail;
    3555             : }else
    3556           0 : (to)->validationParms = NULL;
    3557           0 : return 0;
    3558           0 : fail:
    3559           0 : free_DomainParameters(to);
    3560           0 : return ENOMEM;
    3561             : }
    3562             : 
    3563             : int ASN1CALL
    3564           0 : encode_DHParameter(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DHParameter *data, size_t *size)
    3565             : {
    3566           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    3567             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3568             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    3569             : 
    3570             : /* privateValueLength */
    3571           0 : if((data)->privateValueLength) {
    3572           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3573           0 : ret = 0;
    3574           0 : e = der_put_heim_integer(p, len, (data)->privateValueLength, &l);
    3575           0 : if (e) return e;
    3576           0 : p -= l; len -= l; ret += l;
    3577             : 
    3578           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3579           0 : if (e) return e;
    3580           0 : p -= l; len -= l; ret += l;
    3581             : 
    3582           0 : ret += Top_tag_oldret;
    3583             : }
    3584             : /* base */
    3585             : {
    3586           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3587           0 : ret = 0;
    3588           0 : e = der_put_heim_integer(p, len, &(data)->base, &l);
    3589           0 : if (e) return e;
    3590           0 : p -= l; len -= l; ret += l;
    3591             : 
    3592           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3593           0 : if (e) return e;
    3594           0 : p -= l; len -= l; ret += l;
    3595             : 
    3596           0 : ret += Top_tag_oldret;
    3597             : }
    3598             : /* prime */
    3599             : {
    3600           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3601           0 : ret = 0;
    3602           0 : e = der_put_heim_integer(p, len, &(data)->prime, &l);
    3603           0 : if (e) return e;
    3604           0 : p -= l; len -= l; ret += l;
    3605             : 
    3606           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3607           0 : if (e) return e;
    3608           0 : p -= l; len -= l; ret += l;
    3609             : 
    3610           0 : ret += Top_tag_oldret;
    3611             : }
    3612           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    3613           0 : if (e) return e;
    3614           0 : p -= l; len -= l; ret += l;
    3615             : 
    3616           0 : *size = ret;
    3617           0 : return 0;
    3618             : }
    3619             : 
    3620             : int ASN1CALL
    3621           0 : decode_DHParameter(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DHParameter *data, size_t *size)
    3622             : {
    3623           0 : size_t ret = 0;
    3624             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3625             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    3626             : 
    3627           0 : memset(data, 0, sizeof(*data));
    3628             : {
    3629             : size_t Top_datalen, Top_oldlen;
    3630             : Der_type Top_type;
    3631           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    3632           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    3633           0 : if(e) goto fail;
    3634           0 : p += l; len -= l; ret += l;
    3635           0 : Top_oldlen = len;
    3636           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3637           0 : len = Top_datalen;
    3638             : {
    3639             : size_t prime_datalen, prime_oldlen;
    3640             : Der_type prime_type;
    3641           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &prime_type, UT_Integer, &prime_datalen, &l);
    3642           0 : if (e == 0 && prime_type != PRIM) { e = ASN1_BAD_ID; }
    3643           0 : if(e) goto fail;
    3644           0 : p += l; len -= l; ret += l;
    3645           0 : prime_oldlen = len;
    3646           0 : if (prime_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3647           0 : len = prime_datalen;
    3648           0 : e = der_get_heim_integer(p, len, &(data)->prime, &l);
    3649           0 : if(e) goto fail;
    3650           0 : p += l; len -= l; ret += l;
    3651           0 : len = prime_oldlen - prime_datalen;
    3652             : }
    3653             : {
    3654             : size_t base_datalen, base_oldlen;
    3655             : Der_type base_type;
    3656           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &base_type, UT_Integer, &base_datalen, &l);
    3657           0 : if (e == 0 && base_type != PRIM) { e = ASN1_BAD_ID; }
    3658           0 : if(e) goto fail;
    3659           0 : p += l; len -= l; ret += l;
    3660           0 : base_oldlen = len;
    3661           0 : if (base_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3662           0 : len = base_datalen;
    3663           0 : e = der_get_heim_integer(p, len, &(data)->base, &l);
    3664           0 : if(e) goto fail;
    3665           0 : p += l; len -= l; ret += l;
    3666           0 : len = base_oldlen - base_datalen;
    3667             : }
    3668             : {
    3669             : size_t privateValueLength_datalen, privateValueLength_oldlen;
    3670             : Der_type privateValueLength_type;
    3671           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &privateValueLength_type, UT_Integer, &privateValueLength_datalen, &l);
    3672           0 : if (e == 0 && privateValueLength_type != PRIM) { e = ASN1_BAD_ID; }
    3673           0 : if(e) {
    3674           0 : (data)->privateValueLength = NULL;
    3675             : } else {
    3676           0 : (data)->privateValueLength = calloc(1, sizeof(*(data)->privateValueLength));
    3677           0 : if ((data)->privateValueLength == NULL) { e = ENOMEM; goto fail; }
    3678           0 : p += l; len -= l; ret += l;
    3679           0 : privateValueLength_oldlen = len;
    3680           0 : if (privateValueLength_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3681           0 : len = privateValueLength_datalen;
    3682           0 : e = der_get_heim_integer(p, len, (data)->privateValueLength, &l);
    3683           0 : if(e) goto fail;
    3684           0 : p += l; len -= l; ret += l;
    3685           0 : len = privateValueLength_oldlen - privateValueLength_datalen;
    3686             : }
    3687             : }
    3688           0 : len = Top_oldlen - Top_datalen;
    3689             : }
    3690           0 : if(size) *size = ret;
    3691           0 : return 0;
    3692           0 : fail:
    3693           0 : free_DHParameter(data);
    3694           0 : return e;
    3695             : }
    3696             : 
    3697             : void ASN1CALL
    3698           0 : free_DHParameter(DHParameter *data)
    3699             : {
    3700           0 : der_free_heim_integer(&(data)->prime);
    3701           0 : der_free_heim_integer(&(data)->base);
    3702           0 : if((data)->privateValueLength) {
    3703           0 : der_free_heim_integer((data)->privateValueLength);
    3704           0 : free((data)->privateValueLength);
    3705           0 : (data)->privateValueLength = NULL;
    3706             : }
    3707           0 : }
    3708             : 
    3709             : size_t ASN1CALL
    3710           0 : length_DHParameter(const DHParameter *data)
    3711             : {
    3712           0 : size_t ret = 0;
    3713             : {
    3714           0 : size_t Top_tag_oldret = ret;
    3715           0 : ret = 0;
    3716           0 : ret += der_length_heim_integer(&(data)->prime);
    3717           0 : ret += 1 + der_length_len (ret);
    3718           0 : ret += Top_tag_oldret;
    3719             : }
    3720             : {
    3721           0 : size_t Top_tag_oldret = ret;
    3722           0 : ret = 0;
    3723           0 : ret += der_length_heim_integer(&(data)->base);
    3724           0 : ret += 1 + der_length_len (ret);
    3725           0 : ret += Top_tag_oldret;
    3726             : }
    3727           0 : if((data)->privateValueLength){
    3728           0 : size_t Top_tag_oldret = ret;
    3729           0 : ret = 0;
    3730           0 : ret += der_length_heim_integer((data)->privateValueLength);
    3731           0 : ret += 1 + der_length_len (ret);
    3732           0 : ret += Top_tag_oldret;
    3733             : }
    3734           0 : ret += 1 + der_length_len (ret);
    3735           0 : return ret;
    3736             : }
    3737             : 
    3738             : int ASN1CALL
    3739           0 : copy_DHParameter(const DHParameter *from, DHParameter *to)
    3740             : {
    3741           0 : memset(to, 0, sizeof(*to));
    3742           0 : if(der_copy_heim_integer(&(from)->prime, &(to)->prime)) goto fail;
    3743           0 : if(der_copy_heim_integer(&(from)->base, &(to)->base)) goto fail;
    3744           0 : if((from)->privateValueLength) {
    3745           0 : (to)->privateValueLength = malloc(sizeof(*(to)->privateValueLength));
    3746           0 : if((to)->privateValueLength == NULL) goto fail;
    3747           0 : if(der_copy_heim_integer((from)->privateValueLength, (to)->privateValueLength)) goto fail;
    3748             : }else
    3749           0 : (to)->privateValueLength = NULL;
    3750           0 : return 0;
    3751           0 : fail:
    3752           0 : free_DHParameter(to);
    3753           0 : return ENOMEM;
    3754             : }
    3755             : 
    3756             : int ASN1CALL
    3757          66 : encode_DHPublicKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DHPublicKey *data, size_t *size)
    3758             : {
    3759          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    3760             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3761             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    3762             : 
    3763          66 : e = der_put_heim_integer(p, len, data, &l);
    3764          66 : if (e) return e;
    3765          66 : p -= l; len -= l; ret += l;
    3766             : 
    3767          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    3768          66 : if (e) return e;
    3769          66 : p -= l; len -= l; ret += l;
    3770             : 
    3771          66 : *size = ret;
    3772          66 : return 0;
    3773             : }
    3774             : 
    3775             : int ASN1CALL
    3776          60 : decode_DHPublicKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DHPublicKey *data, size_t *size)
    3777             : {
    3778          60 : size_t ret = 0;
    3779             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3780             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    3781             : 
    3782          60 : memset(data, 0, sizeof(*data));
    3783             : {
    3784             : size_t Top_datalen, Top_oldlen;
    3785             : Der_type Top_type;
    3786          60 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
    3787          60 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    3788          60 : if(e) goto fail;
    3789          60 : p += l; len -= l; ret += l;
    3790          60 : Top_oldlen = len;
    3791          60 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3792          60 : len = Top_datalen;
    3793          60 : e = der_get_heim_integer(p, len, data, &l);
    3794          60 : if(e) goto fail;
    3795          60 : p += l; len -= l; ret += l;
    3796          60 : len = Top_oldlen - Top_datalen;
    3797             : }
    3798          94 : if(size) *size = ret;
    3799          60 : return 0;
    3800           0 : fail:
    3801           0 : free_DHPublicKey(data);
    3802           0 : return e;
    3803             : }
    3804             : 
    3805             : void ASN1CALL
    3806          26 : free_DHPublicKey(DHPublicKey *data)
    3807             : {
    3808          26 : der_free_heim_integer(data);
    3809          26 : }
    3810             : 
    3811             : size_t ASN1CALL
    3812          66 : length_DHPublicKey(const DHPublicKey *data)
    3813             : {
    3814          66 : size_t ret = 0;
    3815          66 : ret += der_length_heim_integer(data);
    3816          66 : ret += 1 + der_length_len (ret);
    3817          66 : return ret;
    3818             : }
    3819             : 
    3820             : int ASN1CALL
    3821           0 : copy_DHPublicKey(const DHPublicKey *from, DHPublicKey *to)
    3822             : {
    3823           0 : memset(to, 0, sizeof(*to));
    3824           0 : if(der_copy_heim_integer(from, to)) goto fail;
    3825           0 : return 0;
    3826           0 : fail:
    3827           0 : free_DHPublicKey(to);
    3828           0 : return ENOMEM;
    3829             : }
    3830             : 
    3831             : int ASN1CALL
    3832           0 : encode_OtherName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const OtherName *data, size_t *size)
    3833             : {
    3834           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    3835             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3836             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    3837             : 
    3838             : /* value */
    3839             : {
    3840           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3841           0 : ret = 0;
    3842           0 : e = encode_heim_any(p, len, &(data)->value, &l);
    3843           0 : if (e) return e;
    3844           0 : p -= l; len -= l; ret += l;
    3845             : 
    3846           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    3847           0 : if (e) return e;
    3848           0 : p -= l; len -= l; ret += l;
    3849             : 
    3850           0 : ret += Top_tag_oldret;
    3851             : }
    3852             : /* type-id */
    3853             : {
    3854           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    3855           0 : ret = 0;
    3856           0 : e = der_put_oid(p, len, &(data)->type_id, &l);
    3857           0 : if (e) return e;
    3858           0 : p -= l; len -= l; ret += l;
    3859             : 
    3860           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
    3861           0 : if (e) return e;
    3862           0 : p -= l; len -= l; ret += l;
    3863             : 
    3864           0 : ret += Top_tag_oldret;
    3865             : }
    3866           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    3867           0 : if (e) return e;
    3868           0 : p -= l; len -= l; ret += l;
    3869             : 
    3870           0 : *size = ret;
    3871           0 : return 0;
    3872             : }
    3873             : 
    3874             : int ASN1CALL
    3875           0 : decode_OtherName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, OtherName *data, size_t *size)
    3876             : {
    3877           0 : size_t ret = 0;
    3878             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3879             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    3880             : 
    3881           0 : memset(data, 0, sizeof(*data));
    3882             : {
    3883             : size_t Top_datalen, Top_oldlen;
    3884             : Der_type Top_type;
    3885           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    3886           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    3887           0 : if(e) goto fail;
    3888           0 : p += l; len -= l; ret += l;
    3889           0 : Top_oldlen = len;
    3890           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3891           0 : len = Top_datalen;
    3892             : {
    3893             : size_t type_id_datalen, type_id_oldlen;
    3894             : Der_type type_id_type;
    3895           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &type_id_type, UT_OID, &type_id_datalen, &l);
    3896           0 : if (e == 0 && type_id_type != PRIM) { e = ASN1_BAD_ID; }
    3897           0 : if(e) goto fail;
    3898           0 : p += l; len -= l; ret += l;
    3899           0 : type_id_oldlen = len;
    3900           0 : if (type_id_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3901           0 : len = type_id_datalen;
    3902           0 : e = der_get_oid(p, len, &(data)->type_id, &l);
    3903           0 : if(e) goto fail;
    3904           0 : p += l; len -= l; ret += l;
    3905           0 : len = type_id_oldlen - type_id_datalen;
    3906             : }
    3907             : {
    3908             : size_t value_datalen, value_oldlen;
    3909             : Der_type value_type;
    3910           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &value_type, 0, &value_datalen, &l);
    3911           0 : if (e == 0 && value_type != CONS) { e = ASN1_BAD_ID; }
    3912           0 : if(e) goto fail;
    3913           0 : p += l; len -= l; ret += l;
    3914           0 : value_oldlen = len;
    3915           0 : if (value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    3916           0 : len = value_datalen;
    3917           0 : e = decode_heim_any(p, len, &(data)->value, &l);
    3918           0 : if(e) goto fail;
    3919           0 : p += l; len -= l; ret += l;
    3920           0 : len = value_oldlen - value_datalen;
    3921             : }
    3922           0 : len = Top_oldlen - Top_datalen;
    3923             : }
    3924           0 : if(size) *size = ret;
    3925           0 : return 0;
    3926           0 : fail:
    3927           0 : free_OtherName(data);
    3928           0 : return e;
    3929             : }
    3930             : 
    3931             : void ASN1CALL
    3932           0 : free_OtherName(OtherName *data)
    3933             : {
    3934           0 : der_free_oid(&(data)->type_id);
    3935           0 : free_heim_any(&(data)->value);
    3936           0 : }
    3937             : 
    3938             : size_t ASN1CALL
    3939           0 : length_OtherName(const OtherName *data)
    3940             : {
    3941           0 : size_t ret = 0;
    3942             : {
    3943           0 : size_t Top_tag_oldret = ret;
    3944           0 : ret = 0;
    3945           0 : ret += der_length_oid(&(data)->type_id);
    3946           0 : ret += 1 + der_length_len (ret);
    3947           0 : ret += Top_tag_oldret;
    3948             : }
    3949             : {
    3950           0 : size_t Top_tag_oldret = ret;
    3951           0 : ret = 0;
    3952           0 : ret += length_heim_any(&(data)->value);
    3953           0 : ret += 1 + der_length_len (ret);
    3954           0 : ret += Top_tag_oldret;
    3955             : }
    3956           0 : ret += 1 + der_length_len (ret);
    3957           0 : return ret;
    3958             : }
    3959             : 
    3960             : int ASN1CALL
    3961           0 : copy_OtherName(const OtherName *from, OtherName *to)
    3962             : {
    3963           0 : memset(to, 0, sizeof(*to));
    3964           0 : if(der_copy_oid(&(from)->type_id, &(to)->type_id)) goto fail;
    3965           0 : if(copy_heim_any(&(from)->value, &(to)->value)) goto fail;
    3966           0 : return 0;
    3967           0 : fail:
    3968           0 : free_OtherName(to);
    3969           0 : return ENOMEM;
    3970             : }
    3971             : 
    3972             : int ASN1CALL
    3973           0 : encode_GeneralName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GeneralName *data, size_t *size)
    3974             : {
    3975           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    3976             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    3977             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    3978             : 
    3979             : 
    3980           0 : switch((data)->element) {
    3981           0 : case choice_GeneralName_registeredID: {size_t Top_oldret = ret;
    3982           0 : ret = 0;
    3983           0 : e = der_put_oid(p, len, &((data))->u.registeredID, &l);
    3984           0 : if (e) return e;
    3985           0 : p -= l; len -= l; ret += l;
    3986             : 
    3987           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 8, &l);
    3988           0 : if (e) return e;
    3989           0 : p -= l; len -= l; ret += l;
    3990             : 
    3991           0 : ret += Top_oldret;
    3992           0 : break;
    3993             : }
    3994           0 : case choice_GeneralName_iPAddress: {size_t Top_oldret = ret;
    3995           0 : ret = 0;
    3996           0 : e = der_put_octet_string(p, len, &((data))->u.iPAddress, &l);
    3997           0 : if (e) return e;
    3998           0 : p -= l; len -= l; ret += l;
    3999             : 
    4000           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 7, &l);
    4001           0 : if (e) return e;
    4002           0 : p -= l; len -= l; ret += l;
    4003             : 
    4004           0 : ret += Top_oldret;
    4005           0 : break;
    4006             : }
    4007           0 : case choice_GeneralName_uniformResourceIdentifier: {size_t Top_oldret = ret;
    4008           0 : ret = 0;
    4009           0 : e = der_put_ia5_string(p, len, &((data))->u.uniformResourceIdentifier, &l);
    4010           0 : if (e) return e;
    4011           0 : p -= l; len -= l; ret += l;
    4012             : 
    4013           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 6, &l);
    4014           0 : if (e) return e;
    4015           0 : p -= l; len -= l; ret += l;
    4016             : 
    4017           0 : ret += Top_oldret;
    4018           0 : break;
    4019             : }
    4020           0 : case choice_GeneralName_directoryName: {size_t Top_oldret = ret;
    4021           0 : ret = 0;
    4022             : 
    4023           0 : switch((&((data))->u.directoryName)->element) {
    4024           0 : case choice_GeneralName_directoryName_rdnSequence: {size_t directoryName_tag_oldret = ret;
    4025           0 : ret = 0;
    4026           0 : e = encode_RDNSequence(p, len, &((&((data))->u.directoryName))->u.rdnSequence, &l);
    4027           0 : if (e) return e;
    4028           0 : p -= l; len -= l; ret += l;
    4029             : 
    4030           0 : ret += directoryName_tag_oldret;
    4031           0 : break;
    4032             : }
    4033             : };
    4034           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 4, &l);
    4035           0 : if (e) return e;
    4036           0 : p -= l; len -= l; ret += l;
    4037             : 
    4038           0 : ret += Top_oldret;
    4039           0 : break;
    4040             : }
    4041           0 : case choice_GeneralName_dNSName: {size_t Top_oldret = ret;
    4042           0 : ret = 0;
    4043           0 : e = der_put_ia5_string(p, len, &((data))->u.dNSName, &l);
    4044           0 : if (e) return e;
    4045           0 : p -= l; len -= l; ret += l;
    4046             : 
    4047           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 2, &l);
    4048           0 : if (e) return e;
    4049           0 : p -= l; len -= l; ret += l;
    4050             : 
    4051           0 : ret += Top_oldret;
    4052           0 : break;
    4053             : }
    4054           0 : case choice_GeneralName_rfc822Name: {size_t Top_oldret = ret;
    4055           0 : ret = 0;
    4056           0 : e = der_put_ia5_string(p, len, &((data))->u.rfc822Name, &l);
    4057           0 : if (e) return e;
    4058           0 : p -= l; len -= l; ret += l;
    4059             : 
    4060           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 1, &l);
    4061           0 : if (e) return e;
    4062           0 : p -= l; len -= l; ret += l;
    4063             : 
    4064           0 : ret += Top_oldret;
    4065           0 : break;
    4066             : }
    4067           0 : case choice_GeneralName_otherName: {size_t Top_oldret = ret;
    4068           0 : ret = 0;
    4069             : /* value */
    4070             : {
    4071           0 : size_t otherName_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    4072           0 : ret = 0;
    4073           0 : e = encode_heim_any(p, len, &(&((data))->u.otherName)->value, &l);
    4074           0 : if (e) return e;
    4075           0 : p -= l; len -= l; ret += l;
    4076             : 
    4077           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    4078           0 : if (e) return e;
    4079           0 : p -= l; len -= l; ret += l;
    4080             : 
    4081           0 : ret += otherName_tag_oldret;
    4082             : }
    4083             : /* type-id */
    4084             : {
    4085           0 : size_t otherName_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    4086           0 : ret = 0;
    4087           0 : e = der_put_oid(p, len, &(&((data))->u.otherName)->type_id, &l);
    4088           0 : if (e) return e;
    4089           0 : p -= l; len -= l; ret += l;
    4090             : 
    4091           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
    4092           0 : if (e) return e;
    4093           0 : p -= l; len -= l; ret += l;
    4094             : 
    4095           0 : ret += otherName_tag_oldret;
    4096             : }
    4097           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    4098           0 : if (e) return e;
    4099           0 : p -= l; len -= l; ret += l;
    4100             : 
    4101           0 : ret += Top_oldret;
    4102           0 : break;
    4103             : }
    4104             : };
    4105           0 : *size = ret;
    4106           0 : return 0;
    4107             : }
    4108             : 
    4109             : int ASN1CALL
    4110         176 : decode_GeneralName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GeneralName *data, size_t *size)
    4111             : {
    4112         176 : size_t ret = 0;
    4113             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4114             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    4115             : 
    4116         176 : memset(data, 0, sizeof(*data));
    4117         176 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
    4118             : {
    4119             : size_t otherName_datalen, otherName_oldlen;
    4120             : Der_type otherName_type;
    4121          88 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &otherName_type, 0, &otherName_datalen, &l);
    4122          88 : if (e == 0 && otherName_type != CONS) { e = ASN1_BAD_ID; }
    4123          88 : if(e) goto fail;
    4124          88 : p += l; len -= l; ret += l;
    4125          88 : otherName_oldlen = len;
    4126          88 : if (otherName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4127          88 : len = otherName_datalen;
    4128             : {
    4129             : size_t type_id_datalen, type_id_oldlen;
    4130             : Der_type type_id_type;
    4131          88 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &type_id_type, UT_OID, &type_id_datalen, &l);
    4132          88 : if (e == 0 && type_id_type != PRIM) { e = ASN1_BAD_ID; }
    4133          88 : if(e) goto fail;
    4134          88 : p += l; len -= l; ret += l;
    4135          88 : type_id_oldlen = len;
    4136          88 : if (type_id_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4137          88 : len = type_id_datalen;
    4138          88 : e = der_get_oid(p, len, &(&(data)->u.otherName)->type_id, &l);
    4139          88 : if(e) goto fail;
    4140          88 : p += l; len -= l; ret += l;
    4141          88 : len = type_id_oldlen - type_id_datalen;
    4142             : }
    4143             : {
    4144             : size_t value_datalen, value_oldlen;
    4145             : Der_type value_type;
    4146          88 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &value_type, 0, &value_datalen, &l);
    4147         176 : if (e == 0 && value_type != CONS) { e = ASN1_BAD_ID; }
    4148          88 : if(e) goto fail;
    4149          88 : p += l; len -= l; ret += l;
    4150          88 : value_oldlen = len;
    4151          88 : if (value_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4152          88 : len = value_datalen;
    4153          88 : e = decode_heim_any(p, len, &(&(data)->u.otherName)->value, &l);
    4154          88 : if(e) goto fail;
    4155          88 : p += l; len -= l; ret += l;
    4156          88 : len = value_oldlen - value_datalen;
    4157             : }
    4158          88 : len = otherName_oldlen - otherName_datalen;
    4159             : }
    4160          88 : (data)->element = choice_GeneralName_otherName;
    4161             : }
    4162          88 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 1, NULL) == 0) {
    4163             : {
    4164             : size_t rfc822Name_datalen, rfc822Name_oldlen;
    4165             : Der_type rfc822Name_type;
    4166          88 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &rfc822Name_type, 1, &rfc822Name_datalen, &l);
    4167          88 : if (e == 0 && rfc822Name_type != PRIM) { e = ASN1_BAD_ID; }
    4168          88 : if(e) goto fail;
    4169          88 : p += l; len -= l; ret += l;
    4170          88 : rfc822Name_oldlen = len;
    4171          88 : if (rfc822Name_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4172          88 : len = rfc822Name_datalen;
    4173          88 : e = der_get_ia5_string(p, len, &(data)->u.rfc822Name, &l);
    4174          88 : if(e) goto fail;
    4175          88 : p += l; len -= l; ret += l;
    4176          88 : len = rfc822Name_oldlen - rfc822Name_datalen;
    4177             : }
    4178          88 : (data)->element = choice_GeneralName_rfc822Name;
    4179             : }
    4180           0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 2, NULL) == 0) {
    4181             : {
    4182             : size_t dNSName_datalen, dNSName_oldlen;
    4183             : Der_type dNSName_type;
    4184           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &dNSName_type, 2, &dNSName_datalen, &l);
    4185           0 : if (e == 0 && dNSName_type != PRIM) { e = ASN1_BAD_ID; }
    4186           0 : if(e) goto fail;
    4187           0 : p += l; len -= l; ret += l;
    4188           0 : dNSName_oldlen = len;
    4189           0 : if (dNSName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4190           0 : len = dNSName_datalen;
    4191           0 : e = der_get_ia5_string(p, len, &(data)->u.dNSName, &l);
    4192           0 : if(e) goto fail;
    4193           0 : p += l; len -= l; ret += l;
    4194           0 : len = dNSName_oldlen - dNSName_datalen;
    4195             : }
    4196           0 : (data)->element = choice_GeneralName_dNSName;
    4197             : }
    4198           0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 4, NULL) == 0) {
    4199             : {
    4200             : size_t directoryName_datalen, directoryName_oldlen;
    4201             : Der_type directoryName_type;
    4202           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &directoryName_type, 4, &directoryName_datalen, &l);
    4203           0 : if (e == 0 && directoryName_type != CONS) { e = ASN1_BAD_ID; }
    4204           0 : if(e) goto fail;
    4205           0 : p += l; len -= l; ret += l;
    4206           0 : directoryName_oldlen = len;
    4207           0 : if (directoryName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4208           0 : len = directoryName_datalen;
    4209           0 : if (der_match_tag(p, len, ASN1_C_UNIV, CONS, UT_Sequence, NULL) == 0) {
    4210           0 : e = decode_RDNSequence(p, len, &(&(data)->u.directoryName)->u.rdnSequence, &l);
    4211           0 : if(e) goto fail;
    4212           0 : p += l; len -= l; ret += l;
    4213           0 : (&(data)->u.directoryName)->element = choice_GeneralName_directoryName_rdnSequence;
    4214             : }
    4215             : else {
    4216           0 : e = ASN1_PARSE_ERROR;
    4217           0 : goto fail;
    4218             : }
    4219           0 : len = directoryName_oldlen - directoryName_datalen;
    4220             : }
    4221           0 : (data)->element = choice_GeneralName_directoryName;
    4222             : }
    4223           0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 6, NULL) == 0) {
    4224             : {
    4225             : size_t uniformResourceIdentifier_datalen, uniformResourceIdentifier_oldlen;
    4226             : Der_type uniformResourceIdentifier_type;
    4227           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &uniformResourceIdentifier_type, 6, &uniformResourceIdentifier_datalen, &l);
    4228           0 : if (e == 0 && uniformResourceIdentifier_type != PRIM) { e = ASN1_BAD_ID; }
    4229           0 : if(e) goto fail;
    4230           0 : p += l; len -= l; ret += l;
    4231           0 : uniformResourceIdentifier_oldlen = len;
    4232           0 : if (uniformResourceIdentifier_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4233           0 : len = uniformResourceIdentifier_datalen;
    4234           0 : e = der_get_ia5_string(p, len, &(data)->u.uniformResourceIdentifier, &l);
    4235           0 : if(e) goto fail;
    4236           0 : p += l; len -= l; ret += l;
    4237           0 : len = uniformResourceIdentifier_oldlen - uniformResourceIdentifier_datalen;
    4238             : }
    4239           0 : (data)->element = choice_GeneralName_uniformResourceIdentifier;
    4240             : }
    4241           0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 7, NULL) == 0) {
    4242             : {
    4243             : size_t iPAddress_datalen, iPAddress_oldlen;
    4244             : Der_type iPAddress_type;
    4245           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &iPAddress_type, 7, &iPAddress_datalen, &l);
    4246           0 : if (e == 0 && iPAddress_type != PRIM) { e = ASN1_BAD_ID; }
    4247           0 : if(e) goto fail;
    4248           0 : p += l; len -= l; ret += l;
    4249           0 : iPAddress_oldlen = len;
    4250           0 : if (iPAddress_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4251           0 : len = iPAddress_datalen;
    4252           0 : e = der_get_octet_string(p, len, &(data)->u.iPAddress, &l);
    4253           0 : if(e) goto fail;
    4254           0 : p += l; len -= l; ret += l;
    4255           0 : len = iPAddress_oldlen - iPAddress_datalen;
    4256             : }
    4257           0 : (data)->element = choice_GeneralName_iPAddress;
    4258             : }
    4259           0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, PRIM, 8, NULL) == 0) {
    4260             : {
    4261             : size_t registeredID_datalen, registeredID_oldlen;
    4262             : Der_type registeredID_type;
    4263           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &registeredID_type, 8, &registeredID_datalen, &l);
    4264           0 : if (e == 0 && registeredID_type != PRIM) { e = ASN1_BAD_ID; }
    4265           0 : if(e) goto fail;
    4266           0 : p += l; len -= l; ret += l;
    4267           0 : registeredID_oldlen = len;
    4268           0 : if (registeredID_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4269           0 : len = registeredID_datalen;
    4270           0 : e = der_get_oid(p, len, &(data)->u.registeredID, &l);
    4271           0 : if(e) goto fail;
    4272           0 : p += l; len -= l; ret += l;
    4273           0 : len = registeredID_oldlen - registeredID_datalen;
    4274             : }
    4275           0 : (data)->element = choice_GeneralName_registeredID;
    4276             : }
    4277             : else {
    4278           0 : e = ASN1_PARSE_ERROR;
    4279           0 : goto fail;
    4280             : }
    4281         176 : if(size) *size = ret;
    4282         176 : return 0;
    4283           0 : fail:
    4284           0 : free_GeneralName(data);
    4285           0 : return e;
    4286             : }
    4287             : 
    4288             : void ASN1CALL
    4289         176 : free_GeneralName(GeneralName *data)
    4290             : {
    4291         176 : switch((data)->element) {
    4292          88 : case choice_GeneralName_otherName:
    4293          88 : der_free_oid(&(&(data)->u.otherName)->type_id);
    4294          88 : free_heim_any(&(&(data)->u.otherName)->value);
    4295          88 : break;
    4296          88 : case choice_GeneralName_rfc822Name:
    4297          88 : der_free_ia5_string(&(data)->u.rfc822Name);
    4298          88 : break;
    4299           0 : case choice_GeneralName_dNSName:
    4300           0 : der_free_ia5_string(&(data)->u.dNSName);
    4301           0 : break;
    4302           0 : case choice_GeneralName_directoryName:
    4303           0 : switch((&(data)->u.directoryName)->element) {
    4304           0 : case choice_GeneralName_directoryName_rdnSequence:
    4305           0 : free_RDNSequence(&(&(data)->u.directoryName)->u.rdnSequence);
    4306           0 : break;
    4307             : }
    4308           0 : break;
    4309           0 : case choice_GeneralName_uniformResourceIdentifier:
    4310           0 : der_free_ia5_string(&(data)->u.uniformResourceIdentifier);
    4311           0 : break;
    4312           0 : case choice_GeneralName_iPAddress:
    4313           0 : der_free_octet_string(&(data)->u.iPAddress);
    4314           0 : break;
    4315           0 : case choice_GeneralName_registeredID:
    4316           0 : der_free_oid(&(data)->u.registeredID);
    4317           0 : break;
    4318             : }
    4319         176 : }
    4320             : 
    4321             : size_t ASN1CALL
    4322           0 : length_GeneralName(const GeneralName *data)
    4323             : {
    4324           0 : size_t ret = 0;
    4325           0 : switch((data)->element) {
    4326           0 : case choice_GeneralName_otherName:
    4327             : {
    4328           0 : size_t Top_oldret = ret;
    4329           0 : ret = 0;
    4330             : {
    4331           0 : size_t otherName_tag_oldret = ret;
    4332           0 : ret = 0;
    4333           0 : ret += der_length_oid(&(&(data)->u.otherName)->type_id);
    4334           0 : ret += 1 + der_length_len (ret);
    4335           0 : ret += otherName_tag_oldret;
    4336             : }
    4337             : {
    4338           0 : size_t otherName_tag_oldret = ret;
    4339           0 : ret = 0;
    4340           0 : ret += length_heim_any(&(&(data)->u.otherName)->value);
    4341           0 : ret += 1 + der_length_len (ret);
    4342           0 : ret += otherName_tag_oldret;
    4343             : }
    4344           0 : ret += 1 + der_length_len (ret);
    4345           0 : ret += Top_oldret;
    4346             : }
    4347           0 : break;
    4348           0 : case choice_GeneralName_rfc822Name:
    4349             : {
    4350           0 : size_t Top_oldret = ret;
    4351           0 : ret = 0;
    4352           0 : ret += der_length_ia5_string(&(data)->u.rfc822Name);
    4353           0 : ret += 1 + der_length_len (ret);
    4354           0 : ret += Top_oldret;
    4355             : }
    4356           0 : break;
    4357           0 : case choice_GeneralName_dNSName:
    4358             : {
    4359           0 : size_t Top_oldret = ret;
    4360           0 : ret = 0;
    4361           0 : ret += der_length_ia5_string(&(data)->u.dNSName);
    4362           0 : ret += 1 + der_length_len (ret);
    4363           0 : ret += Top_oldret;
    4364             : }
    4365           0 : break;
    4366           0 : case choice_GeneralName_directoryName:
    4367             : {
    4368           0 : size_t Top_oldret = ret;
    4369           0 : ret = 0;
    4370           0 : switch((&(data)->u.directoryName)->element) {
    4371           0 : case choice_GeneralName_directoryName_rdnSequence:
    4372             : {
    4373           0 : size_t directoryName_tag_oldret = ret;
    4374           0 : ret = 0;
    4375           0 : ret += length_RDNSequence(&(&(data)->u.directoryName)->u.rdnSequence);
    4376           0 : ret += directoryName_tag_oldret;
    4377             : }
    4378           0 : break;
    4379             : }
    4380           0 : ret += 1 + der_length_len (ret);
    4381           0 : ret += Top_oldret;
    4382             : }
    4383           0 : break;
    4384           0 : case choice_GeneralName_uniformResourceIdentifier:
    4385             : {
    4386           0 : size_t Top_oldret = ret;
    4387           0 : ret = 0;
    4388           0 : ret += der_length_ia5_string(&(data)->u.uniformResourceIdentifier);
    4389           0 : ret += 1 + der_length_len (ret);
    4390           0 : ret += Top_oldret;
    4391             : }
    4392           0 : break;
    4393           0 : case choice_GeneralName_iPAddress:
    4394             : {
    4395           0 : size_t Top_oldret = ret;
    4396           0 : ret = 0;
    4397           0 : ret += der_length_octet_string(&(data)->u.iPAddress);
    4398           0 : ret += 1 + der_length_len (ret);
    4399           0 : ret += Top_oldret;
    4400             : }
    4401           0 : break;
    4402           0 : case choice_GeneralName_registeredID:
    4403             : {
    4404           0 : size_t Top_oldret = ret;
    4405           0 : ret = 0;
    4406           0 : ret += der_length_oid(&(data)->u.registeredID);
    4407           0 : ret += 1 + der_length_len (ret);
    4408           0 : ret += Top_oldret;
    4409             : }
    4410           0 : break;
    4411             : }
    4412           0 : return ret;
    4413             : }
    4414             : 
    4415             : int ASN1CALL
    4416           0 : copy_GeneralName(const GeneralName *from, GeneralName *to)
    4417             : {
    4418           0 : memset(to, 0, sizeof(*to));
    4419           0 : (to)->element = (from)->element;
    4420           0 : switch((from)->element) {
    4421           0 : case choice_GeneralName_otherName:
    4422           0 : if(der_copy_oid(&(&(from)->u.otherName)->type_id, &(&(to)->u.otherName)->type_id)) goto fail;
    4423           0 : if(copy_heim_any(&(&(from)->u.otherName)->value, &(&(to)->u.otherName)->value)) goto fail;
    4424           0 : break;
    4425           0 : case choice_GeneralName_rfc822Name:
    4426           0 : if(der_copy_ia5_string(&(from)->u.rfc822Name, &(to)->u.rfc822Name)) goto fail;
    4427           0 : break;
    4428           0 : case choice_GeneralName_dNSName:
    4429           0 : if(der_copy_ia5_string(&(from)->u.dNSName, &(to)->u.dNSName)) goto fail;
    4430           0 : break;
    4431           0 : case choice_GeneralName_directoryName:
    4432           0 : (&(to)->u.directoryName)->element = (&(from)->u.directoryName)->element;
    4433           0 : switch((&(from)->u.directoryName)->element) {
    4434           0 : case choice_GeneralName_directoryName_rdnSequence:
    4435           0 : if(copy_RDNSequence(&(&(from)->u.directoryName)->u.rdnSequence, &(&(to)->u.directoryName)->u.rdnSequence)) goto fail;
    4436           0 : break;
    4437             : }
    4438           0 : break;
    4439           0 : case choice_GeneralName_uniformResourceIdentifier:
    4440           0 : if(der_copy_ia5_string(&(from)->u.uniformResourceIdentifier, &(to)->u.uniformResourceIdentifier)) goto fail;
    4441           0 : break;
    4442           0 : case choice_GeneralName_iPAddress:
    4443           0 : if(der_copy_octet_string(&(from)->u.iPAddress, &(to)->u.iPAddress)) goto fail;
    4444           0 : break;
    4445           0 : case choice_GeneralName_registeredID:
    4446           0 : if(der_copy_oid(&(from)->u.registeredID, &(to)->u.registeredID)) goto fail;
    4447           0 : break;
    4448             : }
    4449           0 : return 0;
    4450           0 : fail:
    4451           0 : free_GeneralName(to);
    4452           0 : return ENOMEM;
    4453             : }
    4454             : 
    4455             : int ASN1CALL
    4456           0 : encode_GeneralNames(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GeneralNames *data, size_t *size)
    4457             : {
    4458           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    4459             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4460             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    4461             : 
    4462           0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    4463           0 : size_t Top_tag_for_oldret = ret;
    4464           0 : ret = 0;
    4465           0 : e = encode_GeneralName(p, len, &(data)->val[i], &l);
    4466           0 : if (e) return e;
    4467           0 : p -= l; len -= l; ret += l;
    4468             : 
    4469           0 : ret += Top_tag_for_oldret;
    4470             : }
    4471           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    4472           0 : if (e) return e;
    4473           0 : p -= l; len -= l; ret += l;
    4474             : 
    4475           0 : *size = ret;
    4476           0 : return 0;
    4477             : }
    4478             : 
    4479             : int ASN1CALL
    4480          88 : decode_GeneralNames(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GeneralNames *data, size_t *size)
    4481             : {
    4482          88 : size_t ret = 0;
    4483             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4484             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    4485             : 
    4486          88 : memset(data, 0, sizeof(*data));
    4487             : {
    4488             : size_t Top_datalen, Top_oldlen;
    4489             : Der_type Top_type;
    4490          88 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    4491          88 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    4492          88 : if(e) goto fail;
    4493          88 : p += l; len -= l; ret += l;
    4494          88 : Top_oldlen = len;
    4495          88 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4496          88 : len = Top_datalen;
    4497             : {
    4498          88 : size_t Top_Tag_origlen = len;
    4499          88 : size_t Top_Tag_oldret = ret;
    4500          88 : size_t Top_Tag_olen = 0;
    4501             : void *Top_Tag_tmp;
    4502          88 : ret = 0;
    4503          88 : (data)->len = 0;
    4504          88 : (data)->val = NULL;
    4505         352 : while(ret < Top_Tag_origlen) {
    4506         176 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    4507         176 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    4508         176 : Top_Tag_olen = Top_Tag_nlen;
    4509         176 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    4510         176 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    4511         176 : (data)->val = Top_Tag_tmp;
    4512         176 : e = decode_GeneralName(p, len, &(data)->val[(data)->len], &l);
    4513         176 : if(e) goto fail;
    4514         176 : p += l; len -= l; ret += l;
    4515         176 : (data)->len++;
    4516         176 : len = Top_Tag_origlen - ret;
    4517             : }
    4518          88 : ret += Top_Tag_oldret;
    4519             : }
    4520          88 : if ((data)->len < 1) {
    4521           0 : e = ASN1_MIN_CONSTRAINT; goto fail;
    4522             : }
    4523          88 : len = Top_oldlen - Top_datalen;
    4524             : }
    4525         176 : if(size) *size = ret;
    4526          88 : return 0;
    4527           0 : fail:
    4528           0 : free_GeneralNames(data);
    4529           0 : return e;
    4530             : }
    4531             : 
    4532             : void ASN1CALL
    4533          88 : free_GeneralNames(GeneralNames *data)
    4534             : {
    4535         352 : while((data)->len){
    4536         176 : free_GeneralName(&(data)->val[(data)->len-1]);
    4537         176 : (data)->len--;
    4538             : }
    4539          88 : free((data)->val);
    4540          88 : (data)->val = NULL;
    4541          88 : }
    4542             : 
    4543             : size_t ASN1CALL
    4544           0 : length_GeneralNames(const GeneralNames *data)
    4545             : {
    4546           0 : size_t ret = 0;
    4547             : {
    4548           0 : size_t Top_tag_oldret = ret;
    4549             : int i;
    4550           0 : ret = 0;
    4551           0 : for(i = (data)->len - 1; i >= 0; --i){
    4552           0 : size_t Top_tag_for_oldret = ret;
    4553           0 : ret = 0;
    4554           0 : ret += length_GeneralName(&(data)->val[i]);
    4555           0 : ret += Top_tag_for_oldret;
    4556             : }
    4557           0 : ret += Top_tag_oldret;
    4558             : }
    4559           0 : ret += 1 + der_length_len (ret);
    4560           0 : return ret;
    4561             : }
    4562             : 
    4563             : int ASN1CALL
    4564           0 : copy_GeneralNames(const GeneralNames *from, GeneralNames *to)
    4565             : {
    4566           0 : memset(to, 0, sizeof(*to));
    4567           0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    4568           0 : goto fail;
    4569           0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    4570           0 : if(copy_GeneralName(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    4571             : }
    4572           0 : return 0;
    4573           0 : fail:
    4574           0 : free_GeneralNames(to);
    4575           0 : return ENOMEM;
    4576             : }
    4577             : 
    4578             : int ASN1CALL
    4579           0 : add_GeneralNames(GeneralNames *data, const GeneralName *element)
    4580             : {
    4581             : int ret;
    4582             : void *ptr;
    4583             : 
    4584           0 : ptr = realloc(data->val, 
    4585           0 :         (data->len + 1) * sizeof(data->val[0]));
    4586           0 : if (ptr == NULL) return ENOMEM;
    4587           0 : data->val = ptr;
    4588             : 
    4589           0 : ret = copy_GeneralName(element, &data->val[data->len]);
    4590           0 : if (ret) return ret;
    4591           0 : data->len++;
    4592           0 : return 0;
    4593             : }
    4594             : 
    4595             : int ASN1CALL
    4596           0 : remove_GeneralNames(GeneralNames *data, unsigned int element)
    4597             : {
    4598             : void *ptr;
    4599             : 
    4600           0 : if (data->len == 0 || element >= data->len)
    4601           0 :         return ASN1_OVERRUN;
    4602           0 : free_GeneralName(&data->val[element]);
    4603           0 : data->len--;
    4604           0 : if (element < data->len)
    4605           0 :         memmove(&data->val[element], &data->val[element + 1], 
    4606           0 :                 sizeof(data->val[0]) * data->len);
    4607           0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
    4608           0 : if (ptr != NULL || data->len == 0) data->val = ptr;
    4609           0 : return 0;
    4610             : }
    4611             : 
    4612             : static unsigned oid_id_x509_ce_keyUsage_variable_num[4] =  {2, 5, 29, 15 };
    4613             : const heim_oid asn1_oid_id_x509_ce_keyUsage = { 4, oid_id_x509_ce_keyUsage_variable_num };
    4614             : 
    4615             : int ASN1CALL
    4616           0 : encode_KeyUsage(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KeyUsage *data, size_t *size)
    4617             : {
    4618           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    4619             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4620             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    4621             : 
    4622             : {
    4623           0 : unsigned char c = 0;
    4624           0 : int rest = 0;
    4625           0 : int bit_set = 0;
    4626           0 : if((data)->decipherOnly) {
    4627           0 : c |= 1<<7;
    4628             : }
    4629           0 : if (c != 0 || bit_set) {
    4630           0 : if (len < 1) return ASN1_OVERFLOW;
    4631           0 : *p-- = c; len--; ret++;
    4632           0 : if (!bit_set) {
    4633           0 : rest = 0;
    4634           0 : while(c) { 
    4635           0 : if (c & 1) break;
    4636           0 : c = c >> 1;
    4637           0 : rest++;
    4638             : }
    4639           0 : bit_set = 1;
    4640             : }
    4641             : }
    4642           0 : c = 0;
    4643           0 : if((data)->encipherOnly) {
    4644           0 : c |= 1<<0;
    4645             : }
    4646           0 : if((data)->cRLSign) {
    4647           0 : c |= 1<<1;
    4648             : }
    4649           0 : if((data)->keyCertSign) {
    4650           0 : c |= 1<<2;
    4651             : }
    4652           0 : if((data)->keyAgreement) {
    4653           0 : c |= 1<<3;
    4654             : }
    4655           0 : if((data)->dataEncipherment) {
    4656           0 : c |= 1<<4;
    4657             : }
    4658           0 : if((data)->keyEncipherment) {
    4659           0 : c |= 1<<5;
    4660             : }
    4661           0 : if((data)->nonRepudiation) {
    4662           0 : c |= 1<<6;
    4663             : }
    4664           0 : if((data)->digitalSignature) {
    4665           0 : c |= 1<<7;
    4666             : }
    4667           0 : if (c != 0 || bit_set) {
    4668           0 : if (len < 1) return ASN1_OVERFLOW;
    4669           0 : *p-- = c; len--; ret++;
    4670           0 : if (!bit_set) {
    4671           0 : rest = 0;
    4672           0 : if(c) { 
    4673           0 : while(c) { 
    4674           0 : if (c & 1) break;
    4675           0 : c = c >> 1;
    4676           0 : rest++;
    4677             : }
    4678             : }
    4679             : }
    4680             : }
    4681           0 : if (len < 1) return ASN1_OVERFLOW;
    4682           0 : *p-- = rest;
    4683           0 : len -= 1;
    4684           0 : ret += 1;
    4685             : }
    4686             : 
    4687           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
    4688           0 : if (e) return e;
    4689           0 : p -= l; len -= l; ret += l;
    4690             : 
    4691           0 : *size = ret;
    4692           0 : return 0;
    4693             : }
    4694             : 
    4695             : int ASN1CALL
    4696         210 : decode_KeyUsage(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KeyUsage *data, size_t *size)
    4697             : {
    4698         210 : size_t ret = 0;
    4699             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4700             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    4701             : 
    4702         210 : memset(data, 0, sizeof(*data));
    4703             : {
    4704             : size_t Top_datalen, Top_oldlen;
    4705             : Der_type Top_type;
    4706         210 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
    4707         210 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    4708         210 : if(e) goto fail;
    4709         210 : p += l; len -= l; ret += l;
    4710         210 : Top_oldlen = len;
    4711         210 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4712         210 : len = Top_datalen;
    4713         210 : if (len < 1) return ASN1_OVERRUN;
    4714         210 : p++; len--; ret++;
    4715             : do {
    4716         210 : if (len < 1) break;
    4717         210 : (data)->digitalSignature = (*p >> 7) & 1;
    4718         210 : (data)->nonRepudiation = (*p >> 6) & 1;
    4719         210 : (data)->keyEncipherment = (*p >> 5) & 1;
    4720         210 : (data)->dataEncipherment = (*p >> 4) & 1;
    4721         210 : (data)->keyAgreement = (*p >> 3) & 1;
    4722         210 : (data)->keyCertSign = (*p >> 2) & 1;
    4723         210 : (data)->cRLSign = (*p >> 1) & 1;
    4724         210 : (data)->encipherOnly = (*p >> 0) & 1;
    4725         210 : p++; len--; ret++;
    4726         210 : if (len < 1) break;
    4727           0 : (data)->decipherOnly = (*p >> 7) & 1;
    4728             : } while(0);
    4729         210 : p += len; ret += len;
    4730         210 : len = Top_oldlen - Top_datalen;
    4731             : }
    4732         420 : if(size) *size = ret;
    4733         210 : return 0;
    4734           0 : fail:
    4735           0 : free_KeyUsage(data);
    4736           0 : return e;
    4737             : }
    4738             : 
    4739             : void ASN1CALL
    4740           0 : free_KeyUsage(KeyUsage *data)
    4741             : {
    4742           0 : }
    4743             : 
    4744             : size_t ASN1CALL
    4745           0 : length_KeyUsage(const KeyUsage *data)
    4746             : {
    4747           0 : size_t ret = 0;
    4748             : do {
    4749           0 : if((data)->decipherOnly) { ret += 2; break; }
    4750           0 : if((data)->encipherOnly) { ret += 1; break; }
    4751           0 : if((data)->cRLSign) { ret += 1; break; }
    4752           0 : if((data)->keyCertSign) { ret += 1; break; }
    4753           0 : if((data)->keyAgreement) { ret += 1; break; }
    4754           0 : if((data)->dataEncipherment) { ret += 1; break; }
    4755           0 : if((data)->keyEncipherment) { ret += 1; break; }
    4756           0 : if((data)->nonRepudiation) { ret += 1; break; }
    4757           0 : if((data)->digitalSignature) { ret += 1; break; }
    4758             : } while(0);
    4759           0 : ret += 1;
    4760           0 : ret += 1 + der_length_len (ret);
    4761           0 : return ret;
    4762             : }
    4763             : 
    4764             : int ASN1CALL
    4765           0 : copy_KeyUsage(const KeyUsage *from, KeyUsage *to)
    4766             : {
    4767           0 : memset(to, 0, sizeof(*to));
    4768           0 : *(to) = *(from);
    4769           0 : return 0;
    4770             : }
    4771             : 
    4772         210 : unsigned KeyUsage2int(KeyUsage f)
    4773             : {
    4774         210 : unsigned r = 0;
    4775         210 : if(f.digitalSignature) r |= (1U << 0);
    4776         210 : if(f.nonRepudiation) r |= (1U << 1);
    4777         210 : if(f.keyEncipherment) r |= (1U << 2);
    4778         210 : if(f.dataEncipherment) r |= (1U << 3);
    4779         210 : if(f.keyAgreement) r |= (1U << 4);
    4780         210 : if(f.keyCertSign) r |= (1U << 5);
    4781         210 : if(f.cRLSign) r |= (1U << 6);
    4782         210 : if(f.encipherOnly) r |= (1U << 7);
    4783         210 : if(f.decipherOnly) r |= (1U << 8);
    4784         210 : return r;
    4785             : }
    4786             : 
    4787           0 : KeyUsage int2KeyUsage(unsigned n)
    4788             : {
    4789             :         KeyUsage flags;
    4790             : 
    4791           0 :         memset(&flags, 0, sizeof(flags));
    4792             : 
    4793           0 :         flags.digitalSignature = (n >> 0) & 1;
    4794           0 :         flags.nonRepudiation = (n >> 1) & 1;
    4795           0 :         flags.keyEncipherment = (n >> 2) & 1;
    4796           0 :         flags.dataEncipherment = (n >> 3) & 1;
    4797           0 :         flags.keyAgreement = (n >> 4) & 1;
    4798           0 :         flags.keyCertSign = (n >> 5) & 1;
    4799           0 :         flags.cRLSign = (n >> 6) & 1;
    4800           0 :         flags.encipherOnly = (n >> 7) & 1;
    4801           0 :         flags.decipherOnly = (n >> 8) & 1;
    4802           0 :         return flags;
    4803             : }
    4804             : 
    4805             : static struct units KeyUsage_units[] = {
    4806             :         {"decipherOnly",      1U << 8},
    4807             :         {"encipherOnly",      1U << 7},
    4808             :         {"cRLSign",   1U << 6},
    4809             :         {"keyCertSign",       1U << 5},
    4810             :         {"keyAgreement",      1U << 4},
    4811             :         {"dataEncipherment",  1U << 3},
    4812             :         {"keyEncipherment",   1U << 2},
    4813             :         {"nonRepudiation",    1U << 1},
    4814             :         {"digitalSignature",  1U << 0},
    4815             :         {NULL,  0}
    4816             : };
    4817             : 
    4818           0 : const struct units * asn1_KeyUsage_units(void){
    4819           0 : return KeyUsage_units;
    4820             : }
    4821             : 
    4822             : static unsigned oid_id_x509_ce_authorityKeyIdentifier_variable_num[4] =  {2, 5, 29, 35 };
    4823             : const heim_oid asn1_oid_id_x509_ce_authorityKeyIdentifier = { 4, oid_id_x509_ce_authorityKeyIdentifier_variable_num };
    4824             : 
    4825             : int ASN1CALL
    4826          66 : encode_KeyIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const KeyIdentifier *data, size_t *size)
    4827             : {
    4828          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    4829             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4830             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    4831             : 
    4832          66 : e = der_put_octet_string(p, len, data, &l);
    4833          66 : if (e) return e;
    4834          66 : p -= l; len -= l; ret += l;
    4835             : 
    4836          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
    4837          66 : if (e) return e;
    4838          66 : p -= l; len -= l; ret += l;
    4839             : 
    4840          66 : *size = ret;
    4841          66 : return 0;
    4842             : }
    4843             : 
    4844             : int ASN1CALL
    4845         246 : decode_KeyIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, KeyIdentifier *data, size_t *size)
    4846             : {
    4847         246 : size_t ret = 0;
    4848             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4849             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    4850             : 
    4851         246 : memset(data, 0, sizeof(*data));
    4852             : {
    4853             : size_t Top_datalen, Top_oldlen;
    4854             : Der_type Top_type;
    4855         246 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
    4856         246 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    4857         246 : if(e) goto fail;
    4858         246 : p += l; len -= l; ret += l;
    4859         246 : Top_oldlen = len;
    4860         246 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4861         246 : len = Top_datalen;
    4862         246 : e = der_get_octet_string(p, len, data, &l);
    4863         246 : if(e) goto fail;
    4864         246 : p += l; len -= l; ret += l;
    4865         246 : len = Top_oldlen - Top_datalen;
    4866             : }
    4867         492 : if(size) *size = ret;
    4868         246 : return 0;
    4869           0 : fail:
    4870           0 : free_KeyIdentifier(data);
    4871           0 : return e;
    4872             : }
    4873             : 
    4874             : void ASN1CALL
    4875         246 : free_KeyIdentifier(KeyIdentifier *data)
    4876             : {
    4877         246 : der_free_octet_string(data);
    4878         246 : }
    4879             : 
    4880             : size_t ASN1CALL
    4881         132 : length_KeyIdentifier(const KeyIdentifier *data)
    4882             : {
    4883         132 : size_t ret = 0;
    4884         132 : ret += der_length_octet_string(data);
    4885         132 : ret += 1 + der_length_len (ret);
    4886         132 : return ret;
    4887             : }
    4888             : 
    4889             : int ASN1CALL
    4890           0 : copy_KeyIdentifier(const KeyIdentifier *from, KeyIdentifier *to)
    4891             : {
    4892           0 : memset(to, 0, sizeof(*to));
    4893           0 : if(der_copy_octet_string(from, to)) goto fail;
    4894           0 : return 0;
    4895           0 : fail:
    4896           0 : free_KeyIdentifier(to);
    4897           0 : return ENOMEM;
    4898             : }
    4899             : 
    4900             : int ASN1CALL
    4901           0 : encode_AuthorityKeyIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AuthorityKeyIdentifier *data, size_t *size)
    4902             : {
    4903           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    4904             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4905             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    4906             : 
    4907             : /* authorityCertSerialNumber */
    4908           0 : if((data)->authorityCertSerialNumber) {
    4909           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    4910           0 : ret = 0;
    4911           0 : e = der_put_heim_integer(p, len, (data)->authorityCertSerialNumber, &l);
    4912           0 : if (e) return e;
    4913           0 : p -= l; len -= l; ret += l;
    4914             : 
    4915           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 2, &l);
    4916           0 : if (e) return e;
    4917           0 : p -= l; len -= l; ret += l;
    4918             : 
    4919           0 : ret += Top_tag_oldret;
    4920             : }
    4921             : /* authorityCertIssuer */
    4922           0 : if((data)->authorityCertIssuer) {
    4923           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    4924           0 : ret = 0;
    4925           0 : for(i = (int)((data)->authorityCertIssuer)->len - 1; i >= 0; --i) {
    4926           0 : size_t authorityCertIssuer_tag_for_oldret = ret;
    4927           0 : ret = 0;
    4928           0 : e = encode_GeneralName(p, len, &((data)->authorityCertIssuer)->val[i], &l);
    4929           0 : if (e) return e;
    4930           0 : p -= l; len -= l; ret += l;
    4931             : 
    4932           0 : ret += authorityCertIssuer_tag_for_oldret;
    4933             : }
    4934           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
    4935           0 : if (e) return e;
    4936           0 : p -= l; len -= l; ret += l;
    4937             : 
    4938           0 : ret += Top_tag_oldret;
    4939             : }
    4940             : /* keyIdentifier */
    4941           0 : if((data)->keyIdentifier) {
    4942           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    4943           0 : ret = 0;
    4944           0 : e = der_put_octet_string(p, len, (data)->keyIdentifier, &l);
    4945           0 : if (e) return e;
    4946           0 : p -= l; len -= l; ret += l;
    4947             : 
    4948           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 0, &l);
    4949           0 : if (e) return e;
    4950           0 : p -= l; len -= l; ret += l;
    4951             : 
    4952           0 : ret += Top_tag_oldret;
    4953             : }
    4954           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    4955           0 : if (e) return e;
    4956           0 : p -= l; len -= l; ret += l;
    4957             : 
    4958           0 : *size = ret;
    4959           0 : return 0;
    4960             : }
    4961             : 
    4962             : int ASN1CALL
    4963          60 : decode_AuthorityKeyIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AuthorityKeyIdentifier *data, size_t *size)
    4964             : {
    4965          60 : size_t ret = 0;
    4966             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    4967             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    4968             : 
    4969          60 : memset(data, 0, sizeof(*data));
    4970             : {
    4971             : size_t Top_datalen, Top_oldlen;
    4972             : Der_type Top_type;
    4973          60 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    4974          60 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    4975          60 : if(e) goto fail;
    4976          60 : p += l; len -= l; ret += l;
    4977          60 : Top_oldlen = len;
    4978          60 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4979          60 : len = Top_datalen;
    4980             : {
    4981             : size_t keyIdentifier_datalen, keyIdentifier_oldlen;
    4982             : Der_type keyIdentifier_type;
    4983          60 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &keyIdentifier_type, 0, &keyIdentifier_datalen, &l);
    4984          60 : if (e == 0 && keyIdentifier_type != PRIM) { e = ASN1_BAD_ID; }
    4985          60 : if(e) {
    4986           0 : (data)->keyIdentifier = NULL;
    4987             : } else {
    4988          60 : (data)->keyIdentifier = calloc(1, sizeof(*(data)->keyIdentifier));
    4989          60 : if ((data)->keyIdentifier == NULL) { e = ENOMEM; goto fail; }
    4990          60 : p += l; len -= l; ret += l;
    4991          60 : keyIdentifier_oldlen = len;
    4992          60 : if (keyIdentifier_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    4993          60 : len = keyIdentifier_datalen;
    4994          60 : e = der_get_octet_string(p, len, (data)->keyIdentifier, &l);
    4995          60 : if(e) goto fail;
    4996          60 : p += l; len -= l; ret += l;
    4997          60 : len = keyIdentifier_oldlen - keyIdentifier_datalen;
    4998             : }
    4999             : }
    5000             : {
    5001             : size_t authorityCertIssuer_datalen, authorityCertIssuer_oldlen;
    5002             : Der_type authorityCertIssuer_type;
    5003          60 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorityCertIssuer_type, 1, &authorityCertIssuer_datalen, &l);
    5004          60 : if (e == 0 && authorityCertIssuer_type != CONS) { e = ASN1_BAD_ID; }
    5005          60 : if(e) {
    5006          60 : (data)->authorityCertIssuer = NULL;
    5007             : } else {
    5008           0 : (data)->authorityCertIssuer = calloc(1, sizeof(*(data)->authorityCertIssuer));
    5009           0 : if ((data)->authorityCertIssuer == NULL) { e = ENOMEM; goto fail; }
    5010           0 : p += l; len -= l; ret += l;
    5011           0 : authorityCertIssuer_oldlen = len;
    5012           0 : if (authorityCertIssuer_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5013           0 : len = authorityCertIssuer_datalen;
    5014             : {
    5015           0 : size_t authorityCertIssuer_Tag_origlen = len;
    5016           0 : size_t authorityCertIssuer_Tag_oldret = ret;
    5017           0 : size_t authorityCertIssuer_Tag_olen = 0;
    5018             : void *authorityCertIssuer_Tag_tmp;
    5019           0 : ret = 0;
    5020           0 : ((data)->authorityCertIssuer)->len = 0;
    5021           0 : ((data)->authorityCertIssuer)->val = NULL;
    5022           0 : while(ret < authorityCertIssuer_Tag_origlen) {
    5023           0 : size_t authorityCertIssuer_Tag_nlen = authorityCertIssuer_Tag_olen + sizeof(*(((data)->authorityCertIssuer)->val));
    5024           0 : if (authorityCertIssuer_Tag_olen > authorityCertIssuer_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    5025           0 : authorityCertIssuer_Tag_olen = authorityCertIssuer_Tag_nlen;
    5026           0 : authorityCertIssuer_Tag_tmp = realloc(((data)->authorityCertIssuer)->val, authorityCertIssuer_Tag_olen);
    5027           0 : if (authorityCertIssuer_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    5028           0 : ((data)->authorityCertIssuer)->val = authorityCertIssuer_Tag_tmp;
    5029           0 : e = decode_GeneralName(p, len, &((data)->authorityCertIssuer)->val[((data)->authorityCertIssuer)->len], &l);
    5030           0 : if(e) goto fail;
    5031           0 : p += l; len -= l; ret += l;
    5032           0 : ((data)->authorityCertIssuer)->len++;
    5033           0 : len = authorityCertIssuer_Tag_origlen - ret;
    5034             : }
    5035           0 : ret += authorityCertIssuer_Tag_oldret;
    5036             : }
    5037           0 : len = authorityCertIssuer_oldlen - authorityCertIssuer_datalen;
    5038             : }
    5039             : }
    5040             : {
    5041             : size_t authorityCertSerialNumber_datalen, authorityCertSerialNumber_oldlen;
    5042             : Der_type authorityCertSerialNumber_type;
    5043          60 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &authorityCertSerialNumber_type, 2, &authorityCertSerialNumber_datalen, &l);
    5044          60 : if (e == 0 && authorityCertSerialNumber_type != PRIM) { e = ASN1_BAD_ID; }
    5045          60 : if(e) {
    5046          60 : (data)->authorityCertSerialNumber = NULL;
    5047             : } else {
    5048           0 : (data)->authorityCertSerialNumber = calloc(1, sizeof(*(data)->authorityCertSerialNumber));
    5049           0 : if ((data)->authorityCertSerialNumber == NULL) { e = ENOMEM; goto fail; }
    5050           0 : p += l; len -= l; ret += l;
    5051           0 : authorityCertSerialNumber_oldlen = len;
    5052           0 : if (authorityCertSerialNumber_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5053           0 : len = authorityCertSerialNumber_datalen;
    5054           0 : e = der_get_heim_integer(p, len, (data)->authorityCertSerialNumber, &l);
    5055           0 : if(e) goto fail;
    5056           0 : p += l; len -= l; ret += l;
    5057           0 : len = authorityCertSerialNumber_oldlen - authorityCertSerialNumber_datalen;
    5058             : }
    5059             : }
    5060          60 : len = Top_oldlen - Top_datalen;
    5061             : }
    5062         120 : if(size) *size = ret;
    5063          60 : return 0;
    5064           0 : fail:
    5065           0 : free_AuthorityKeyIdentifier(data);
    5066           0 : return e;
    5067             : }
    5068             : 
    5069             : void ASN1CALL
    5070         186 : free_AuthorityKeyIdentifier(AuthorityKeyIdentifier *data)
    5071             : {
    5072         186 : if((data)->keyIdentifier) {
    5073          60 : der_free_octet_string((data)->keyIdentifier);
    5074          60 : free((data)->keyIdentifier);
    5075          60 : (data)->keyIdentifier = NULL;
    5076             : }
    5077         186 : if((data)->authorityCertIssuer) {
    5078           0 : while(((data)->authorityCertIssuer)->len){
    5079           0 : free_GeneralName(&((data)->authorityCertIssuer)->val[((data)->authorityCertIssuer)->len-1]);
    5080           0 : ((data)->authorityCertIssuer)->len--;
    5081             : }
    5082           0 : free(((data)->authorityCertIssuer)->val);
    5083           0 : ((data)->authorityCertIssuer)->val = NULL;
    5084           0 : free((data)->authorityCertIssuer);
    5085           0 : (data)->authorityCertIssuer = NULL;
    5086             : }
    5087         186 : if((data)->authorityCertSerialNumber) {
    5088           0 : der_free_heim_integer((data)->authorityCertSerialNumber);
    5089           0 : free((data)->authorityCertSerialNumber);
    5090           0 : (data)->authorityCertSerialNumber = NULL;
    5091             : }
    5092         186 : }
    5093             : 
    5094             : size_t ASN1CALL
    5095           0 : length_AuthorityKeyIdentifier(const AuthorityKeyIdentifier *data)
    5096             : {
    5097           0 : size_t ret = 0;
    5098           0 : if((data)->keyIdentifier){
    5099           0 : size_t Top_tag_oldret = ret;
    5100           0 : ret = 0;
    5101           0 : ret += der_length_octet_string((data)->keyIdentifier);
    5102           0 : ret += 1 + der_length_len (ret);
    5103           0 : ret += Top_tag_oldret;
    5104             : }
    5105           0 : if((data)->authorityCertIssuer){
    5106           0 : size_t Top_tag_oldret = ret;
    5107           0 : ret = 0;
    5108             : {
    5109           0 : size_t authorityCertIssuer_tag_oldret = ret;
    5110             : int i;
    5111           0 : ret = 0;
    5112           0 : for(i = ((data)->authorityCertIssuer)->len - 1; i >= 0; --i){
    5113           0 : size_t authorityCertIssuer_tag_for_oldret = ret;
    5114           0 : ret = 0;
    5115           0 : ret += length_GeneralName(&((data)->authorityCertIssuer)->val[i]);
    5116           0 : ret += authorityCertIssuer_tag_for_oldret;
    5117             : }
    5118           0 : ret += authorityCertIssuer_tag_oldret;
    5119             : }
    5120           0 : ret += 1 + der_length_len (ret);
    5121           0 : ret += Top_tag_oldret;
    5122             : }
    5123           0 : if((data)->authorityCertSerialNumber){
    5124           0 : size_t Top_tag_oldret = ret;
    5125           0 : ret = 0;
    5126           0 : ret += der_length_heim_integer((data)->authorityCertSerialNumber);
    5127           0 : ret += 1 + der_length_len (ret);
    5128           0 : ret += Top_tag_oldret;
    5129             : }
    5130           0 : ret += 1 + der_length_len (ret);
    5131           0 : return ret;
    5132             : }
    5133             : 
    5134             : int ASN1CALL
    5135           0 : copy_AuthorityKeyIdentifier(const AuthorityKeyIdentifier *from, AuthorityKeyIdentifier *to)
    5136             : {
    5137           0 : memset(to, 0, sizeof(*to));
    5138           0 : if((from)->keyIdentifier) {
    5139           0 : (to)->keyIdentifier = malloc(sizeof(*(to)->keyIdentifier));
    5140           0 : if((to)->keyIdentifier == NULL) goto fail;
    5141           0 : if(der_copy_octet_string((from)->keyIdentifier, (to)->keyIdentifier)) goto fail;
    5142             : }else
    5143           0 : (to)->keyIdentifier = NULL;
    5144           0 : if((from)->authorityCertIssuer) {
    5145           0 : (to)->authorityCertIssuer = malloc(sizeof(*(to)->authorityCertIssuer));
    5146           0 : if((to)->authorityCertIssuer == NULL) goto fail;
    5147           0 : if((((to)->authorityCertIssuer)->val = malloc(((from)->authorityCertIssuer)->len * sizeof(*((to)->authorityCertIssuer)->val))) == NULL && ((from)->authorityCertIssuer)->len != 0)
    5148           0 : goto fail;
    5149           0 : for(((to)->authorityCertIssuer)->len = 0; ((to)->authorityCertIssuer)->len < ((from)->authorityCertIssuer)->len; ((to)->authorityCertIssuer)->len++){
    5150           0 : if(copy_GeneralName(&((from)->authorityCertIssuer)->val[((to)->authorityCertIssuer)->len], &((to)->authorityCertIssuer)->val[((to)->authorityCertIssuer)->len])) goto fail;
    5151             : }
    5152             : }else
    5153           0 : (to)->authorityCertIssuer = NULL;
    5154           0 : if((from)->authorityCertSerialNumber) {
    5155           0 : (to)->authorityCertSerialNumber = malloc(sizeof(*(to)->authorityCertSerialNumber));
    5156           0 : if((to)->authorityCertSerialNumber == NULL) goto fail;
    5157           0 : if(der_copy_heim_integer((from)->authorityCertSerialNumber, (to)->authorityCertSerialNumber)) goto fail;
    5158             : }else
    5159           0 : (to)->authorityCertSerialNumber = NULL;
    5160           0 : return 0;
    5161           0 : fail:
    5162           0 : free_AuthorityKeyIdentifier(to);
    5163           0 : return ENOMEM;
    5164             : }
    5165             : 
    5166             : static unsigned oid_id_x509_ce_subjectKeyIdentifier_variable_num[4] =  {2, 5, 29, 14 };
    5167             : const heim_oid asn1_oid_id_x509_ce_subjectKeyIdentifier = { 4, oid_id_x509_ce_subjectKeyIdentifier_variable_num };
    5168             : 
    5169             : int ASN1CALL
    5170          66 : encode_SubjectKeyIdentifier(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const SubjectKeyIdentifier *data, size_t *size)
    5171             : {
    5172          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    5173             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5174             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    5175             : 
    5176          66 : e = encode_KeyIdentifier(p, len, data, &l);
    5177          66 : if (e) return e;
    5178          66 : p -= l; len -= l; ret += l;
    5179             : 
    5180          66 : *size = ret;
    5181          66 : return 0;
    5182             : }
    5183             : 
    5184             : int ASN1CALL
    5185         246 : decode_SubjectKeyIdentifier(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, SubjectKeyIdentifier *data, size_t *size)
    5186             : {
    5187         246 : size_t ret = 0;
    5188             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5189             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    5190             : 
    5191         246 : memset(data, 0, sizeof(*data));
    5192         246 : e = decode_KeyIdentifier(p, len, data, &l);
    5193         246 : if(e) goto fail;
    5194         246 : p += l; len -= l; ret += l;
    5195         246 : if(size) *size = ret;
    5196         246 : return 0;
    5197           0 : fail:
    5198           0 : free_SubjectKeyIdentifier(data);
    5199           0 : return e;
    5200             : }
    5201             : 
    5202             : void ASN1CALL
    5203         246 : free_SubjectKeyIdentifier(SubjectKeyIdentifier *data)
    5204             : {
    5205         246 : free_KeyIdentifier(data);
    5206         246 : }
    5207             : 
    5208             : size_t ASN1CALL
    5209         132 : length_SubjectKeyIdentifier(const SubjectKeyIdentifier *data)
    5210             : {
    5211         132 : size_t ret = 0;
    5212         132 : ret += length_KeyIdentifier(data);
    5213         132 : return ret;
    5214             : }
    5215             : 
    5216             : int ASN1CALL
    5217           0 : copy_SubjectKeyIdentifier(const SubjectKeyIdentifier *from, SubjectKeyIdentifier *to)
    5218             : {
    5219           0 : memset(to, 0, sizeof(*to));
    5220           0 : if(copy_KeyIdentifier(from, to)) goto fail;
    5221           0 : return 0;
    5222           0 : fail:
    5223           0 : free_SubjectKeyIdentifier(to);
    5224           0 : return ENOMEM;
    5225             : }
    5226             : 
    5227             : static unsigned oid_id_x509_ce_basicConstraints_variable_num[4] =  {2, 5, 29, 19 };
    5228             : const heim_oid asn1_oid_id_x509_ce_basicConstraints = { 4, oid_id_x509_ce_basicConstraints_variable_num };
    5229             : 
    5230             : int ASN1CALL
    5231           0 : encode_BasicConstraints(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const BasicConstraints *data, size_t *size)
    5232             : {
    5233           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    5234             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5235             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    5236             : 
    5237             : /* pathLenConstraint */
    5238           0 : if((data)->pathLenConstraint) {
    5239           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    5240           0 : ret = 0;
    5241           0 : e = der_put_unsigned(p, len, (data)->pathLenConstraint, &l);
    5242           0 : if (e) return e;
    5243           0 : p -= l; len -= l; ret += l;
    5244             : 
    5245           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    5246           0 : if (e) return e;
    5247           0 : p -= l; len -= l; ret += l;
    5248             : 
    5249           0 : ret += Top_tag_oldret;
    5250             : }
    5251             : /* cA */
    5252           0 : if((data)->cA) {
    5253           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    5254           0 : ret = 0;
    5255           0 : e = der_put_boolean(p, len, (data)->cA, &l);
    5256           0 : if (e) return e;
    5257           0 : p -= l; len -= l; ret += l;
    5258             : 
    5259           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Boolean, &l);
    5260           0 : if (e) return e;
    5261           0 : p -= l; len -= l; ret += l;
    5262             : 
    5263           0 : ret += Top_tag_oldret;
    5264             : }
    5265           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    5266           0 : if (e) return e;
    5267           0 : p -= l; len -= l; ret += l;
    5268             : 
    5269           0 : *size = ret;
    5270           0 : return 0;
    5271             : }
    5272             : 
    5273             : int ASN1CALL
    5274         120 : decode_BasicConstraints(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, BasicConstraints *data, size_t *size)
    5275             : {
    5276         120 : size_t ret = 0;
    5277             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5278             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    5279             : 
    5280         120 : memset(data, 0, sizeof(*data));
    5281             : {
    5282             : size_t Top_datalen, Top_oldlen;
    5283             : Der_type Top_type;
    5284         120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    5285         120 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    5286         120 : if(e) goto fail;
    5287         120 : p += l; len -= l; ret += l;
    5288         120 : Top_oldlen = len;
    5289         120 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5290         120 : len = Top_datalen;
    5291             : {
    5292             : size_t cA_datalen, cA_oldlen;
    5293             : Der_type cA_type;
    5294         120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &cA_type, UT_Boolean, &cA_datalen, &l);
    5295         120 : if (e == 0 && cA_type != PRIM) { e = ASN1_BAD_ID; }
    5296         120 : if(e) {
    5297          60 : (data)->cA = NULL;
    5298             : } else {
    5299          60 : (data)->cA = calloc(1, sizeof(*(data)->cA));
    5300          60 : if ((data)->cA == NULL) { e = ENOMEM; goto fail; }
    5301          60 : p += l; len -= l; ret += l;
    5302          60 : cA_oldlen = len;
    5303          60 : if (cA_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5304          60 : len = cA_datalen;
    5305          60 : e = der_get_boolean(p, len, (data)->cA, &l);
    5306          60 : if(e) goto fail;
    5307          60 : p += l; len -= l; ret += l;
    5308          60 : len = cA_oldlen - cA_datalen;
    5309             : }
    5310             : }
    5311             : {
    5312             : size_t pathLenConstraint_datalen, pathLenConstraint_oldlen;
    5313             : Der_type pathLenConstraint_type;
    5314         120 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &pathLenConstraint_type, UT_Integer, &pathLenConstraint_datalen, &l);
    5315         120 : if (e == 0 && pathLenConstraint_type != PRIM) { e = ASN1_BAD_ID; }
    5316         120 : if(e) {
    5317         120 : (data)->pathLenConstraint = NULL;
    5318             : } else {
    5319           0 : (data)->pathLenConstraint = calloc(1, sizeof(*(data)->pathLenConstraint));
    5320           0 : if ((data)->pathLenConstraint == NULL) { e = ENOMEM; goto fail; }
    5321           0 : p += l; len -= l; ret += l;
    5322           0 : pathLenConstraint_oldlen = len;
    5323           0 : if (pathLenConstraint_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5324           0 : len = pathLenConstraint_datalen;
    5325           0 : e = der_get_unsigned(p, len, (data)->pathLenConstraint, &l);
    5326           0 : if(e) goto fail;
    5327           0 : p += l; len -= l; ret += l;
    5328           0 : len = pathLenConstraint_oldlen - pathLenConstraint_datalen;
    5329             : }
    5330             : }
    5331         120 : len = Top_oldlen - Top_datalen;
    5332             : }
    5333         240 : if(size) *size = ret;
    5334         120 : return 0;
    5335           0 : fail:
    5336           0 : free_BasicConstraints(data);
    5337           0 : return e;
    5338             : }
    5339             : 
    5340             : void ASN1CALL
    5341         120 : free_BasicConstraints(BasicConstraints *data)
    5342             : {
    5343         120 : if((data)->cA) {
    5344          60 : free((data)->cA);
    5345          60 : (data)->cA = NULL;
    5346             : }
    5347         120 : if((data)->pathLenConstraint) {
    5348           0 : free((data)->pathLenConstraint);
    5349           0 : (data)->pathLenConstraint = NULL;
    5350             : }
    5351         120 : }
    5352             : 
    5353             : size_t ASN1CALL
    5354           0 : length_BasicConstraints(const BasicConstraints *data)
    5355             : {
    5356           0 : size_t ret = 0;
    5357           0 : if((data)->cA){
    5358           0 : size_t Top_tag_oldret = ret;
    5359           0 : ret = 0;
    5360           0 : ret += 1;
    5361           0 : ret += 1 + der_length_len (ret);
    5362           0 : ret += Top_tag_oldret;
    5363             : }
    5364           0 : if((data)->pathLenConstraint){
    5365           0 : size_t Top_tag_oldret = ret;
    5366           0 : ret = 0;
    5367           0 : ret += der_length_unsigned((data)->pathLenConstraint);
    5368           0 : ret += 1 + der_length_len (ret);
    5369           0 : ret += Top_tag_oldret;
    5370             : }
    5371           0 : ret += 1 + der_length_len (ret);
    5372           0 : return ret;
    5373             : }
    5374             : 
    5375             : int ASN1CALL
    5376           0 : copy_BasicConstraints(const BasicConstraints *from, BasicConstraints *to)
    5377             : {
    5378           0 : memset(to, 0, sizeof(*to));
    5379           0 : if((from)->cA) {
    5380           0 : (to)->cA = malloc(sizeof(*(to)->cA));
    5381           0 : if((to)->cA == NULL) goto fail;
    5382           0 : *((to)->cA) = *((from)->cA);
    5383             : }else
    5384           0 : (to)->cA = NULL;
    5385           0 : if((from)->pathLenConstraint) {
    5386           0 : (to)->pathLenConstraint = malloc(sizeof(*(to)->pathLenConstraint));
    5387           0 : if((to)->pathLenConstraint == NULL) goto fail;
    5388           0 : *((to)->pathLenConstraint) = *((from)->pathLenConstraint);
    5389             : }else
    5390           0 : (to)->pathLenConstraint = NULL;
    5391           0 : return 0;
    5392           0 : fail:
    5393           0 : free_BasicConstraints(to);
    5394           0 : return ENOMEM;
    5395             : }
    5396             : 
    5397             : static unsigned oid_id_x509_ce_nameConstraints_variable_num[4] =  {2, 5, 29, 30 };
    5398             : const heim_oid asn1_oid_id_x509_ce_nameConstraints = { 4, oid_id_x509_ce_nameConstraints_variable_num };
    5399             : 
    5400             : int ASN1CALL
    5401           0 : encode_BaseDistance(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const BaseDistance *data, size_t *size)
    5402             : {
    5403           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    5404             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5405             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    5406             : 
    5407           0 : e = der_put_heim_integer(p, len, data, &l);
    5408           0 : if (e) return e;
    5409           0 : p -= l; len -= l; ret += l;
    5410             : 
    5411           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    5412           0 : if (e) return e;
    5413           0 : p -= l; len -= l; ret += l;
    5414             : 
    5415           0 : *size = ret;
    5416           0 : return 0;
    5417             : }
    5418             : 
    5419             : int ASN1CALL
    5420           0 : decode_BaseDistance(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, BaseDistance *data, size_t *size)
    5421             : {
    5422           0 : size_t ret = 0;
    5423             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5424             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    5425             : 
    5426           0 : memset(data, 0, sizeof(*data));
    5427             : {
    5428             : size_t Top_datalen, Top_oldlen;
    5429             : Der_type Top_type;
    5430           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
    5431           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    5432           0 : if(e) goto fail;
    5433           0 : p += l; len -= l; ret += l;
    5434           0 : Top_oldlen = len;
    5435           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5436           0 : len = Top_datalen;
    5437           0 : e = der_get_heim_integer(p, len, data, &l);
    5438           0 : if(e) goto fail;
    5439           0 : p += l; len -= l; ret += l;
    5440           0 : len = Top_oldlen - Top_datalen;
    5441             : }
    5442           0 : if(size) *size = ret;
    5443           0 : return 0;
    5444           0 : fail:
    5445           0 : free_BaseDistance(data);
    5446           0 : return e;
    5447             : }
    5448             : 
    5449             : void ASN1CALL
    5450           0 : free_BaseDistance(BaseDistance *data)
    5451             : {
    5452           0 : der_free_heim_integer(data);
    5453           0 : }
    5454             : 
    5455             : size_t ASN1CALL
    5456           0 : length_BaseDistance(const BaseDistance *data)
    5457             : {
    5458           0 : size_t ret = 0;
    5459           0 : ret += der_length_heim_integer(data);
    5460           0 : ret += 1 + der_length_len (ret);
    5461           0 : return ret;
    5462             : }
    5463             : 
    5464             : int ASN1CALL
    5465           0 : copy_BaseDistance(const BaseDistance *from, BaseDistance *to)
    5466             : {
    5467           0 : memset(to, 0, sizeof(*to));
    5468           0 : if(der_copy_heim_integer(from, to)) goto fail;
    5469           0 : return 0;
    5470           0 : fail:
    5471           0 : free_BaseDistance(to);
    5472           0 : return ENOMEM;
    5473             : }
    5474             : 
    5475             : int ASN1CALL
    5476           0 : encode_GeneralSubtree(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GeneralSubtree *data, size_t *size)
    5477             : {
    5478           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    5479             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5480             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    5481             : 
    5482             : /* maximum */
    5483           0 : if((data)->maximum) {
    5484           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    5485           0 : ret = 0;
    5486           0 : e = der_put_heim_integer(p, len, (data)->maximum, &l);
    5487           0 : if (e) return e;
    5488           0 : p -= l; len -= l; ret += l;
    5489             : 
    5490           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 1, &l);
    5491           0 : if (e) return e;
    5492           0 : p -= l; len -= l; ret += l;
    5493             : 
    5494           0 : ret += Top_tag_oldret;
    5495             : }
    5496             : /* minimum */
    5497           0 : if((data)->minimum) {
    5498           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    5499           0 : ret = 0;
    5500           0 : e = der_put_heim_integer(p, len, (data)->minimum, &l);
    5501           0 : if (e) return e;
    5502           0 : p -= l; len -= l; ret += l;
    5503             : 
    5504           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, PRIM, 0, &l);
    5505           0 : if (e) return e;
    5506           0 : p -= l; len -= l; ret += l;
    5507             : 
    5508           0 : ret += Top_tag_oldret;
    5509             : }
    5510             : /* base */
    5511             : {
    5512           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    5513           0 : ret = 0;
    5514           0 : e = encode_GeneralName(p, len, &(data)->base, &l);
    5515           0 : if (e) return e;
    5516           0 : p -= l; len -= l; ret += l;
    5517             : 
    5518           0 : ret += Top_tag_oldret;
    5519             : }
    5520           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    5521           0 : if (e) return e;
    5522           0 : p -= l; len -= l; ret += l;
    5523             : 
    5524           0 : *size = ret;
    5525           0 : return 0;
    5526             : }
    5527             : 
    5528             : int ASN1CALL
    5529           0 : decode_GeneralSubtree(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GeneralSubtree *data, size_t *size)
    5530             : {
    5531           0 : size_t ret = 0;
    5532             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5533             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    5534             : 
    5535           0 : memset(data, 0, sizeof(*data));
    5536             : {
    5537             : size_t Top_datalen, Top_oldlen;
    5538             : Der_type Top_type;
    5539           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    5540           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    5541           0 : if(e) goto fail;
    5542           0 : p += l; len -= l; ret += l;
    5543           0 : Top_oldlen = len;
    5544           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5545           0 : len = Top_datalen;
    5546           0 : e = decode_GeneralName(p, len, &(data)->base, &l);
    5547           0 : if(e) goto fail;
    5548           0 : p += l; len -= l; ret += l;
    5549             : {
    5550             : size_t minimum_datalen, minimum_oldlen;
    5551             : Der_type minimum_type;
    5552           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &minimum_type, 0, &minimum_datalen, &l);
    5553           0 : if (e == 0 && minimum_type != PRIM) { e = ASN1_BAD_ID; }
    5554           0 : if(e) {
    5555           0 : (data)->minimum = NULL;
    5556             : } else {
    5557           0 : (data)->minimum = calloc(1, sizeof(*(data)->minimum));
    5558           0 : if ((data)->minimum == NULL) { e = ENOMEM; goto fail; }
    5559           0 : p += l; len -= l; ret += l;
    5560           0 : minimum_oldlen = len;
    5561           0 : if (minimum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5562           0 : len = minimum_datalen;
    5563           0 : e = der_get_heim_integer(p, len, (data)->minimum, &l);
    5564           0 : if(e) goto fail;
    5565           0 : p += l; len -= l; ret += l;
    5566           0 : len = minimum_oldlen - minimum_datalen;
    5567             : }
    5568             : }
    5569             : {
    5570             : size_t maximum_datalen, maximum_oldlen;
    5571             : Der_type maximum_type;
    5572           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &maximum_type, 1, &maximum_datalen, &l);
    5573           0 : if (e == 0 && maximum_type != PRIM) { e = ASN1_BAD_ID; }
    5574           0 : if(e) {
    5575           0 : (data)->maximum = NULL;
    5576             : } else {
    5577           0 : (data)->maximum = calloc(1, sizeof(*(data)->maximum));
    5578           0 : if ((data)->maximum == NULL) { e = ENOMEM; goto fail; }
    5579           0 : p += l; len -= l; ret += l;
    5580           0 : maximum_oldlen = len;
    5581           0 : if (maximum_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5582           0 : len = maximum_datalen;
    5583           0 : e = der_get_heim_integer(p, len, (data)->maximum, &l);
    5584           0 : if(e) goto fail;
    5585           0 : p += l; len -= l; ret += l;
    5586           0 : len = maximum_oldlen - maximum_datalen;
    5587             : }
    5588             : }
    5589           0 : len = Top_oldlen - Top_datalen;
    5590             : }
    5591           0 : if(size) *size = ret;
    5592           0 : return 0;
    5593           0 : fail:
    5594           0 : free_GeneralSubtree(data);
    5595           0 : return e;
    5596             : }
    5597             : 
    5598             : void ASN1CALL
    5599           0 : free_GeneralSubtree(GeneralSubtree *data)
    5600             : {
    5601           0 : free_GeneralName(&(data)->base);
    5602           0 : if((data)->minimum) {
    5603           0 : der_free_heim_integer((data)->minimum);
    5604           0 : free((data)->minimum);
    5605           0 : (data)->minimum = NULL;
    5606             : }
    5607           0 : if((data)->maximum) {
    5608           0 : der_free_heim_integer((data)->maximum);
    5609           0 : free((data)->maximum);
    5610           0 : (data)->maximum = NULL;
    5611             : }
    5612           0 : }
    5613             : 
    5614             : size_t ASN1CALL
    5615           0 : length_GeneralSubtree(const GeneralSubtree *data)
    5616             : {
    5617           0 : size_t ret = 0;
    5618             : {
    5619           0 : size_t Top_tag_oldret = ret;
    5620           0 : ret = 0;
    5621           0 : ret += length_GeneralName(&(data)->base);
    5622           0 : ret += Top_tag_oldret;
    5623             : }
    5624           0 : if((data)->minimum){
    5625           0 : size_t Top_tag_oldret = ret;
    5626           0 : ret = 0;
    5627           0 : ret += der_length_heim_integer((data)->minimum);
    5628           0 : ret += 1 + der_length_len (ret);
    5629           0 : ret += Top_tag_oldret;
    5630             : }
    5631           0 : if((data)->maximum){
    5632           0 : size_t Top_tag_oldret = ret;
    5633           0 : ret = 0;
    5634           0 : ret += der_length_heim_integer((data)->maximum);
    5635           0 : ret += 1 + der_length_len (ret);
    5636           0 : ret += Top_tag_oldret;
    5637             : }
    5638           0 : ret += 1 + der_length_len (ret);
    5639           0 : return ret;
    5640             : }
    5641             : 
    5642             : int ASN1CALL
    5643           0 : copy_GeneralSubtree(const GeneralSubtree *from, GeneralSubtree *to)
    5644             : {
    5645           0 : memset(to, 0, sizeof(*to));
    5646           0 : if(copy_GeneralName(&(from)->base, &(to)->base)) goto fail;
    5647           0 : if((from)->minimum) {
    5648           0 : (to)->minimum = malloc(sizeof(*(to)->minimum));
    5649           0 : if((to)->minimum == NULL) goto fail;
    5650           0 : if(der_copy_heim_integer((from)->minimum, (to)->minimum)) goto fail;
    5651             : }else
    5652           0 : (to)->minimum = NULL;
    5653           0 : if((from)->maximum) {
    5654           0 : (to)->maximum = malloc(sizeof(*(to)->maximum));
    5655           0 : if((to)->maximum == NULL) goto fail;
    5656           0 : if(der_copy_heim_integer((from)->maximum, (to)->maximum)) goto fail;
    5657             : }else
    5658           0 : (to)->maximum = NULL;
    5659           0 : return 0;
    5660           0 : fail:
    5661           0 : free_GeneralSubtree(to);
    5662           0 : return ENOMEM;
    5663             : }
    5664             : 
    5665             : int ASN1CALL
    5666           0 : encode_GeneralSubtrees(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const GeneralSubtrees *data, size_t *size)
    5667             : {
    5668           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    5669             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5670             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    5671             : 
    5672           0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    5673           0 : size_t Top_tag_for_oldret = ret;
    5674           0 : ret = 0;
    5675           0 : e = encode_GeneralSubtree(p, len, &(data)->val[i], &l);
    5676           0 : if (e) return e;
    5677           0 : p -= l; len -= l; ret += l;
    5678             : 
    5679           0 : ret += Top_tag_for_oldret;
    5680             : }
    5681           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    5682           0 : if (e) return e;
    5683           0 : p -= l; len -= l; ret += l;
    5684             : 
    5685           0 : *size = ret;
    5686           0 : return 0;
    5687             : }
    5688             : 
    5689             : int ASN1CALL
    5690           0 : decode_GeneralSubtrees(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, GeneralSubtrees *data, size_t *size)
    5691             : {
    5692           0 : size_t ret = 0;
    5693             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5694             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    5695             : 
    5696           0 : memset(data, 0, sizeof(*data));
    5697             : {
    5698             : size_t Top_datalen, Top_oldlen;
    5699             : Der_type Top_type;
    5700           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    5701           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    5702           0 : if(e) goto fail;
    5703           0 : p += l; len -= l; ret += l;
    5704           0 : Top_oldlen = len;
    5705           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5706           0 : len = Top_datalen;
    5707             : {
    5708           0 : size_t Top_Tag_origlen = len;
    5709           0 : size_t Top_Tag_oldret = ret;
    5710           0 : size_t Top_Tag_olen = 0;
    5711             : void *Top_Tag_tmp;
    5712           0 : ret = 0;
    5713           0 : (data)->len = 0;
    5714           0 : (data)->val = NULL;
    5715           0 : while(ret < Top_Tag_origlen) {
    5716           0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    5717           0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    5718           0 : Top_Tag_olen = Top_Tag_nlen;
    5719           0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    5720           0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    5721           0 : (data)->val = Top_Tag_tmp;
    5722           0 : e = decode_GeneralSubtree(p, len, &(data)->val[(data)->len], &l);
    5723           0 : if(e) goto fail;
    5724           0 : p += l; len -= l; ret += l;
    5725           0 : (data)->len++;
    5726           0 : len = Top_Tag_origlen - ret;
    5727             : }
    5728           0 : ret += Top_Tag_oldret;
    5729             : }
    5730           0 : len = Top_oldlen - Top_datalen;
    5731             : }
    5732           0 : if(size) *size = ret;
    5733           0 : return 0;
    5734           0 : fail:
    5735           0 : free_GeneralSubtrees(data);
    5736           0 : return e;
    5737             : }
    5738             : 
    5739             : void ASN1CALL
    5740           0 : free_GeneralSubtrees(GeneralSubtrees *data)
    5741             : {
    5742           0 : while((data)->len){
    5743           0 : free_GeneralSubtree(&(data)->val[(data)->len-1]);
    5744           0 : (data)->len--;
    5745             : }
    5746           0 : free((data)->val);
    5747           0 : (data)->val = NULL;
    5748           0 : }
    5749             : 
    5750             : size_t ASN1CALL
    5751           0 : length_GeneralSubtrees(const GeneralSubtrees *data)
    5752             : {
    5753           0 : size_t ret = 0;
    5754             : {
    5755           0 : size_t Top_tag_oldret = ret;
    5756             : int i;
    5757           0 : ret = 0;
    5758           0 : for(i = (data)->len - 1; i >= 0; --i){
    5759           0 : size_t Top_tag_for_oldret = ret;
    5760           0 : ret = 0;
    5761           0 : ret += length_GeneralSubtree(&(data)->val[i]);
    5762           0 : ret += Top_tag_for_oldret;
    5763             : }
    5764           0 : ret += Top_tag_oldret;
    5765             : }
    5766           0 : ret += 1 + der_length_len (ret);
    5767           0 : return ret;
    5768             : }
    5769             : 
    5770             : int ASN1CALL
    5771           0 : copy_GeneralSubtrees(const GeneralSubtrees *from, GeneralSubtrees *to)
    5772             : {
    5773           0 : memset(to, 0, sizeof(*to));
    5774           0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    5775           0 : goto fail;
    5776           0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    5777           0 : if(copy_GeneralSubtree(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    5778             : }
    5779           0 : return 0;
    5780           0 : fail:
    5781           0 : free_GeneralSubtrees(to);
    5782           0 : return ENOMEM;
    5783             : }
    5784             : 
    5785             : int ASN1CALL
    5786           0 : encode_NameConstraints(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NameConstraints *data, size_t *size)
    5787             : {
    5788           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    5789             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5790             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    5791             : 
    5792             : /* excludedSubtrees */
    5793           0 : if((data)->excludedSubtrees) {
    5794           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    5795           0 : ret = 0;
    5796           0 : for(i = (int)((data)->excludedSubtrees)->len - 1; i >= 0; --i) {
    5797           0 : size_t excludedSubtrees_tag_for_oldret = ret;
    5798           0 : ret = 0;
    5799           0 : e = encode_GeneralSubtree(p, len, &((data)->excludedSubtrees)->val[i], &l);
    5800           0 : if (e) return e;
    5801           0 : p -= l; len -= l; ret += l;
    5802             : 
    5803           0 : ret += excludedSubtrees_tag_for_oldret;
    5804             : }
    5805           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
    5806           0 : if (e) return e;
    5807           0 : p -= l; len -= l; ret += l;
    5808             : 
    5809           0 : ret += Top_tag_oldret;
    5810             : }
    5811             : /* permittedSubtrees */
    5812           0 : if((data)->permittedSubtrees) {
    5813           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    5814           0 : ret = 0;
    5815           0 : for(i = (int)((data)->permittedSubtrees)->len - 1; i >= 0; --i) {
    5816           0 : size_t permittedSubtrees_tag_for_oldret = ret;
    5817           0 : ret = 0;
    5818           0 : e = encode_GeneralSubtree(p, len, &((data)->permittedSubtrees)->val[i], &l);
    5819           0 : if (e) return e;
    5820           0 : p -= l; len -= l; ret += l;
    5821             : 
    5822           0 : ret += permittedSubtrees_tag_for_oldret;
    5823             : }
    5824           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    5825           0 : if (e) return e;
    5826           0 : p -= l; len -= l; ret += l;
    5827             : 
    5828           0 : ret += Top_tag_oldret;
    5829             : }
    5830           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    5831           0 : if (e) return e;
    5832           0 : p -= l; len -= l; ret += l;
    5833             : 
    5834           0 : *size = ret;
    5835           0 : return 0;
    5836             : }
    5837             : 
    5838             : int ASN1CALL
    5839           0 : decode_NameConstraints(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NameConstraints *data, size_t *size)
    5840             : {
    5841           0 : size_t ret = 0;
    5842             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    5843             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    5844             : 
    5845           0 : memset(data, 0, sizeof(*data));
    5846             : {
    5847             : size_t Top_datalen, Top_oldlen;
    5848             : Der_type Top_type;
    5849           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    5850           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    5851           0 : if(e) goto fail;
    5852           0 : p += l; len -= l; ret += l;
    5853           0 : Top_oldlen = len;
    5854           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5855           0 : len = Top_datalen;
    5856             : {
    5857             : size_t permittedSubtrees_datalen, permittedSubtrees_oldlen;
    5858             : Der_type permittedSubtrees_type;
    5859           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &permittedSubtrees_type, 0, &permittedSubtrees_datalen, &l);
    5860           0 : if (e == 0 && permittedSubtrees_type != CONS) { e = ASN1_BAD_ID; }
    5861           0 : if(e) {
    5862           0 : (data)->permittedSubtrees = NULL;
    5863             : } else {
    5864           0 : (data)->permittedSubtrees = calloc(1, sizeof(*(data)->permittedSubtrees));
    5865           0 : if ((data)->permittedSubtrees == NULL) { e = ENOMEM; goto fail; }
    5866           0 : p += l; len -= l; ret += l;
    5867           0 : permittedSubtrees_oldlen = len;
    5868           0 : if (permittedSubtrees_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5869           0 : len = permittedSubtrees_datalen;
    5870             : {
    5871           0 : size_t permittedSubtrees_Tag_origlen = len;
    5872           0 : size_t permittedSubtrees_Tag_oldret = ret;
    5873           0 : size_t permittedSubtrees_Tag_olen = 0;
    5874             : void *permittedSubtrees_Tag_tmp;
    5875           0 : ret = 0;
    5876           0 : ((data)->permittedSubtrees)->len = 0;
    5877           0 : ((data)->permittedSubtrees)->val = NULL;
    5878           0 : while(ret < permittedSubtrees_Tag_origlen) {
    5879           0 : size_t permittedSubtrees_Tag_nlen = permittedSubtrees_Tag_olen + sizeof(*(((data)->permittedSubtrees)->val));
    5880           0 : if (permittedSubtrees_Tag_olen > permittedSubtrees_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    5881           0 : permittedSubtrees_Tag_olen = permittedSubtrees_Tag_nlen;
    5882           0 : permittedSubtrees_Tag_tmp = realloc(((data)->permittedSubtrees)->val, permittedSubtrees_Tag_olen);
    5883           0 : if (permittedSubtrees_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    5884           0 : ((data)->permittedSubtrees)->val = permittedSubtrees_Tag_tmp;
    5885           0 : e = decode_GeneralSubtree(p, len, &((data)->permittedSubtrees)->val[((data)->permittedSubtrees)->len], &l);
    5886           0 : if(e) goto fail;
    5887           0 : p += l; len -= l; ret += l;
    5888           0 : ((data)->permittedSubtrees)->len++;
    5889           0 : len = permittedSubtrees_Tag_origlen - ret;
    5890             : }
    5891           0 : ret += permittedSubtrees_Tag_oldret;
    5892             : }
    5893           0 : len = permittedSubtrees_oldlen - permittedSubtrees_datalen;
    5894             : }
    5895             : }
    5896             : {
    5897             : size_t excludedSubtrees_datalen, excludedSubtrees_oldlen;
    5898             : Der_type excludedSubtrees_type;
    5899           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &excludedSubtrees_type, 1, &excludedSubtrees_datalen, &l);
    5900           0 : if (e == 0 && excludedSubtrees_type != CONS) { e = ASN1_BAD_ID; }
    5901           0 : if(e) {
    5902           0 : (data)->excludedSubtrees = NULL;
    5903             : } else {
    5904           0 : (data)->excludedSubtrees = calloc(1, sizeof(*(data)->excludedSubtrees));
    5905           0 : if ((data)->excludedSubtrees == NULL) { e = ENOMEM; goto fail; }
    5906           0 : p += l; len -= l; ret += l;
    5907           0 : excludedSubtrees_oldlen = len;
    5908           0 : if (excludedSubtrees_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    5909           0 : len = excludedSubtrees_datalen;
    5910             : {
    5911           0 : size_t excludedSubtrees_Tag_origlen = len;
    5912           0 : size_t excludedSubtrees_Tag_oldret = ret;
    5913           0 : size_t excludedSubtrees_Tag_olen = 0;
    5914             : void *excludedSubtrees_Tag_tmp;
    5915           0 : ret = 0;
    5916           0 : ((data)->excludedSubtrees)->len = 0;
    5917           0 : ((data)->excludedSubtrees)->val = NULL;
    5918           0 : while(ret < excludedSubtrees_Tag_origlen) {
    5919           0 : size_t excludedSubtrees_Tag_nlen = excludedSubtrees_Tag_olen + sizeof(*(((data)->excludedSubtrees)->val));
    5920           0 : if (excludedSubtrees_Tag_olen > excludedSubtrees_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    5921           0 : excludedSubtrees_Tag_olen = excludedSubtrees_Tag_nlen;
    5922           0 : excludedSubtrees_Tag_tmp = realloc(((data)->excludedSubtrees)->val, excludedSubtrees_Tag_olen);
    5923           0 : if (excludedSubtrees_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    5924           0 : ((data)->excludedSubtrees)->val = excludedSubtrees_Tag_tmp;
    5925           0 : e = decode_GeneralSubtree(p, len, &((data)->excludedSubtrees)->val[((data)->excludedSubtrees)->len], &l);
    5926           0 : if(e) goto fail;
    5927           0 : p += l; len -= l; ret += l;
    5928           0 : ((data)->excludedSubtrees)->len++;
    5929           0 : len = excludedSubtrees_Tag_origlen - ret;
    5930             : }
    5931           0 : ret += excludedSubtrees_Tag_oldret;
    5932             : }
    5933           0 : len = excludedSubtrees_oldlen - excludedSubtrees_datalen;
    5934             : }
    5935             : }
    5936           0 : len = Top_oldlen - Top_datalen;
    5937             : }
    5938           0 : if(size) *size = ret;
    5939           0 : return 0;
    5940           0 : fail:
    5941           0 : free_NameConstraints(data);
    5942           0 : return e;
    5943             : }
    5944             : 
    5945             : void ASN1CALL
    5946           0 : free_NameConstraints(NameConstraints *data)
    5947             : {
    5948           0 : if((data)->permittedSubtrees) {
    5949           0 : while(((data)->permittedSubtrees)->len){
    5950           0 : free_GeneralSubtree(&((data)->permittedSubtrees)->val[((data)->permittedSubtrees)->len-1]);
    5951           0 : ((data)->permittedSubtrees)->len--;
    5952             : }
    5953           0 : free(((data)->permittedSubtrees)->val);
    5954           0 : ((data)->permittedSubtrees)->val = NULL;
    5955           0 : free((data)->permittedSubtrees);
    5956           0 : (data)->permittedSubtrees = NULL;
    5957             : }
    5958           0 : if((data)->excludedSubtrees) {
    5959           0 : while(((data)->excludedSubtrees)->len){
    5960           0 : free_GeneralSubtree(&((data)->excludedSubtrees)->val[((data)->excludedSubtrees)->len-1]);
    5961           0 : ((data)->excludedSubtrees)->len--;
    5962             : }
    5963           0 : free(((data)->excludedSubtrees)->val);
    5964           0 : ((data)->excludedSubtrees)->val = NULL;
    5965           0 : free((data)->excludedSubtrees);
    5966           0 : (data)->excludedSubtrees = NULL;
    5967             : }
    5968           0 : }
    5969             : 
    5970             : size_t ASN1CALL
    5971           0 : length_NameConstraints(const NameConstraints *data)
    5972             : {
    5973           0 : size_t ret = 0;
    5974           0 : if((data)->permittedSubtrees){
    5975           0 : size_t Top_tag_oldret = ret;
    5976           0 : ret = 0;
    5977             : {
    5978           0 : size_t permittedSubtrees_tag_oldret = ret;
    5979             : int i;
    5980           0 : ret = 0;
    5981           0 : for(i = ((data)->permittedSubtrees)->len - 1; i >= 0; --i){
    5982           0 : size_t permittedSubtrees_tag_for_oldret = ret;
    5983           0 : ret = 0;
    5984           0 : ret += length_GeneralSubtree(&((data)->permittedSubtrees)->val[i]);
    5985           0 : ret += permittedSubtrees_tag_for_oldret;
    5986             : }
    5987           0 : ret += permittedSubtrees_tag_oldret;
    5988             : }
    5989           0 : ret += 1 + der_length_len (ret);
    5990           0 : ret += Top_tag_oldret;
    5991             : }
    5992           0 : if((data)->excludedSubtrees){
    5993           0 : size_t Top_tag_oldret = ret;
    5994           0 : ret = 0;
    5995             : {
    5996           0 : size_t excludedSubtrees_tag_oldret = ret;
    5997             : int i;
    5998           0 : ret = 0;
    5999           0 : for(i = ((data)->excludedSubtrees)->len - 1; i >= 0; --i){
    6000           0 : size_t excludedSubtrees_tag_for_oldret = ret;
    6001           0 : ret = 0;
    6002           0 : ret += length_GeneralSubtree(&((data)->excludedSubtrees)->val[i]);
    6003           0 : ret += excludedSubtrees_tag_for_oldret;
    6004             : }
    6005           0 : ret += excludedSubtrees_tag_oldret;
    6006             : }
    6007           0 : ret += 1 + der_length_len (ret);
    6008           0 : ret += Top_tag_oldret;
    6009             : }
    6010           0 : ret += 1 + der_length_len (ret);
    6011           0 : return ret;
    6012             : }
    6013             : 
    6014             : int ASN1CALL
    6015           0 : copy_NameConstraints(const NameConstraints *from, NameConstraints *to)
    6016             : {
    6017           0 : memset(to, 0, sizeof(*to));
    6018           0 : if((from)->permittedSubtrees) {
    6019           0 : (to)->permittedSubtrees = malloc(sizeof(*(to)->permittedSubtrees));
    6020           0 : if((to)->permittedSubtrees == NULL) goto fail;
    6021           0 : if((((to)->permittedSubtrees)->val = malloc(((from)->permittedSubtrees)->len * sizeof(*((to)->permittedSubtrees)->val))) == NULL && ((from)->permittedSubtrees)->len != 0)
    6022           0 : goto fail;
    6023           0 : for(((to)->permittedSubtrees)->len = 0; ((to)->permittedSubtrees)->len < ((from)->permittedSubtrees)->len; ((to)->permittedSubtrees)->len++){
    6024           0 : if(copy_GeneralSubtree(&((from)->permittedSubtrees)->val[((to)->permittedSubtrees)->len], &((to)->permittedSubtrees)->val[((to)->permittedSubtrees)->len])) goto fail;
    6025             : }
    6026             : }else
    6027           0 : (to)->permittedSubtrees = NULL;
    6028           0 : if((from)->excludedSubtrees) {
    6029           0 : (to)->excludedSubtrees = malloc(sizeof(*(to)->excludedSubtrees));
    6030           0 : if((to)->excludedSubtrees == NULL) goto fail;
    6031           0 : if((((to)->excludedSubtrees)->val = malloc(((from)->excludedSubtrees)->len * sizeof(*((to)->excludedSubtrees)->val))) == NULL && ((from)->excludedSubtrees)->len != 0)
    6032           0 : goto fail;
    6033           0 : for(((to)->excludedSubtrees)->len = 0; ((to)->excludedSubtrees)->len < ((from)->excludedSubtrees)->len; ((to)->excludedSubtrees)->len++){
    6034           0 : if(copy_GeneralSubtree(&((from)->excludedSubtrees)->val[((to)->excludedSubtrees)->len], &((to)->excludedSubtrees)->val[((to)->excludedSubtrees)->len])) goto fail;
    6035             : }
    6036             : }else
    6037           0 : (to)->excludedSubtrees = NULL;
    6038           0 : return 0;
    6039           0 : fail:
    6040           0 : free_NameConstraints(to);
    6041           0 : return ENOMEM;
    6042             : }
    6043             : 
    6044             : static unsigned oid_id_x509_ce_privateKeyUsagePeriod_variable_num[4] =  {2, 5, 29, 16 };
    6045             : const heim_oid asn1_oid_id_x509_ce_privateKeyUsagePeriod = { 4, oid_id_x509_ce_privateKeyUsagePeriod_variable_num };
    6046             : 
    6047             : static unsigned oid_id_x509_ce_certificatePolicies_variable_num[4] =  {2, 5, 29, 32 };
    6048             : const heim_oid asn1_oid_id_x509_ce_certificatePolicies = { 4, oid_id_x509_ce_certificatePolicies_variable_num };
    6049             : 
    6050             : static unsigned oid_id_x509_ce_policyMappings_variable_num[4] =  {2, 5, 29, 33 };
    6051             : const heim_oid asn1_oid_id_x509_ce_policyMappings = { 4, oid_id_x509_ce_policyMappings_variable_num };
    6052             : 
    6053             : static unsigned oid_id_x509_ce_subjectAltName_variable_num[4] =  {2, 5, 29, 17 };
    6054             : const heim_oid asn1_oid_id_x509_ce_subjectAltName = { 4, oid_id_x509_ce_subjectAltName_variable_num };
    6055             : 
    6056             : static unsigned oid_id_x509_ce_issuerAltName_variable_num[4] =  {2, 5, 29, 18 };
    6057             : const heim_oid asn1_oid_id_x509_ce_issuerAltName = { 4, oid_id_x509_ce_issuerAltName_variable_num };
    6058             : 
    6059             : static unsigned oid_id_x509_ce_subjectDirectoryAttributes_variable_num[4] =  {2, 5, 29, 9 };
    6060             : const heim_oid asn1_oid_id_x509_ce_subjectDirectoryAttributes = { 4, oid_id_x509_ce_subjectDirectoryAttributes_variable_num };
    6061             : 
    6062             : static unsigned oid_id_x509_ce_policyConstraints_variable_num[4] =  {2, 5, 29, 36 };
    6063             : const heim_oid asn1_oid_id_x509_ce_policyConstraints = { 4, oid_id_x509_ce_policyConstraints_variable_num };
    6064             : 
    6065             : static unsigned oid_id_x509_ce_extKeyUsage_variable_num[4] =  {2, 5, 29, 37 };
    6066             : const heim_oid asn1_oid_id_x509_ce_extKeyUsage = { 4, oid_id_x509_ce_extKeyUsage_variable_num };
    6067             : 
    6068             : int ASN1CALL
    6069           0 : encode_ExtKeyUsage(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ExtKeyUsage *data, size_t *size)
    6070             : {
    6071           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    6072             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6073             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    6074             : 
    6075           0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    6076           0 : size_t Top_tag_for_oldret = ret;
    6077           0 : ret = 0;
    6078           0 : e = der_put_oid(p, len, &(data)->val[i], &l);
    6079           0 : if (e) return e;
    6080           0 : p -= l; len -= l; ret += l;
    6081             : 
    6082           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
    6083           0 : if (e) return e;
    6084           0 : p -= l; len -= l; ret += l;
    6085             : 
    6086           0 : ret += Top_tag_for_oldret;
    6087             : }
    6088           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    6089           0 : if (e) return e;
    6090           0 : p -= l; len -= l; ret += l;
    6091             : 
    6092           0 : *size = ret;
    6093           0 : return 0;
    6094             : }
    6095             : 
    6096             : int ASN1CALL
    6097         154 : decode_ExtKeyUsage(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ExtKeyUsage *data, size_t *size)
    6098             : {
    6099         154 : size_t ret = 0;
    6100             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6101             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    6102             : 
    6103         154 : memset(data, 0, sizeof(*data));
    6104             : {
    6105             : size_t Top_datalen, Top_oldlen;
    6106             : Der_type Top_type;
    6107         154 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    6108         154 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    6109         154 : if(e) goto fail;
    6110         154 : p += l; len -= l; ret += l;
    6111         154 : Top_oldlen = len;
    6112         154 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6113         154 : len = Top_datalen;
    6114             : {
    6115         154 : size_t Top_Tag_origlen = len;
    6116         154 : size_t Top_Tag_oldret = ret;
    6117         154 : size_t Top_Tag_olen = 0;
    6118             : void *Top_Tag_tmp;
    6119         154 : ret = 0;
    6120         154 : (data)->len = 0;
    6121         154 : (data)->val = NULL;
    6122         680 : while(ret < Top_Tag_origlen) {
    6123         372 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    6124         372 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    6125         372 : Top_Tag_olen = Top_Tag_nlen;
    6126         372 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    6127         372 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    6128         372 : (data)->val = Top_Tag_tmp;
    6129             : {
    6130             : size_t Top_Tag_s_of_datalen, Top_Tag_s_of_oldlen;
    6131             : Der_type Top_Tag_s_of_type;
    6132         372 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_Tag_s_of_type, UT_OID, &Top_Tag_s_of_datalen, &l);
    6133         372 : if (e == 0 && Top_Tag_s_of_type != PRIM) { e = ASN1_BAD_ID; }
    6134         372 : if(e) goto fail;
    6135         372 : p += l; len -= l; ret += l;
    6136         372 : Top_Tag_s_of_oldlen = len;
    6137         372 : if (Top_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6138         372 : len = Top_Tag_s_of_datalen;
    6139         372 : e = der_get_oid(p, len, &(data)->val[(data)->len], &l);
    6140         372 : if(e) goto fail;
    6141         372 : p += l; len -= l; ret += l;
    6142         372 : len = Top_Tag_s_of_oldlen - Top_Tag_s_of_datalen;
    6143             : }
    6144         372 : (data)->len++;
    6145         372 : len = Top_Tag_origlen - ret;
    6146             : }
    6147         154 : ret += Top_Tag_oldret;
    6148             : }
    6149         154 : len = Top_oldlen - Top_datalen;
    6150             : }
    6151         308 : if(size) *size = ret;
    6152         146 : return 0;
    6153           0 : fail:
    6154           0 : free_ExtKeyUsage(data);
    6155           0 : return e;
    6156             : }
    6157             : 
    6158             : void ASN1CALL
    6159         154 : free_ExtKeyUsage(ExtKeyUsage *data)
    6160             : {
    6161         680 : while((data)->len){
    6162         372 : der_free_oid(&(data)->val[(data)->len-1]);
    6163         372 : (data)->len--;
    6164             : }
    6165         154 : free((data)->val);
    6166         154 : (data)->val = NULL;
    6167         154 : }
    6168             : 
    6169             : size_t ASN1CALL
    6170           0 : length_ExtKeyUsage(const ExtKeyUsage *data)
    6171             : {
    6172           0 : size_t ret = 0;
    6173             : {
    6174           0 : size_t Top_tag_oldret = ret;
    6175             : int i;
    6176           0 : ret = 0;
    6177           0 : for(i = (data)->len - 1; i >= 0; --i){
    6178           0 : size_t Top_tag_for_oldret = ret;
    6179           0 : ret = 0;
    6180           0 : ret += der_length_oid(&(data)->val[i]);
    6181           0 : ret += 1 + der_length_len (ret);
    6182           0 : ret += Top_tag_for_oldret;
    6183             : }
    6184           0 : ret += Top_tag_oldret;
    6185             : }
    6186           0 : ret += 1 + der_length_len (ret);
    6187           0 : return ret;
    6188             : }
    6189             : 
    6190             : int ASN1CALL
    6191           0 : copy_ExtKeyUsage(const ExtKeyUsage *from, ExtKeyUsage *to)
    6192             : {
    6193           0 : memset(to, 0, sizeof(*to));
    6194           0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    6195           0 : goto fail;
    6196           0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    6197           0 : if(der_copy_oid(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    6198             : }
    6199           0 : return 0;
    6200           0 : fail:
    6201           0 : free_ExtKeyUsage(to);
    6202           0 : return ENOMEM;
    6203             : }
    6204             : 
    6205             : static unsigned oid_id_x509_ce_cRLDistributionPoints_variable_num[4] =  {2, 5, 29, 31 };
    6206             : const heim_oid asn1_oid_id_x509_ce_cRLDistributionPoints = { 4, oid_id_x509_ce_cRLDistributionPoints_variable_num };
    6207             : 
    6208             : static unsigned oid_id_x509_ce_deltaCRLIndicator_variable_num[4] =  {2, 5, 29, 27 };
    6209             : const heim_oid asn1_oid_id_x509_ce_deltaCRLIndicator = { 4, oid_id_x509_ce_deltaCRLIndicator_variable_num };
    6210             : 
    6211             : static unsigned oid_id_x509_ce_issuingDistributionPoint_variable_num[4] =  {2, 5, 29, 28 };
    6212             : const heim_oid asn1_oid_id_x509_ce_issuingDistributionPoint = { 4, oid_id_x509_ce_issuingDistributionPoint_variable_num };
    6213             : 
    6214             : static unsigned oid_id_x509_ce_holdInstructionCode_variable_num[4] =  {2, 5, 29, 23 };
    6215             : const heim_oid asn1_oid_id_x509_ce_holdInstructionCode = { 4, oid_id_x509_ce_holdInstructionCode_variable_num };
    6216             : 
    6217             : static unsigned oid_id_x509_ce_invalidityDate_variable_num[4] =  {2, 5, 29, 24 };
    6218             : const heim_oid asn1_oid_id_x509_ce_invalidityDate = { 4, oid_id_x509_ce_invalidityDate_variable_num };
    6219             : 
    6220             : static unsigned oid_id_x509_ce_certificateIssuer_variable_num[4] =  {2, 5, 29, 29 };
    6221             : const heim_oid asn1_oid_id_x509_ce_certificateIssuer = { 4, oid_id_x509_ce_certificateIssuer_variable_num };
    6222             : 
    6223             : static unsigned oid_id_x509_ce_inhibitAnyPolicy_variable_num[4] =  {2, 5, 29, 54 };
    6224             : const heim_oid asn1_oid_id_x509_ce_inhibitAnyPolicy = { 4, oid_id_x509_ce_inhibitAnyPolicy_variable_num };
    6225             : 
    6226             : int ASN1CALL
    6227           0 : encode_DistributionPointReasonFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DistributionPointReasonFlags *data, size_t *size)
    6228             : {
    6229           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    6230             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6231             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    6232             : 
    6233             : {
    6234           0 : unsigned char c = 0;
    6235           0 : int rest = 0;
    6236           0 : int bit_set = 0;
    6237           0 : if((data)->aACompromise) {
    6238           0 : c |= 1<<7;
    6239             : }
    6240           0 : if (c != 0 || bit_set) {
    6241           0 : if (len < 1) return ASN1_OVERFLOW;
    6242           0 : *p-- = c; len--; ret++;
    6243           0 : if (!bit_set) {
    6244           0 : rest = 0;
    6245           0 : while(c) { 
    6246           0 : if (c & 1) break;
    6247           0 : c = c >> 1;
    6248           0 : rest++;
    6249             : }
    6250           0 : bit_set = 1;
    6251             : }
    6252             : }
    6253           0 : c = 0;
    6254           0 : if((data)->privilegeWithdrawn) {
    6255           0 : c |= 1<<0;
    6256             : }
    6257           0 : if((data)->certificateHold) {
    6258           0 : c |= 1<<1;
    6259             : }
    6260           0 : if((data)->cessationOfOperation) {
    6261           0 : c |= 1<<2;
    6262             : }
    6263           0 : if((data)->superseded) {
    6264           0 : c |= 1<<3;
    6265             : }
    6266           0 : if((data)->affiliationChanged) {
    6267           0 : c |= 1<<4;
    6268             : }
    6269           0 : if((data)->cACompromise) {
    6270           0 : c |= 1<<5;
    6271             : }
    6272           0 : if((data)->keyCompromise) {
    6273           0 : c |= 1<<6;
    6274             : }
    6275           0 : if((data)->unused) {
    6276           0 : c |= 1<<7;
    6277             : }
    6278           0 : if (c != 0 || bit_set) {
    6279           0 : if (len < 1) return ASN1_OVERFLOW;
    6280           0 : *p-- = c; len--; ret++;
    6281           0 : if (!bit_set) {
    6282           0 : rest = 0;
    6283           0 : if(c) { 
    6284           0 : while(c) { 
    6285           0 : if (c & 1) break;
    6286           0 : c = c >> 1;
    6287           0 : rest++;
    6288             : }
    6289             : }
    6290             : }
    6291             : }
    6292           0 : if (len < 1) return ASN1_OVERFLOW;
    6293           0 : *p-- = rest;
    6294           0 : len -= 1;
    6295           0 : ret += 1;
    6296             : }
    6297             : 
    6298           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
    6299           0 : if (e) return e;
    6300           0 : p -= l; len -= l; ret += l;
    6301             : 
    6302           0 : *size = ret;
    6303           0 : return 0;
    6304             : }
    6305             : 
    6306             : int ASN1CALL
    6307           0 : decode_DistributionPointReasonFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DistributionPointReasonFlags *data, size_t *size)
    6308             : {
    6309           0 : size_t ret = 0;
    6310             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6311             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    6312             : 
    6313           0 : memset(data, 0, sizeof(*data));
    6314             : {
    6315             : size_t Top_datalen, Top_oldlen;
    6316             : Der_type Top_type;
    6317           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
    6318           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    6319           0 : if(e) goto fail;
    6320           0 : p += l; len -= l; ret += l;
    6321           0 : Top_oldlen = len;
    6322           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6323           0 : len = Top_datalen;
    6324           0 : if (len < 1) return ASN1_OVERRUN;
    6325           0 : p++; len--; ret++;
    6326             : do {
    6327           0 : if (len < 1) break;
    6328           0 : (data)->unused = (*p >> 7) & 1;
    6329           0 : (data)->keyCompromise = (*p >> 6) & 1;
    6330           0 : (data)->cACompromise = (*p >> 5) & 1;
    6331           0 : (data)->affiliationChanged = (*p >> 4) & 1;
    6332           0 : (data)->superseded = (*p >> 3) & 1;
    6333           0 : (data)->cessationOfOperation = (*p >> 2) & 1;
    6334           0 : (data)->certificateHold = (*p >> 1) & 1;
    6335           0 : (data)->privilegeWithdrawn = (*p >> 0) & 1;
    6336           0 : p++; len--; ret++;
    6337           0 : if (len < 1) break;
    6338           0 : (data)->aACompromise = (*p >> 7) & 1;
    6339             : } while(0);
    6340           0 : p += len; ret += len;
    6341           0 : len = Top_oldlen - Top_datalen;
    6342             : }
    6343           0 : if(size) *size = ret;
    6344           0 : return 0;
    6345           0 : fail:
    6346           0 : free_DistributionPointReasonFlags(data);
    6347           0 : return e;
    6348             : }
    6349             : 
    6350             : void ASN1CALL
    6351           0 : free_DistributionPointReasonFlags(DistributionPointReasonFlags *data)
    6352             : {
    6353           0 : }
    6354             : 
    6355             : size_t ASN1CALL
    6356           0 : length_DistributionPointReasonFlags(const DistributionPointReasonFlags *data)
    6357             : {
    6358           0 : size_t ret = 0;
    6359             : do {
    6360           0 : if((data)->aACompromise) { ret += 2; break; }
    6361           0 : if((data)->privilegeWithdrawn) { ret += 1; break; }
    6362           0 : if((data)->certificateHold) { ret += 1; break; }
    6363           0 : if((data)->cessationOfOperation) { ret += 1; break; }
    6364           0 : if((data)->superseded) { ret += 1; break; }
    6365           0 : if((data)->affiliationChanged) { ret += 1; break; }
    6366           0 : if((data)->cACompromise) { ret += 1; break; }
    6367           0 : if((data)->keyCompromise) { ret += 1; break; }
    6368           0 : if((data)->unused) { ret += 1; break; }
    6369             : } while(0);
    6370           0 : ret += 1;
    6371           0 : ret += 1 + der_length_len (ret);
    6372           0 : return ret;
    6373             : }
    6374             : 
    6375             : int ASN1CALL
    6376           0 : copy_DistributionPointReasonFlags(const DistributionPointReasonFlags *from, DistributionPointReasonFlags *to)
    6377             : {
    6378           0 : memset(to, 0, sizeof(*to));
    6379           0 : *(to) = *(from);
    6380           0 : return 0;
    6381             : }
    6382             : 
    6383           0 : unsigned DistributionPointReasonFlags2int(DistributionPointReasonFlags f)
    6384             : {
    6385           0 : unsigned r = 0;
    6386           0 : if(f.unused) r |= (1U << 0);
    6387           0 : if(f.keyCompromise) r |= (1U << 1);
    6388           0 : if(f.cACompromise) r |= (1U << 2);
    6389           0 : if(f.affiliationChanged) r |= (1U << 3);
    6390           0 : if(f.superseded) r |= (1U << 4);
    6391           0 : if(f.cessationOfOperation) r |= (1U << 5);
    6392           0 : if(f.certificateHold) r |= (1U << 6);
    6393           0 : if(f.privilegeWithdrawn) r |= (1U << 7);
    6394           0 : if(f.aACompromise) r |= (1U << 8);
    6395           0 : return r;
    6396             : }
    6397             : 
    6398           0 : DistributionPointReasonFlags int2DistributionPointReasonFlags(unsigned n)
    6399             : {
    6400             :         DistributionPointReasonFlags flags;
    6401             : 
    6402           0 :         memset(&flags, 0, sizeof(flags));
    6403             : 
    6404           0 :         flags.unused = (n >> 0) & 1;
    6405           0 :         flags.keyCompromise = (n >> 1) & 1;
    6406           0 :         flags.cACompromise = (n >> 2) & 1;
    6407           0 :         flags.affiliationChanged = (n >> 3) & 1;
    6408           0 :         flags.superseded = (n >> 4) & 1;
    6409           0 :         flags.cessationOfOperation = (n >> 5) & 1;
    6410           0 :         flags.certificateHold = (n >> 6) & 1;
    6411           0 :         flags.privilegeWithdrawn = (n >> 7) & 1;
    6412           0 :         flags.aACompromise = (n >> 8) & 1;
    6413           0 :         return flags;
    6414             : }
    6415             : 
    6416             : static struct units DistributionPointReasonFlags_units[] = {
    6417             :         {"aACompromise",      1U << 8},
    6418             :         {"privilegeWithdrawn",        1U << 7},
    6419             :         {"certificateHold",   1U << 6},
    6420             :         {"cessationOfOperation",      1U << 5},
    6421             :         {"superseded",        1U << 4},
    6422             :         {"affiliationChanged",        1U << 3},
    6423             :         {"cACompromise",      1U << 2},
    6424             :         {"keyCompromise",     1U << 1},
    6425             :         {"unused",    1U << 0},
    6426             :         {NULL,  0}
    6427             : };
    6428             : 
    6429           0 : const struct units * asn1_DistributionPointReasonFlags_units(void){
    6430           0 : return DistributionPointReasonFlags_units;
    6431             : }
    6432             : 
    6433             : int ASN1CALL
    6434           0 : encode_DistributionPointName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DistributionPointName *data, size_t *size)
    6435             : {
    6436           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    6437             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6438             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    6439             : 
    6440             : 
    6441           0 : switch((data)->element) {
    6442           0 : case choice_DistributionPointName_nameRelativeToCRLIssuer: {size_t Top_oldret = ret;
    6443           0 : ret = 0;
    6444           0 : e = encode_RelativeDistinguishedName(p, len, &((data))->u.nameRelativeToCRLIssuer, &l);
    6445           0 : if (e) return e;
    6446           0 : p -= l; len -= l; ret += l;
    6447             : 
    6448           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
    6449           0 : if (e) return e;
    6450           0 : p -= l; len -= l; ret += l;
    6451             : 
    6452           0 : ret += Top_oldret;
    6453           0 : break;
    6454             : }
    6455           0 : case choice_DistributionPointName_fullName: {size_t Top_oldret = ret;
    6456           0 : ret = 0;
    6457           0 : for(i = (int)(&((data))->u.fullName)->len - 1; i >= 0; --i) {
    6458           0 : size_t fullName_tag_for_oldret = ret;
    6459           0 : ret = 0;
    6460           0 : e = encode_GeneralName(p, len, &(&((data))->u.fullName)->val[i], &l);
    6461           0 : if (e) return e;
    6462           0 : p -= l; len -= l; ret += l;
    6463             : 
    6464           0 : ret += fullName_tag_for_oldret;
    6465             : }
    6466           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    6467           0 : if (e) return e;
    6468           0 : p -= l; len -= l; ret += l;
    6469             : 
    6470           0 : ret += Top_oldret;
    6471           0 : break;
    6472             : }
    6473             : };
    6474           0 : *size = ret;
    6475           0 : return 0;
    6476             : }
    6477             : 
    6478             : int ASN1CALL
    6479           0 : decode_DistributionPointName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DistributionPointName *data, size_t *size)
    6480             : {
    6481           0 : size_t ret = 0;
    6482             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6483             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    6484             : 
    6485           0 : memset(data, 0, sizeof(*data));
    6486           0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
    6487             : {
    6488             : size_t fullName_datalen, fullName_oldlen;
    6489             : Der_type fullName_type;
    6490           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &fullName_type, 0, &fullName_datalen, &l);
    6491           0 : if (e == 0 && fullName_type != CONS) { e = ASN1_BAD_ID; }
    6492           0 : if(e) goto fail;
    6493           0 : p += l; len -= l; ret += l;
    6494           0 : fullName_oldlen = len;
    6495           0 : if (fullName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6496           0 : len = fullName_datalen;
    6497             : {
    6498           0 : size_t fullName_Tag_origlen = len;
    6499           0 : size_t fullName_Tag_oldret = ret;
    6500           0 : size_t fullName_Tag_olen = 0;
    6501             : void *fullName_Tag_tmp;
    6502           0 : ret = 0;
    6503           0 : (&(data)->u.fullName)->len = 0;
    6504           0 : (&(data)->u.fullName)->val = NULL;
    6505           0 : while(ret < fullName_Tag_origlen) {
    6506           0 : size_t fullName_Tag_nlen = fullName_Tag_olen + sizeof(*((&(data)->u.fullName)->val));
    6507           0 : if (fullName_Tag_olen > fullName_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    6508           0 : fullName_Tag_olen = fullName_Tag_nlen;
    6509           0 : fullName_Tag_tmp = realloc((&(data)->u.fullName)->val, fullName_Tag_olen);
    6510           0 : if (fullName_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    6511           0 : (&(data)->u.fullName)->val = fullName_Tag_tmp;
    6512           0 : e = decode_GeneralName(p, len, &(&(data)->u.fullName)->val[(&(data)->u.fullName)->len], &l);
    6513           0 : if(e) goto fail;
    6514           0 : p += l; len -= l; ret += l;
    6515           0 : (&(data)->u.fullName)->len++;
    6516           0 : len = fullName_Tag_origlen - ret;
    6517             : }
    6518           0 : ret += fullName_Tag_oldret;
    6519             : }
    6520           0 : if ((&(data)->u.fullName)->len < 1) {
    6521           0 : e = ASN1_MIN_CONSTRAINT; goto fail;
    6522             : }
    6523           0 : len = fullName_oldlen - fullName_datalen;
    6524             : }
    6525           0 : (data)->element = choice_DistributionPointName_fullName;
    6526             : }
    6527           0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, NULL) == 0) {
    6528             : {
    6529             : size_t nameRelativeToCRLIssuer_datalen, nameRelativeToCRLIssuer_oldlen;
    6530             : Der_type nameRelativeToCRLIssuer_type;
    6531           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &nameRelativeToCRLIssuer_type, 1, &nameRelativeToCRLIssuer_datalen, &l);
    6532           0 : if (e == 0 && nameRelativeToCRLIssuer_type != CONS) { e = ASN1_BAD_ID; }
    6533           0 : if(e) goto fail;
    6534           0 : p += l; len -= l; ret += l;
    6535           0 : nameRelativeToCRLIssuer_oldlen = len;
    6536           0 : if (nameRelativeToCRLIssuer_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6537           0 : len = nameRelativeToCRLIssuer_datalen;
    6538           0 : e = decode_RelativeDistinguishedName(p, len, &(data)->u.nameRelativeToCRLIssuer, &l);
    6539           0 : if(e) goto fail;
    6540           0 : p += l; len -= l; ret += l;
    6541           0 : len = nameRelativeToCRLIssuer_oldlen - nameRelativeToCRLIssuer_datalen;
    6542             : }
    6543           0 : (data)->element = choice_DistributionPointName_nameRelativeToCRLIssuer;
    6544             : }
    6545             : else {
    6546           0 : e = ASN1_PARSE_ERROR;
    6547           0 : goto fail;
    6548             : }
    6549           0 : if(size) *size = ret;
    6550           0 : return 0;
    6551           0 : fail:
    6552           0 : free_DistributionPointName(data);
    6553           0 : return e;
    6554             : }
    6555             : 
    6556             : void ASN1CALL
    6557           0 : free_DistributionPointName(DistributionPointName *data)
    6558             : {
    6559           0 : switch((data)->element) {
    6560           0 : case choice_DistributionPointName_fullName:
    6561           0 : while((&(data)->u.fullName)->len){
    6562           0 : free_GeneralName(&(&(data)->u.fullName)->val[(&(data)->u.fullName)->len-1]);
    6563           0 : (&(data)->u.fullName)->len--;
    6564             : }
    6565           0 : free((&(data)->u.fullName)->val);
    6566           0 : (&(data)->u.fullName)->val = NULL;
    6567           0 : break;
    6568           0 : case choice_DistributionPointName_nameRelativeToCRLIssuer:
    6569           0 : free_RelativeDistinguishedName(&(data)->u.nameRelativeToCRLIssuer);
    6570           0 : break;
    6571             : }
    6572           0 : }
    6573             : 
    6574             : size_t ASN1CALL
    6575           0 : length_DistributionPointName(const DistributionPointName *data)
    6576             : {
    6577           0 : size_t ret = 0;
    6578           0 : switch((data)->element) {
    6579           0 : case choice_DistributionPointName_fullName:
    6580             : {
    6581           0 : size_t Top_oldret = ret;
    6582           0 : ret = 0;
    6583             : {
    6584           0 : size_t fullName_tag_oldret = ret;
    6585             : int i;
    6586           0 : ret = 0;
    6587           0 : for(i = (&(data)->u.fullName)->len - 1; i >= 0; --i){
    6588           0 : size_t fullName_tag_for_oldret = ret;
    6589           0 : ret = 0;
    6590           0 : ret += length_GeneralName(&(&(data)->u.fullName)->val[i]);
    6591           0 : ret += fullName_tag_for_oldret;
    6592             : }
    6593           0 : ret += fullName_tag_oldret;
    6594             : }
    6595           0 : ret += 1 + der_length_len (ret);
    6596           0 : ret += Top_oldret;
    6597             : }
    6598           0 : break;
    6599           0 : case choice_DistributionPointName_nameRelativeToCRLIssuer:
    6600             : {
    6601           0 : size_t Top_oldret = ret;
    6602           0 : ret = 0;
    6603           0 : ret += length_RelativeDistinguishedName(&(data)->u.nameRelativeToCRLIssuer);
    6604           0 : ret += 1 + der_length_len (ret);
    6605           0 : ret += Top_oldret;
    6606             : }
    6607           0 : break;
    6608             : }
    6609           0 : return ret;
    6610             : }
    6611             : 
    6612             : int ASN1CALL
    6613           0 : copy_DistributionPointName(const DistributionPointName *from, DistributionPointName *to)
    6614             : {
    6615           0 : memset(to, 0, sizeof(*to));
    6616           0 : (to)->element = (from)->element;
    6617           0 : switch((from)->element) {
    6618           0 : case choice_DistributionPointName_fullName:
    6619           0 : if(((&(to)->u.fullName)->val = malloc((&(from)->u.fullName)->len * sizeof(*(&(to)->u.fullName)->val))) == NULL && (&(from)->u.fullName)->len != 0)
    6620           0 : goto fail;
    6621           0 : for((&(to)->u.fullName)->len = 0; (&(to)->u.fullName)->len < (&(from)->u.fullName)->len; (&(to)->u.fullName)->len++){
    6622           0 : if(copy_GeneralName(&(&(from)->u.fullName)->val[(&(to)->u.fullName)->len], &(&(to)->u.fullName)->val[(&(to)->u.fullName)->len])) goto fail;
    6623             : }
    6624           0 : break;
    6625           0 : case choice_DistributionPointName_nameRelativeToCRLIssuer:
    6626           0 : if(copy_RelativeDistinguishedName(&(from)->u.nameRelativeToCRLIssuer, &(to)->u.nameRelativeToCRLIssuer)) goto fail;
    6627           0 : break;
    6628             : }
    6629           0 : return 0;
    6630           0 : fail:
    6631           0 : free_DistributionPointName(to);
    6632           0 : return ENOMEM;
    6633             : }
    6634             : 
    6635             : int ASN1CALL
    6636           0 : encode_DistributionPoint(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DistributionPoint *data, size_t *size)
    6637             : {
    6638           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    6639             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6640             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    6641             : 
    6642             : /* cRLIssuer */
    6643           0 : if((data)->cRLIssuer) {
    6644           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    6645           0 : ret = 0;
    6646           0 : e = encode_heim_any(p, len, (data)->cRLIssuer, &l);
    6647           0 : if (e) return e;
    6648           0 : p -= l; len -= l; ret += l;
    6649             : 
    6650           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
    6651           0 : if (e) return e;
    6652           0 : p -= l; len -= l; ret += l;
    6653             : 
    6654           0 : ret += Top_tag_oldret;
    6655             : }
    6656             : /* reasons */
    6657           0 : if((data)->reasons) {
    6658           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    6659           0 : ret = 0;
    6660           0 : e = encode_heim_any(p, len, (data)->reasons, &l);
    6661           0 : if (e) return e;
    6662           0 : p -= l; len -= l; ret += l;
    6663             : 
    6664           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
    6665           0 : if (e) return e;
    6666           0 : p -= l; len -= l; ret += l;
    6667             : 
    6668           0 : ret += Top_tag_oldret;
    6669             : }
    6670             : /* distributionPoint */
    6671           0 : if((data)->distributionPoint) {
    6672           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    6673           0 : ret = 0;
    6674           0 : e = encode_heim_any(p, len, (data)->distributionPoint, &l);
    6675           0 : if (e) return e;
    6676           0 : p -= l; len -= l; ret += l;
    6677             : 
    6678           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    6679           0 : if (e) return e;
    6680           0 : p -= l; len -= l; ret += l;
    6681             : 
    6682           0 : ret += Top_tag_oldret;
    6683             : }
    6684           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    6685           0 : if (e) return e;
    6686           0 : p -= l; len -= l; ret += l;
    6687             : 
    6688           0 : *size = ret;
    6689           0 : return 0;
    6690             : }
    6691             : 
    6692             : int ASN1CALL
    6693           0 : decode_DistributionPoint(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DistributionPoint *data, size_t *size)
    6694             : {
    6695           0 : size_t ret = 0;
    6696             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6697             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    6698             : 
    6699           0 : memset(data, 0, sizeof(*data));
    6700             : {
    6701             : size_t Top_datalen, Top_oldlen;
    6702             : Der_type Top_type;
    6703           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    6704           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    6705           0 : if(e) goto fail;
    6706           0 : p += l; len -= l; ret += l;
    6707           0 : Top_oldlen = len;
    6708           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6709           0 : len = Top_datalen;
    6710             : {
    6711             : size_t distributionPoint_datalen, distributionPoint_oldlen;
    6712             : Der_type distributionPoint_type;
    6713           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &distributionPoint_type, 0, &distributionPoint_datalen, &l);
    6714           0 : if (e == 0 && distributionPoint_type != CONS) { e = ASN1_BAD_ID; }
    6715           0 : if(e) {
    6716           0 : (data)->distributionPoint = NULL;
    6717             : } else {
    6718           0 : (data)->distributionPoint = calloc(1, sizeof(*(data)->distributionPoint));
    6719           0 : if ((data)->distributionPoint == NULL) { e = ENOMEM; goto fail; }
    6720           0 : p += l; len -= l; ret += l;
    6721           0 : distributionPoint_oldlen = len;
    6722           0 : if (distributionPoint_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6723           0 : len = distributionPoint_datalen;
    6724           0 : e = decode_heim_any(p, len, (data)->distributionPoint, &l);
    6725           0 : if(e) goto fail;
    6726           0 : p += l; len -= l; ret += l;
    6727           0 : len = distributionPoint_oldlen - distributionPoint_datalen;
    6728             : }
    6729             : }
    6730             : {
    6731             : size_t reasons_datalen, reasons_oldlen;
    6732             : Der_type reasons_type;
    6733           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &reasons_type, 1, &reasons_datalen, &l);
    6734           0 : if (e == 0 && reasons_type != CONS) { e = ASN1_BAD_ID; }
    6735           0 : if(e) {
    6736           0 : (data)->reasons = NULL;
    6737             : } else {
    6738           0 : (data)->reasons = calloc(1, sizeof(*(data)->reasons));
    6739           0 : if ((data)->reasons == NULL) { e = ENOMEM; goto fail; }
    6740           0 : p += l; len -= l; ret += l;
    6741           0 : reasons_oldlen = len;
    6742           0 : if (reasons_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6743           0 : len = reasons_datalen;
    6744           0 : e = decode_heim_any(p, len, (data)->reasons, &l);
    6745           0 : if(e) goto fail;
    6746           0 : p += l; len -= l; ret += l;
    6747           0 : len = reasons_oldlen - reasons_datalen;
    6748             : }
    6749             : }
    6750             : {
    6751             : size_t cRLIssuer_datalen, cRLIssuer_oldlen;
    6752             : Der_type cRLIssuer_type;
    6753           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &cRLIssuer_type, 2, &cRLIssuer_datalen, &l);
    6754           0 : if (e == 0 && cRLIssuer_type != CONS) { e = ASN1_BAD_ID; }
    6755           0 : if(e) {
    6756           0 : (data)->cRLIssuer = NULL;
    6757             : } else {
    6758           0 : (data)->cRLIssuer = calloc(1, sizeof(*(data)->cRLIssuer));
    6759           0 : if ((data)->cRLIssuer == NULL) { e = ENOMEM; goto fail; }
    6760           0 : p += l; len -= l; ret += l;
    6761           0 : cRLIssuer_oldlen = len;
    6762           0 : if (cRLIssuer_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6763           0 : len = cRLIssuer_datalen;
    6764           0 : e = decode_heim_any(p, len, (data)->cRLIssuer, &l);
    6765           0 : if(e) goto fail;
    6766           0 : p += l; len -= l; ret += l;
    6767           0 : len = cRLIssuer_oldlen - cRLIssuer_datalen;
    6768             : }
    6769             : }
    6770           0 : len = Top_oldlen - Top_datalen;
    6771             : }
    6772           0 : if(size) *size = ret;
    6773           0 : return 0;
    6774           0 : fail:
    6775           0 : free_DistributionPoint(data);
    6776           0 : return e;
    6777             : }
    6778             : 
    6779             : void ASN1CALL
    6780           0 : free_DistributionPoint(DistributionPoint *data)
    6781             : {
    6782           0 : if((data)->distributionPoint) {
    6783           0 : free_heim_any((data)->distributionPoint);
    6784           0 : free((data)->distributionPoint);
    6785           0 : (data)->distributionPoint = NULL;
    6786             : }
    6787           0 : if((data)->reasons) {
    6788           0 : free_heim_any((data)->reasons);
    6789           0 : free((data)->reasons);
    6790           0 : (data)->reasons = NULL;
    6791             : }
    6792           0 : if((data)->cRLIssuer) {
    6793           0 : free_heim_any((data)->cRLIssuer);
    6794           0 : free((data)->cRLIssuer);
    6795           0 : (data)->cRLIssuer = NULL;
    6796             : }
    6797           0 : }
    6798             : 
    6799             : size_t ASN1CALL
    6800           0 : length_DistributionPoint(const DistributionPoint *data)
    6801             : {
    6802           0 : size_t ret = 0;
    6803           0 : if((data)->distributionPoint){
    6804           0 : size_t Top_tag_oldret = ret;
    6805           0 : ret = 0;
    6806           0 : ret += length_heim_any((data)->distributionPoint);
    6807           0 : ret += 1 + der_length_len (ret);
    6808           0 : ret += Top_tag_oldret;
    6809             : }
    6810           0 : if((data)->reasons){
    6811           0 : size_t Top_tag_oldret = ret;
    6812           0 : ret = 0;
    6813           0 : ret += length_heim_any((data)->reasons);
    6814           0 : ret += 1 + der_length_len (ret);
    6815           0 : ret += Top_tag_oldret;
    6816             : }
    6817           0 : if((data)->cRLIssuer){
    6818           0 : size_t Top_tag_oldret = ret;
    6819           0 : ret = 0;
    6820           0 : ret += length_heim_any((data)->cRLIssuer);
    6821           0 : ret += 1 + der_length_len (ret);
    6822           0 : ret += Top_tag_oldret;
    6823             : }
    6824           0 : ret += 1 + der_length_len (ret);
    6825           0 : return ret;
    6826             : }
    6827             : 
    6828             : int ASN1CALL
    6829           0 : copy_DistributionPoint(const DistributionPoint *from, DistributionPoint *to)
    6830             : {
    6831           0 : memset(to, 0, sizeof(*to));
    6832           0 : if((from)->distributionPoint) {
    6833           0 : (to)->distributionPoint = malloc(sizeof(*(to)->distributionPoint));
    6834           0 : if((to)->distributionPoint == NULL) goto fail;
    6835           0 : if(copy_heim_any((from)->distributionPoint, (to)->distributionPoint)) goto fail;
    6836             : }else
    6837           0 : (to)->distributionPoint = NULL;
    6838           0 : if((from)->reasons) {
    6839           0 : (to)->reasons = malloc(sizeof(*(to)->reasons));
    6840           0 : if((to)->reasons == NULL) goto fail;
    6841           0 : if(copy_heim_any((from)->reasons, (to)->reasons)) goto fail;
    6842             : }else
    6843           0 : (to)->reasons = NULL;
    6844           0 : if((from)->cRLIssuer) {
    6845           0 : (to)->cRLIssuer = malloc(sizeof(*(to)->cRLIssuer));
    6846           0 : if((to)->cRLIssuer == NULL) goto fail;
    6847           0 : if(copy_heim_any((from)->cRLIssuer, (to)->cRLIssuer)) goto fail;
    6848             : }else
    6849           0 : (to)->cRLIssuer = NULL;
    6850           0 : return 0;
    6851           0 : fail:
    6852           0 : free_DistributionPoint(to);
    6853           0 : return ENOMEM;
    6854             : }
    6855             : 
    6856             : int ASN1CALL
    6857           0 : encode_CRLDistributionPoints(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CRLDistributionPoints *data, size_t *size)
    6858             : {
    6859           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    6860             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6861             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    6862             : 
    6863           0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    6864           0 : size_t Top_tag_for_oldret = ret;
    6865           0 : ret = 0;
    6866           0 : e = encode_DistributionPoint(p, len, &(data)->val[i], &l);
    6867           0 : if (e) return e;
    6868           0 : p -= l; len -= l; ret += l;
    6869             : 
    6870           0 : ret += Top_tag_for_oldret;
    6871             : }
    6872           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    6873           0 : if (e) return e;
    6874           0 : p -= l; len -= l; ret += l;
    6875             : 
    6876           0 : *size = ret;
    6877           0 : return 0;
    6878             : }
    6879             : 
    6880             : int ASN1CALL
    6881           0 : decode_CRLDistributionPoints(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CRLDistributionPoints *data, size_t *size)
    6882             : {
    6883           0 : size_t ret = 0;
    6884             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    6885             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    6886             : 
    6887           0 : memset(data, 0, sizeof(*data));
    6888             : {
    6889             : size_t Top_datalen, Top_oldlen;
    6890             : Der_type Top_type;
    6891           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    6892           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    6893           0 : if(e) goto fail;
    6894           0 : p += l; len -= l; ret += l;
    6895           0 : Top_oldlen = len;
    6896           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    6897           0 : len = Top_datalen;
    6898             : {
    6899           0 : size_t Top_Tag_origlen = len;
    6900           0 : size_t Top_Tag_oldret = ret;
    6901           0 : size_t Top_Tag_olen = 0;
    6902             : void *Top_Tag_tmp;
    6903           0 : ret = 0;
    6904           0 : (data)->len = 0;
    6905           0 : (data)->val = NULL;
    6906           0 : while(ret < Top_Tag_origlen) {
    6907           0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    6908           0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    6909           0 : Top_Tag_olen = Top_Tag_nlen;
    6910           0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    6911           0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    6912           0 : (data)->val = Top_Tag_tmp;
    6913           0 : e = decode_DistributionPoint(p, len, &(data)->val[(data)->len], &l);
    6914           0 : if(e) goto fail;
    6915           0 : p += l; len -= l; ret += l;
    6916           0 : (data)->len++;
    6917           0 : len = Top_Tag_origlen - ret;
    6918             : }
    6919           0 : ret += Top_Tag_oldret;
    6920             : }
    6921           0 : if ((data)->len < 1) {
    6922           0 : e = ASN1_MIN_CONSTRAINT; goto fail;
    6923             : }
    6924           0 : len = Top_oldlen - Top_datalen;
    6925             : }
    6926           0 : if(size) *size = ret;
    6927           0 : return 0;
    6928           0 : fail:
    6929           0 : free_CRLDistributionPoints(data);
    6930           0 : return e;
    6931             : }
    6932             : 
    6933             : void ASN1CALL
    6934           0 : free_CRLDistributionPoints(CRLDistributionPoints *data)
    6935             : {
    6936           0 : while((data)->len){
    6937           0 : free_DistributionPoint(&(data)->val[(data)->len-1]);
    6938           0 : (data)->len--;
    6939             : }
    6940           0 : free((data)->val);
    6941           0 : (data)->val = NULL;
    6942           0 : }
    6943             : 
    6944             : size_t ASN1CALL
    6945           0 : length_CRLDistributionPoints(const CRLDistributionPoints *data)
    6946             : {
    6947           0 : size_t ret = 0;
    6948             : {
    6949           0 : size_t Top_tag_oldret = ret;
    6950             : int i;
    6951           0 : ret = 0;
    6952           0 : for(i = (data)->len - 1; i >= 0; --i){
    6953           0 : size_t Top_tag_for_oldret = ret;
    6954           0 : ret = 0;
    6955           0 : ret += length_DistributionPoint(&(data)->val[i]);
    6956           0 : ret += Top_tag_for_oldret;
    6957             : }
    6958           0 : ret += Top_tag_oldret;
    6959             : }
    6960           0 : ret += 1 + der_length_len (ret);
    6961           0 : return ret;
    6962             : }
    6963             : 
    6964             : int ASN1CALL
    6965           0 : copy_CRLDistributionPoints(const CRLDistributionPoints *from, CRLDistributionPoints *to)
    6966             : {
    6967           0 : memset(to, 0, sizeof(*to));
    6968           0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    6969           0 : goto fail;
    6970           0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    6971           0 : if(copy_DistributionPoint(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    6972             : }
    6973           0 : return 0;
    6974           0 : fail:
    6975           0 : free_CRLDistributionPoints(to);
    6976           0 : return ENOMEM;
    6977             : }
    6978             : 
    6979             : int ASN1CALL
    6980           0 : add_CRLDistributionPoints(CRLDistributionPoints *data, const DistributionPoint *element)
    6981             : {
    6982             : int ret;
    6983             : void *ptr;
    6984             : 
    6985           0 : ptr = realloc(data->val, 
    6986           0 :         (data->len + 1) * sizeof(data->val[0]));
    6987           0 : if (ptr == NULL) return ENOMEM;
    6988           0 : data->val = ptr;
    6989             : 
    6990           0 : ret = copy_DistributionPoint(element, &data->val[data->len]);
    6991           0 : if (ret) return ret;
    6992           0 : data->len++;
    6993           0 : return 0;
    6994             : }
    6995             : 
    6996             : int ASN1CALL
    6997           0 : remove_CRLDistributionPoints(CRLDistributionPoints *data, unsigned int element)
    6998             : {
    6999             : void *ptr;
    7000             : 
    7001           0 : if (data->len == 0 || element >= data->len)
    7002           0 :         return ASN1_OVERRUN;
    7003           0 : free_DistributionPoint(&data->val[element]);
    7004           0 : data->len--;
    7005           0 : if (element < data->len)
    7006           0 :         memmove(&data->val[element], &data->val[element + 1], 
    7007           0 :                 sizeof(data->val[0]) * data->len);
    7008           0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
    7009           0 : if (ptr != NULL || data->len == 0) data->val = ptr;
    7010           0 : return 0;
    7011             : }
    7012             : 
    7013             : int ASN1CALL
    7014           0 : encode_DSASigValue(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DSASigValue *data, size_t *size)
    7015             : {
    7016           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    7017             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7018             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    7019             : 
    7020             : /* s */
    7021             : {
    7022           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7023           0 : ret = 0;
    7024           0 : e = der_put_heim_integer(p, len, &(data)->s, &l);
    7025           0 : if (e) return e;
    7026           0 : p -= l; len -= l; ret += l;
    7027             : 
    7028           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7029           0 : if (e) return e;
    7030           0 : p -= l; len -= l; ret += l;
    7031             : 
    7032           0 : ret += Top_tag_oldret;
    7033             : }
    7034             : /* r */
    7035             : {
    7036           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7037           0 : ret = 0;
    7038           0 : e = der_put_heim_integer(p, len, &(data)->r, &l);
    7039           0 : if (e) return e;
    7040           0 : p -= l; len -= l; ret += l;
    7041             : 
    7042           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7043           0 : if (e) return e;
    7044           0 : p -= l; len -= l; ret += l;
    7045             : 
    7046           0 : ret += Top_tag_oldret;
    7047             : }
    7048           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    7049           0 : if (e) return e;
    7050           0 : p -= l; len -= l; ret += l;
    7051             : 
    7052           0 : *size = ret;
    7053           0 : return 0;
    7054             : }
    7055             : 
    7056             : int ASN1CALL
    7057           0 : decode_DSASigValue(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DSASigValue *data, size_t *size)
    7058             : {
    7059           0 : size_t ret = 0;
    7060             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7061             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    7062             : 
    7063           0 : memset(data, 0, sizeof(*data));
    7064             : {
    7065             : size_t Top_datalen, Top_oldlen;
    7066             : Der_type Top_type;
    7067           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    7068           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    7069           0 : if(e) goto fail;
    7070           0 : p += l; len -= l; ret += l;
    7071           0 : Top_oldlen = len;
    7072           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7073           0 : len = Top_datalen;
    7074             : {
    7075             : size_t r_datalen, r_oldlen;
    7076             : Der_type r_type;
    7077           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &r_type, UT_Integer, &r_datalen, &l);
    7078           0 : if (e == 0 && r_type != PRIM) { e = ASN1_BAD_ID; }
    7079           0 : if(e) goto fail;
    7080           0 : p += l; len -= l; ret += l;
    7081           0 : r_oldlen = len;
    7082           0 : if (r_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7083           0 : len = r_datalen;
    7084           0 : e = der_get_heim_integer(p, len, &(data)->r, &l);
    7085           0 : if(e) goto fail;
    7086           0 : p += l; len -= l; ret += l;
    7087           0 : len = r_oldlen - r_datalen;
    7088             : }
    7089             : {
    7090             : size_t s_datalen, s_oldlen;
    7091             : Der_type s_type;
    7092           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &s_type, UT_Integer, &s_datalen, &l);
    7093           0 : if (e == 0 && s_type != PRIM) { e = ASN1_BAD_ID; }
    7094           0 : if(e) goto fail;
    7095           0 : p += l; len -= l; ret += l;
    7096           0 : s_oldlen = len;
    7097           0 : if (s_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7098           0 : len = s_datalen;
    7099           0 : e = der_get_heim_integer(p, len, &(data)->s, &l);
    7100           0 : if(e) goto fail;
    7101           0 : p += l; len -= l; ret += l;
    7102           0 : len = s_oldlen - s_datalen;
    7103             : }
    7104           0 : len = Top_oldlen - Top_datalen;
    7105             : }
    7106           0 : if(size) *size = ret;
    7107           0 : return 0;
    7108           0 : fail:
    7109           0 : free_DSASigValue(data);
    7110           0 : return e;
    7111             : }
    7112             : 
    7113             : void ASN1CALL
    7114           0 : free_DSASigValue(DSASigValue *data)
    7115             : {
    7116           0 : der_free_heim_integer(&(data)->r);
    7117           0 : der_free_heim_integer(&(data)->s);
    7118           0 : }
    7119             : 
    7120             : size_t ASN1CALL
    7121           0 : length_DSASigValue(const DSASigValue *data)
    7122             : {
    7123           0 : size_t ret = 0;
    7124             : {
    7125           0 : size_t Top_tag_oldret = ret;
    7126           0 : ret = 0;
    7127           0 : ret += der_length_heim_integer(&(data)->r);
    7128           0 : ret += 1 + der_length_len (ret);
    7129           0 : ret += Top_tag_oldret;
    7130             : }
    7131             : {
    7132           0 : size_t Top_tag_oldret = ret;
    7133           0 : ret = 0;
    7134           0 : ret += der_length_heim_integer(&(data)->s);
    7135           0 : ret += 1 + der_length_len (ret);
    7136           0 : ret += Top_tag_oldret;
    7137             : }
    7138           0 : ret += 1 + der_length_len (ret);
    7139           0 : return ret;
    7140             : }
    7141             : 
    7142             : int ASN1CALL
    7143           0 : copy_DSASigValue(const DSASigValue *from, DSASigValue *to)
    7144             : {
    7145           0 : memset(to, 0, sizeof(*to));
    7146           0 : if(der_copy_heim_integer(&(from)->r, &(to)->r)) goto fail;
    7147           0 : if(der_copy_heim_integer(&(from)->s, &(to)->s)) goto fail;
    7148           0 : return 0;
    7149           0 : fail:
    7150           0 : free_DSASigValue(to);
    7151           0 : return ENOMEM;
    7152             : }
    7153             : 
    7154             : int ASN1CALL
    7155           0 : encode_DSAPublicKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DSAPublicKey *data, size_t *size)
    7156             : {
    7157           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    7158             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7159             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    7160             : 
    7161           0 : e = der_put_heim_integer(p, len, data, &l);
    7162           0 : if (e) return e;
    7163           0 : p -= l; len -= l; ret += l;
    7164             : 
    7165           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7166           0 : if (e) return e;
    7167           0 : p -= l; len -= l; ret += l;
    7168             : 
    7169           0 : *size = ret;
    7170           0 : return 0;
    7171             : }
    7172             : 
    7173             : int ASN1CALL
    7174           0 : decode_DSAPublicKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DSAPublicKey *data, size_t *size)
    7175             : {
    7176           0 : size_t ret = 0;
    7177             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7178             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    7179             : 
    7180           0 : memset(data, 0, sizeof(*data));
    7181             : {
    7182             : size_t Top_datalen, Top_oldlen;
    7183             : Der_type Top_type;
    7184           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Integer, &Top_datalen, &l);
    7185           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    7186           0 : if(e) goto fail;
    7187           0 : p += l; len -= l; ret += l;
    7188           0 : Top_oldlen = len;
    7189           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7190           0 : len = Top_datalen;
    7191           0 : e = der_get_heim_integer(p, len, data, &l);
    7192           0 : if(e) goto fail;
    7193           0 : p += l; len -= l; ret += l;
    7194           0 : len = Top_oldlen - Top_datalen;
    7195             : }
    7196           0 : if(size) *size = ret;
    7197           0 : return 0;
    7198           0 : fail:
    7199           0 : free_DSAPublicKey(data);
    7200           0 : return e;
    7201             : }
    7202             : 
    7203             : void ASN1CALL
    7204           0 : free_DSAPublicKey(DSAPublicKey *data)
    7205             : {
    7206           0 : der_free_heim_integer(data);
    7207           0 : }
    7208             : 
    7209             : size_t ASN1CALL
    7210           0 : length_DSAPublicKey(const DSAPublicKey *data)
    7211             : {
    7212           0 : size_t ret = 0;
    7213           0 : ret += der_length_heim_integer(data);
    7214           0 : ret += 1 + der_length_len (ret);
    7215           0 : return ret;
    7216             : }
    7217             : 
    7218             : int ASN1CALL
    7219           0 : copy_DSAPublicKey(const DSAPublicKey *from, DSAPublicKey *to)
    7220             : {
    7221           0 : memset(to, 0, sizeof(*to));
    7222           0 : if(der_copy_heim_integer(from, to)) goto fail;
    7223           0 : return 0;
    7224           0 : fail:
    7225           0 : free_DSAPublicKey(to);
    7226           0 : return ENOMEM;
    7227             : }
    7228             : 
    7229             : int ASN1CALL
    7230           0 : encode_DSAParams(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DSAParams *data, size_t *size)
    7231             : {
    7232           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    7233             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7234             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    7235             : 
    7236             : /* g */
    7237             : {
    7238           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7239           0 : ret = 0;
    7240           0 : e = der_put_heim_integer(p, len, &(data)->g, &l);
    7241           0 : if (e) return e;
    7242           0 : p -= l; len -= l; ret += l;
    7243             : 
    7244           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7245           0 : if (e) return e;
    7246           0 : p -= l; len -= l; ret += l;
    7247             : 
    7248           0 : ret += Top_tag_oldret;
    7249             : }
    7250             : /* q */
    7251             : {
    7252           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7253           0 : ret = 0;
    7254           0 : e = der_put_heim_integer(p, len, &(data)->q, &l);
    7255           0 : if (e) return e;
    7256           0 : p -= l; len -= l; ret += l;
    7257             : 
    7258           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7259           0 : if (e) return e;
    7260           0 : p -= l; len -= l; ret += l;
    7261             : 
    7262           0 : ret += Top_tag_oldret;
    7263             : }
    7264             : /* p */
    7265             : {
    7266           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7267           0 : ret = 0;
    7268           0 : e = der_put_heim_integer(p, len, &(data)->p, &l);
    7269           0 : if (e) return e;
    7270           0 : p -= l; len -= l; ret += l;
    7271             : 
    7272           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7273           0 : if (e) return e;
    7274           0 : p -= l; len -= l; ret += l;
    7275             : 
    7276           0 : ret += Top_tag_oldret;
    7277             : }
    7278           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    7279           0 : if (e) return e;
    7280           0 : p -= l; len -= l; ret += l;
    7281             : 
    7282           0 : *size = ret;
    7283           0 : return 0;
    7284             : }
    7285             : 
    7286             : int ASN1CALL
    7287           0 : decode_DSAParams(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DSAParams *data, size_t *size)
    7288             : {
    7289           0 : size_t ret = 0;
    7290             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7291             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    7292             : 
    7293           0 : memset(data, 0, sizeof(*data));
    7294             : {
    7295             : size_t Top_datalen, Top_oldlen;
    7296             : Der_type Top_type;
    7297           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    7298           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    7299           0 : if(e) goto fail;
    7300           0 : p += l; len -= l; ret += l;
    7301           0 : Top_oldlen = len;
    7302           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7303           0 : len = Top_datalen;
    7304             : {
    7305             : size_t p_datalen, p_oldlen;
    7306             : Der_type p_type;
    7307           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &p_type, UT_Integer, &p_datalen, &l);
    7308           0 : if (e == 0 && p_type != PRIM) { e = ASN1_BAD_ID; }
    7309           0 : if(e) goto fail;
    7310           0 : p += l; len -= l; ret += l;
    7311           0 : p_oldlen = len;
    7312           0 : if (p_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7313           0 : len = p_datalen;
    7314           0 : e = der_get_heim_integer(p, len, &(data)->p, &l);
    7315           0 : if(e) goto fail;
    7316           0 : p += l; len -= l; ret += l;
    7317           0 : len = p_oldlen - p_datalen;
    7318             : }
    7319             : {
    7320             : size_t q_datalen, q_oldlen;
    7321             : Der_type q_type;
    7322           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &q_type, UT_Integer, &q_datalen, &l);
    7323           0 : if (e == 0 && q_type != PRIM) { e = ASN1_BAD_ID; }
    7324           0 : if(e) goto fail;
    7325           0 : p += l; len -= l; ret += l;
    7326           0 : q_oldlen = len;
    7327           0 : if (q_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7328           0 : len = q_datalen;
    7329           0 : e = der_get_heim_integer(p, len, &(data)->q, &l);
    7330           0 : if(e) goto fail;
    7331           0 : p += l; len -= l; ret += l;
    7332           0 : len = q_oldlen - q_datalen;
    7333             : }
    7334             : {
    7335             : size_t g_datalen, g_oldlen;
    7336             : Der_type g_type;
    7337           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &g_type, UT_Integer, &g_datalen, &l);
    7338           0 : if (e == 0 && g_type != PRIM) { e = ASN1_BAD_ID; }
    7339           0 : if(e) goto fail;
    7340           0 : p += l; len -= l; ret += l;
    7341           0 : g_oldlen = len;
    7342           0 : if (g_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7343           0 : len = g_datalen;
    7344           0 : e = der_get_heim_integer(p, len, &(data)->g, &l);
    7345           0 : if(e) goto fail;
    7346           0 : p += l; len -= l; ret += l;
    7347           0 : len = g_oldlen - g_datalen;
    7348             : }
    7349           0 : len = Top_oldlen - Top_datalen;
    7350             : }
    7351           0 : if(size) *size = ret;
    7352           0 : return 0;
    7353           0 : fail:
    7354           0 : free_DSAParams(data);
    7355           0 : return e;
    7356             : }
    7357             : 
    7358             : void ASN1CALL
    7359           0 : free_DSAParams(DSAParams *data)
    7360             : {
    7361           0 : der_free_heim_integer(&(data)->p);
    7362           0 : der_free_heim_integer(&(data)->q);
    7363           0 : der_free_heim_integer(&(data)->g);
    7364           0 : }
    7365             : 
    7366             : size_t ASN1CALL
    7367           0 : length_DSAParams(const DSAParams *data)
    7368             : {
    7369           0 : size_t ret = 0;
    7370             : {
    7371           0 : size_t Top_tag_oldret = ret;
    7372           0 : ret = 0;
    7373           0 : ret += der_length_heim_integer(&(data)->p);
    7374           0 : ret += 1 + der_length_len (ret);
    7375           0 : ret += Top_tag_oldret;
    7376             : }
    7377             : {
    7378           0 : size_t Top_tag_oldret = ret;
    7379           0 : ret = 0;
    7380           0 : ret += der_length_heim_integer(&(data)->q);
    7381           0 : ret += 1 + der_length_len (ret);
    7382           0 : ret += Top_tag_oldret;
    7383             : }
    7384             : {
    7385           0 : size_t Top_tag_oldret = ret;
    7386           0 : ret = 0;
    7387           0 : ret += der_length_heim_integer(&(data)->g);
    7388           0 : ret += 1 + der_length_len (ret);
    7389           0 : ret += Top_tag_oldret;
    7390             : }
    7391           0 : ret += 1 + der_length_len (ret);
    7392           0 : return ret;
    7393             : }
    7394             : 
    7395             : int ASN1CALL
    7396           0 : copy_DSAParams(const DSAParams *from, DSAParams *to)
    7397             : {
    7398           0 : memset(to, 0, sizeof(*to));
    7399           0 : if(der_copy_heim_integer(&(from)->p, &(to)->p)) goto fail;
    7400           0 : if(der_copy_heim_integer(&(from)->q, &(to)->q)) goto fail;
    7401           0 : if(der_copy_heim_integer(&(from)->g, &(to)->g)) goto fail;
    7402           0 : return 0;
    7403           0 : fail:
    7404           0 : free_DSAParams(to);
    7405           0 : return ENOMEM;
    7406             : }
    7407             : 
    7408             : int ASN1CALL
    7409           0 : encode_ECPoint(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ECPoint *data, size_t *size)
    7410             : {
    7411           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    7412             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7413             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    7414             : 
    7415           0 : e = der_put_octet_string(p, len, data, &l);
    7416           0 : if (e) return e;
    7417           0 : p -= l; len -= l; ret += l;
    7418             : 
    7419           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
    7420           0 : if (e) return e;
    7421           0 : p -= l; len -= l; ret += l;
    7422             : 
    7423           0 : *size = ret;
    7424           0 : return 0;
    7425             : }
    7426             : 
    7427             : int ASN1CALL
    7428           0 : decode_ECPoint(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ECPoint *data, size_t *size)
    7429             : {
    7430           0 : size_t ret = 0;
    7431             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7432             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    7433             : 
    7434           0 : memset(data, 0, sizeof(*data));
    7435             : {
    7436             : size_t Top_datalen, Top_oldlen;
    7437             : Der_type Top_type;
    7438           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OctetString, &Top_datalen, &l);
    7439           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    7440           0 : if(e) goto fail;
    7441           0 : p += l; len -= l; ret += l;
    7442           0 : Top_oldlen = len;
    7443           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7444           0 : len = Top_datalen;
    7445           0 : e = der_get_octet_string(p, len, data, &l);
    7446           0 : if(e) goto fail;
    7447           0 : p += l; len -= l; ret += l;
    7448           0 : len = Top_oldlen - Top_datalen;
    7449             : }
    7450           0 : if(size) *size = ret;
    7451           0 : return 0;
    7452           0 : fail:
    7453           0 : free_ECPoint(data);
    7454           0 : return e;
    7455             : }
    7456             : 
    7457             : void ASN1CALL
    7458           0 : free_ECPoint(ECPoint *data)
    7459             : {
    7460           0 : der_free_octet_string(data);
    7461           0 : }
    7462             : 
    7463             : size_t ASN1CALL
    7464           0 : length_ECPoint(const ECPoint *data)
    7465             : {
    7466           0 : size_t ret = 0;
    7467           0 : ret += der_length_octet_string(data);
    7468           0 : ret += 1 + der_length_len (ret);
    7469           0 : return ret;
    7470             : }
    7471             : 
    7472             : int ASN1CALL
    7473           0 : copy_ECPoint(const ECPoint *from, ECPoint *to)
    7474             : {
    7475           0 : memset(to, 0, sizeof(*to));
    7476           0 : if(der_copy_octet_string(from, to)) goto fail;
    7477           0 : return 0;
    7478           0 : fail:
    7479           0 : free_ECPoint(to);
    7480           0 : return ENOMEM;
    7481             : }
    7482             : 
    7483             : int ASN1CALL
    7484           0 : encode_ECParameters(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ECParameters *data, size_t *size)
    7485             : {
    7486           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    7487             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7488             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    7489             : 
    7490             : 
    7491           0 : switch((data)->element) {
    7492           0 : case choice_ECParameters_namedCurve: {size_t Top_oldret = ret;
    7493           0 : ret = 0;
    7494           0 : e = der_put_oid(p, len, &((data))->u.namedCurve, &l);
    7495           0 : if (e) return e;
    7496           0 : p -= l; len -= l; ret += l;
    7497             : 
    7498           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
    7499           0 : if (e) return e;
    7500           0 : p -= l; len -= l; ret += l;
    7501             : 
    7502           0 : ret += Top_oldret;
    7503           0 : break;
    7504             : }
    7505             : };
    7506           0 : *size = ret;
    7507           0 : return 0;
    7508             : }
    7509             : 
    7510             : int ASN1CALL
    7511           0 : decode_ECParameters(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ECParameters *data, size_t *size)
    7512             : {
    7513           0 : size_t ret = 0;
    7514             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7515             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    7516             : 
    7517           0 : memset(data, 0, sizeof(*data));
    7518           0 : if (der_match_tag(p, len, ASN1_C_UNIV, PRIM, UT_OID, NULL) == 0) {
    7519             : {
    7520             : size_t namedCurve_datalen, namedCurve_oldlen;
    7521             : Der_type namedCurve_type;
    7522           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &namedCurve_type, UT_OID, &namedCurve_datalen, &l);
    7523           0 : if (e == 0 && namedCurve_type != PRIM) { e = ASN1_BAD_ID; }
    7524           0 : if(e) goto fail;
    7525           0 : p += l; len -= l; ret += l;
    7526           0 : namedCurve_oldlen = len;
    7527           0 : if (namedCurve_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7528           0 : len = namedCurve_datalen;
    7529           0 : e = der_get_oid(p, len, &(data)->u.namedCurve, &l);
    7530           0 : if(e) goto fail;
    7531           0 : p += l; len -= l; ret += l;
    7532           0 : len = namedCurve_oldlen - namedCurve_datalen;
    7533             : }
    7534           0 : (data)->element = choice_ECParameters_namedCurve;
    7535             : }
    7536             : else {
    7537           0 : e = ASN1_PARSE_ERROR;
    7538           0 : goto fail;
    7539             : }
    7540           0 : if(size) *size = ret;
    7541           0 : return 0;
    7542           0 : fail:
    7543           0 : free_ECParameters(data);
    7544           0 : return e;
    7545             : }
    7546             : 
    7547             : void ASN1CALL
    7548           0 : free_ECParameters(ECParameters *data)
    7549             : {
    7550           0 : switch((data)->element) {
    7551           0 : case choice_ECParameters_namedCurve:
    7552           0 : der_free_oid(&(data)->u.namedCurve);
    7553           0 : break;
    7554             : }
    7555           0 : }
    7556             : 
    7557             : size_t ASN1CALL
    7558           0 : length_ECParameters(const ECParameters *data)
    7559             : {
    7560           0 : size_t ret = 0;
    7561           0 : switch((data)->element) {
    7562           0 : case choice_ECParameters_namedCurve:
    7563             : {
    7564           0 : size_t Top_oldret = ret;
    7565           0 : ret = 0;
    7566           0 : ret += der_length_oid(&(data)->u.namedCurve);
    7567           0 : ret += 1 + der_length_len (ret);
    7568           0 : ret += Top_oldret;
    7569             : }
    7570           0 : break;
    7571             : }
    7572           0 : return ret;
    7573             : }
    7574             : 
    7575             : int ASN1CALL
    7576           0 : copy_ECParameters(const ECParameters *from, ECParameters *to)
    7577             : {
    7578           0 : memset(to, 0, sizeof(*to));
    7579           0 : (to)->element = (from)->element;
    7580           0 : switch((from)->element) {
    7581           0 : case choice_ECParameters_namedCurve:
    7582           0 : if(der_copy_oid(&(from)->u.namedCurve, &(to)->u.namedCurve)) goto fail;
    7583           0 : break;
    7584             : }
    7585           0 : return 0;
    7586           0 : fail:
    7587           0 : free_ECParameters(to);
    7588           0 : return ENOMEM;
    7589             : }
    7590             : 
    7591             : int ASN1CALL
    7592           0 : encode_ECDSA_Sig_Value(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ECDSA_Sig_Value *data, size_t *size)
    7593             : {
    7594           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    7595             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7596             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    7597             : 
    7598             : /* s */
    7599             : {
    7600           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7601           0 : ret = 0;
    7602           0 : e = der_put_heim_integer(p, len, &(data)->s, &l);
    7603           0 : if (e) return e;
    7604           0 : p -= l; len -= l; ret += l;
    7605             : 
    7606           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7607           0 : if (e) return e;
    7608           0 : p -= l; len -= l; ret += l;
    7609             : 
    7610           0 : ret += Top_tag_oldret;
    7611             : }
    7612             : /* r */
    7613             : {
    7614           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7615           0 : ret = 0;
    7616           0 : e = der_put_heim_integer(p, len, &(data)->r, &l);
    7617           0 : if (e) return e;
    7618           0 : p -= l; len -= l; ret += l;
    7619             : 
    7620           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7621           0 : if (e) return e;
    7622           0 : p -= l; len -= l; ret += l;
    7623             : 
    7624           0 : ret += Top_tag_oldret;
    7625             : }
    7626           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    7627           0 : if (e) return e;
    7628           0 : p -= l; len -= l; ret += l;
    7629             : 
    7630           0 : *size = ret;
    7631           0 : return 0;
    7632             : }
    7633             : 
    7634             : int ASN1CALL
    7635           0 : decode_ECDSA_Sig_Value(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ECDSA_Sig_Value *data, size_t *size)
    7636             : {
    7637           0 : size_t ret = 0;
    7638             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7639             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    7640             : 
    7641           0 : memset(data, 0, sizeof(*data));
    7642             : {
    7643             : size_t Top_datalen, Top_oldlen;
    7644             : Der_type Top_type;
    7645           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    7646           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    7647           0 : if(e) goto fail;
    7648           0 : p += l; len -= l; ret += l;
    7649           0 : Top_oldlen = len;
    7650           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7651           0 : len = Top_datalen;
    7652             : {
    7653             : size_t r_datalen, r_oldlen;
    7654             : Der_type r_type;
    7655           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &r_type, UT_Integer, &r_datalen, &l);
    7656           0 : if (e == 0 && r_type != PRIM) { e = ASN1_BAD_ID; }
    7657           0 : if(e) goto fail;
    7658           0 : p += l; len -= l; ret += l;
    7659           0 : r_oldlen = len;
    7660           0 : if (r_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7661           0 : len = r_datalen;
    7662           0 : e = der_get_heim_integer(p, len, &(data)->r, &l);
    7663           0 : if(e) goto fail;
    7664           0 : p += l; len -= l; ret += l;
    7665           0 : len = r_oldlen - r_datalen;
    7666             : }
    7667             : {
    7668             : size_t s_datalen, s_oldlen;
    7669             : Der_type s_type;
    7670           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &s_type, UT_Integer, &s_datalen, &l);
    7671           0 : if (e == 0 && s_type != PRIM) { e = ASN1_BAD_ID; }
    7672           0 : if(e) goto fail;
    7673           0 : p += l; len -= l; ret += l;
    7674           0 : s_oldlen = len;
    7675           0 : if (s_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7676           0 : len = s_datalen;
    7677           0 : e = der_get_heim_integer(p, len, &(data)->s, &l);
    7678           0 : if(e) goto fail;
    7679           0 : p += l; len -= l; ret += l;
    7680           0 : len = s_oldlen - s_datalen;
    7681             : }
    7682           0 : len = Top_oldlen - Top_datalen;
    7683             : }
    7684           0 : if(size) *size = ret;
    7685           0 : return 0;
    7686           0 : fail:
    7687           0 : free_ECDSA_Sig_Value(data);
    7688           0 : return e;
    7689             : }
    7690             : 
    7691             : void ASN1CALL
    7692           0 : free_ECDSA_Sig_Value(ECDSA_Sig_Value *data)
    7693             : {
    7694           0 : der_free_heim_integer(&(data)->r);
    7695           0 : der_free_heim_integer(&(data)->s);
    7696           0 : }
    7697             : 
    7698             : size_t ASN1CALL
    7699           0 : length_ECDSA_Sig_Value(const ECDSA_Sig_Value *data)
    7700             : {
    7701           0 : size_t ret = 0;
    7702             : {
    7703           0 : size_t Top_tag_oldret = ret;
    7704           0 : ret = 0;
    7705           0 : ret += der_length_heim_integer(&(data)->r);
    7706           0 : ret += 1 + der_length_len (ret);
    7707           0 : ret += Top_tag_oldret;
    7708             : }
    7709             : {
    7710           0 : size_t Top_tag_oldret = ret;
    7711           0 : ret = 0;
    7712           0 : ret += der_length_heim_integer(&(data)->s);
    7713           0 : ret += 1 + der_length_len (ret);
    7714           0 : ret += Top_tag_oldret;
    7715             : }
    7716           0 : ret += 1 + der_length_len (ret);
    7717           0 : return ret;
    7718             : }
    7719             : 
    7720             : int ASN1CALL
    7721           0 : copy_ECDSA_Sig_Value(const ECDSA_Sig_Value *from, ECDSA_Sig_Value *to)
    7722             : {
    7723           0 : memset(to, 0, sizeof(*to));
    7724           0 : if(der_copy_heim_integer(&(from)->r, &(to)->r)) goto fail;
    7725           0 : if(der_copy_heim_integer(&(from)->s, &(to)->s)) goto fail;
    7726           0 : return 0;
    7727           0 : fail:
    7728           0 : free_ECDSA_Sig_Value(to);
    7729           0 : return ENOMEM;
    7730             : }
    7731             : 
    7732             : int ASN1CALL
    7733           0 : encode_RSAPublicKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RSAPublicKey *data, size_t *size)
    7734             : {
    7735           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    7736             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7737             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    7738             : 
    7739             : /* publicExponent */
    7740             : {
    7741           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7742           0 : ret = 0;
    7743           0 : e = der_put_heim_integer(p, len, &(data)->publicExponent, &l);
    7744           0 : if (e) return e;
    7745           0 : p -= l; len -= l; ret += l;
    7746             : 
    7747           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7748           0 : if (e) return e;
    7749           0 : p -= l; len -= l; ret += l;
    7750             : 
    7751           0 : ret += Top_tag_oldret;
    7752             : }
    7753             : /* modulus */
    7754             : {
    7755           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7756           0 : ret = 0;
    7757           0 : e = der_put_heim_integer(p, len, &(data)->modulus, &l);
    7758           0 : if (e) return e;
    7759           0 : p -= l; len -= l; ret += l;
    7760             : 
    7761           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7762           0 : if (e) return e;
    7763           0 : p -= l; len -= l; ret += l;
    7764             : 
    7765           0 : ret += Top_tag_oldret;
    7766             : }
    7767           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    7768           0 : if (e) return e;
    7769           0 : p -= l; len -= l; ret += l;
    7770             : 
    7771           0 : *size = ret;
    7772           0 : return 0;
    7773             : }
    7774             : 
    7775             : int ASN1CALL
    7776         274 : decode_RSAPublicKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RSAPublicKey *data, size_t *size)
    7777             : {
    7778         274 : size_t ret = 0;
    7779             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7780             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    7781             : 
    7782         274 : memset(data, 0, sizeof(*data));
    7783             : {
    7784             : size_t Top_datalen, Top_oldlen;
    7785             : Der_type Top_type;
    7786         274 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    7787         274 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    7788         274 : if(e) goto fail;
    7789         274 : p += l; len -= l; ret += l;
    7790         274 : Top_oldlen = len;
    7791         274 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7792         274 : len = Top_datalen;
    7793             : {
    7794             : size_t modulus_datalen, modulus_oldlen;
    7795             : Der_type modulus_type;
    7796         274 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &modulus_type, UT_Integer, &modulus_datalen, &l);
    7797         274 : if (e == 0 && modulus_type != PRIM) { e = ASN1_BAD_ID; }
    7798         274 : if(e) goto fail;
    7799         274 : p += l; len -= l; ret += l;
    7800         274 : modulus_oldlen = len;
    7801         274 : if (modulus_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7802         274 : len = modulus_datalen;
    7803         274 : e = der_get_heim_integer(p, len, &(data)->modulus, &l);
    7804         274 : if(e) goto fail;
    7805         274 : p += l; len -= l; ret += l;
    7806         274 : len = modulus_oldlen - modulus_datalen;
    7807             : }
    7808             : {
    7809             : size_t publicExponent_datalen, publicExponent_oldlen;
    7810             : Der_type publicExponent_type;
    7811         274 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &publicExponent_type, UT_Integer, &publicExponent_datalen, &l);
    7812         540 : if (e == 0 && publicExponent_type != PRIM) { e = ASN1_BAD_ID; }
    7813         274 : if(e) goto fail;
    7814         274 : p += l; len -= l; ret += l;
    7815         274 : publicExponent_oldlen = len;
    7816         274 : if (publicExponent_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    7817         274 : len = publicExponent_datalen;
    7818         274 : e = der_get_heim_integer(p, len, &(data)->publicExponent, &l);
    7819         274 : if(e) goto fail;
    7820         274 : p += l; len -= l; ret += l;
    7821         274 : len = publicExponent_oldlen - publicExponent_datalen;
    7822             : }
    7823         274 : len = Top_oldlen - Top_datalen;
    7824             : }
    7825         548 : if(size) *size = ret;
    7826         266 : return 0;
    7827           0 : fail:
    7828           0 : free_RSAPublicKey(data);
    7829           0 : return e;
    7830             : }
    7831             : 
    7832             : void ASN1CALL
    7833         274 : free_RSAPublicKey(RSAPublicKey *data)
    7834             : {
    7835         274 : der_free_heim_integer(&(data)->modulus);
    7836         274 : der_free_heim_integer(&(data)->publicExponent);
    7837         274 : }
    7838             : 
    7839             : size_t ASN1CALL
    7840           0 : length_RSAPublicKey(const RSAPublicKey *data)
    7841             : {
    7842           0 : size_t ret = 0;
    7843             : {
    7844           0 : size_t Top_tag_oldret = ret;
    7845           0 : ret = 0;
    7846           0 : ret += der_length_heim_integer(&(data)->modulus);
    7847           0 : ret += 1 + der_length_len (ret);
    7848           0 : ret += Top_tag_oldret;
    7849             : }
    7850             : {
    7851           0 : size_t Top_tag_oldret = ret;
    7852           0 : ret = 0;
    7853           0 : ret += der_length_heim_integer(&(data)->publicExponent);
    7854           0 : ret += 1 + der_length_len (ret);
    7855           0 : ret += Top_tag_oldret;
    7856             : }
    7857           0 : ret += 1 + der_length_len (ret);
    7858           0 : return ret;
    7859             : }
    7860             : 
    7861             : int ASN1CALL
    7862           0 : copy_RSAPublicKey(const RSAPublicKey *from, RSAPublicKey *to)
    7863             : {
    7864           0 : memset(to, 0, sizeof(*to));
    7865           0 : if(der_copy_heim_integer(&(from)->modulus, &(to)->modulus)) goto fail;
    7866           0 : if(der_copy_heim_integer(&(from)->publicExponent, &(to)->publicExponent)) goto fail;
    7867           0 : return 0;
    7868           0 : fail:
    7869           0 : free_RSAPublicKey(to);
    7870           0 : return ENOMEM;
    7871             : }
    7872             : 
    7873             : int ASN1CALL
    7874           0 : encode_RSAPrivateKey(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const RSAPrivateKey *data, size_t *size)
    7875             : {
    7876           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    7877             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    7878             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    7879             : 
    7880             : /* coefficient */
    7881             : {
    7882           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7883           0 : ret = 0;
    7884           0 : e = der_put_heim_integer(p, len, &(data)->coefficient, &l);
    7885           0 : if (e) return e;
    7886           0 : p -= l; len -= l; ret += l;
    7887             : 
    7888           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7889           0 : if (e) return e;
    7890           0 : p -= l; len -= l; ret += l;
    7891             : 
    7892           0 : ret += Top_tag_oldret;
    7893             : }
    7894             : /* exponent2 */
    7895             : {
    7896           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7897           0 : ret = 0;
    7898           0 : e = der_put_heim_integer(p, len, &(data)->exponent2, &l);
    7899           0 : if (e) return e;
    7900           0 : p -= l; len -= l; ret += l;
    7901             : 
    7902           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7903           0 : if (e) return e;
    7904           0 : p -= l; len -= l; ret += l;
    7905             : 
    7906           0 : ret += Top_tag_oldret;
    7907             : }
    7908             : /* exponent1 */
    7909             : {
    7910           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7911           0 : ret = 0;
    7912           0 : e = der_put_heim_integer(p, len, &(data)->exponent1, &l);
    7913           0 : if (e) return e;
    7914           0 : p -= l; len -= l; ret += l;
    7915             : 
    7916           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7917           0 : if (e) return e;
    7918           0 : p -= l; len -= l; ret += l;
    7919             : 
    7920           0 : ret += Top_tag_oldret;
    7921             : }
    7922             : /* prime2 */
    7923             : {
    7924           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7925           0 : ret = 0;
    7926           0 : e = der_put_heim_integer(p, len, &(data)->prime2, &l);
    7927           0 : if (e) return e;
    7928           0 : p -= l; len -= l; ret += l;
    7929             : 
    7930           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7931           0 : if (e) return e;
    7932           0 : p -= l; len -= l; ret += l;
    7933             : 
    7934           0 : ret += Top_tag_oldret;
    7935             : }
    7936             : /* prime1 */
    7937             : {
    7938           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7939           0 : ret = 0;
    7940           0 : e = der_put_heim_integer(p, len, &(data)->prime1, &l);
    7941           0 : if (e) return e;
    7942           0 : p -= l; len -= l; ret += l;
    7943             : 
    7944           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7945           0 : if (e) return e;
    7946           0 : p -= l; len -= l; ret += l;
    7947             : 
    7948           0 : ret += Top_tag_oldret;
    7949             : }
    7950             : /* privateExponent */
    7951             : {
    7952           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7953           0 : ret = 0;
    7954           0 : e = der_put_heim_integer(p, len, &(data)->privateExponent, &l);
    7955           0 : if (e) return e;
    7956           0 : p -= l; len -= l; ret += l;
    7957             : 
    7958           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7959           0 : if (e) return e;
    7960           0 : p -= l; len -= l; ret += l;
    7961             : 
    7962           0 : ret += Top_tag_oldret;
    7963             : }
    7964             : /* publicExponent */
    7965             : {
    7966           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7967           0 : ret = 0;
    7968           0 : e = der_put_heim_integer(p, len, &(data)->publicExponent, &l);
    7969           0 : if (e) return e;
    7970           0 : p -= l; len -= l; ret += l;
    7971             : 
    7972           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7973           0 : if (e) return e;
    7974           0 : p -= l; len -= l; ret += l;
    7975             : 
    7976           0 : ret += Top_tag_oldret;
    7977             : }
    7978             : /* modulus */
    7979             : {
    7980           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7981           0 : ret = 0;
    7982           0 : e = der_put_heim_integer(p, len, &(data)->modulus, &l);
    7983           0 : if (e) return e;
    7984           0 : p -= l; len -= l; ret += l;
    7985             : 
    7986           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    7987           0 : if (e) return e;
    7988           0 : p -= l; len -= l; ret += l;
    7989             : 
    7990           0 : ret += Top_tag_oldret;
    7991             : }
    7992             : /* version */
    7993             : {
    7994           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    7995           0 : ret = 0;
    7996           0 : e = der_put_unsigned(p, len, &(data)->version, &l);
    7997           0 : if (e) return e;
    7998           0 : p -= l; len -= l; ret += l;
    7999             : 
    8000           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    8001           0 : if (e) return e;
    8002           0 : p -= l; len -= l; ret += l;
    8003             : 
    8004           0 : ret += Top_tag_oldret;
    8005             : }
    8006           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    8007           0 : if (e) return e;
    8008           0 : p -= l; len -= l; ret += l;
    8009             : 
    8010           0 : *size = ret;
    8011           0 : return 0;
    8012             : }
    8013             : 
    8014             : int ASN1CALL
    8015          94 : decode_RSAPrivateKey(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, RSAPrivateKey *data, size_t *size)
    8016             : {
    8017          94 : size_t ret = 0;
    8018             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    8019             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    8020             : 
    8021          94 : memset(data, 0, sizeof(*data));
    8022             : {
    8023             : size_t Top_datalen, Top_oldlen;
    8024             : Der_type Top_type;
    8025          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    8026          94 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    8027          94 : if(e) goto fail;
    8028          94 : p += l; len -= l; ret += l;
    8029          94 : Top_oldlen = len;
    8030          94 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8031          94 : len = Top_datalen;
    8032             : {
    8033             : size_t version_datalen, version_oldlen;
    8034             : Der_type version_type;
    8035          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &version_type, UT_Integer, &version_datalen, &l);
    8036          94 : if (e == 0 && version_type != PRIM) { e = ASN1_BAD_ID; }
    8037          94 : if(e) goto fail;
    8038          94 : p += l; len -= l; ret += l;
    8039          94 : version_oldlen = len;
    8040          94 : if (version_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8041          94 : len = version_datalen;
    8042          94 : e = der_get_unsigned(p, len, &(data)->version, &l);
    8043          94 : if(e) goto fail;
    8044          94 : p += l; len -= l; ret += l;
    8045          94 : len = version_oldlen - version_datalen;
    8046             : }
    8047             : {
    8048             : size_t modulus_datalen, modulus_oldlen;
    8049             : Der_type modulus_type;
    8050          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &modulus_type, UT_Integer, &modulus_datalen, &l);
    8051         180 : if (e == 0 && modulus_type != PRIM) { e = ASN1_BAD_ID; }
    8052          94 : if(e) goto fail;
    8053          94 : p += l; len -= l; ret += l;
    8054          94 : modulus_oldlen = len;
    8055          94 : if (modulus_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8056          94 : len = modulus_datalen;
    8057          94 : e = der_get_heim_integer(p, len, &(data)->modulus, &l);
    8058          94 : if(e) goto fail;
    8059          94 : p += l; len -= l; ret += l;
    8060          94 : len = modulus_oldlen - modulus_datalen;
    8061             : }
    8062             : {
    8063             : size_t publicExponent_datalen, publicExponent_oldlen;
    8064             : Der_type publicExponent_type;
    8065          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &publicExponent_type, UT_Integer, &publicExponent_datalen, &l);
    8066         180 : if (e == 0 && publicExponent_type != PRIM) { e = ASN1_BAD_ID; }
    8067          94 : if(e) goto fail;
    8068          94 : p += l; len -= l; ret += l;
    8069          94 : publicExponent_oldlen = len;
    8070          94 : if (publicExponent_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8071          94 : len = publicExponent_datalen;
    8072          94 : e = der_get_heim_integer(p, len, &(data)->publicExponent, &l);
    8073          94 : if(e) goto fail;
    8074          94 : p += l; len -= l; ret += l;
    8075          94 : len = publicExponent_oldlen - publicExponent_datalen;
    8076             : }
    8077             : {
    8078             : size_t privateExponent_datalen, privateExponent_oldlen;
    8079             : Der_type privateExponent_type;
    8080          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &privateExponent_type, UT_Integer, &privateExponent_datalen, &l);
    8081         180 : if (e == 0 && privateExponent_type != PRIM) { e = ASN1_BAD_ID; }
    8082          94 : if(e) goto fail;
    8083          94 : p += l; len -= l; ret += l;
    8084          94 : privateExponent_oldlen = len;
    8085          94 : if (privateExponent_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8086          94 : len = privateExponent_datalen;
    8087          94 : e = der_get_heim_integer(p, len, &(data)->privateExponent, &l);
    8088          94 : if(e) goto fail;
    8089          94 : p += l; len -= l; ret += l;
    8090          94 : len = privateExponent_oldlen - privateExponent_datalen;
    8091             : }
    8092             : {
    8093             : size_t prime1_datalen, prime1_oldlen;
    8094             : Der_type prime1_type;
    8095          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &prime1_type, UT_Integer, &prime1_datalen, &l);
    8096         180 : if (e == 0 && prime1_type != PRIM) { e = ASN1_BAD_ID; }
    8097          94 : if(e) goto fail;
    8098          94 : p += l; len -= l; ret += l;
    8099          94 : prime1_oldlen = len;
    8100          94 : if (prime1_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8101          94 : len = prime1_datalen;
    8102          94 : e = der_get_heim_integer(p, len, &(data)->prime1, &l);
    8103          94 : if(e) goto fail;
    8104          94 : p += l; len -= l; ret += l;
    8105          94 : len = prime1_oldlen - prime1_datalen;
    8106             : }
    8107             : {
    8108             : size_t prime2_datalen, prime2_oldlen;
    8109             : Der_type prime2_type;
    8110          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &prime2_type, UT_Integer, &prime2_datalen, &l);
    8111         180 : if (e == 0 && prime2_type != PRIM) { e = ASN1_BAD_ID; }
    8112          94 : if(e) goto fail;
    8113          94 : p += l; len -= l; ret += l;
    8114          94 : prime2_oldlen = len;
    8115          94 : if (prime2_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8116          94 : len = prime2_datalen;
    8117          94 : e = der_get_heim_integer(p, len, &(data)->prime2, &l);
    8118          94 : if(e) goto fail;
    8119          94 : p += l; len -= l; ret += l;
    8120          94 : len = prime2_oldlen - prime2_datalen;
    8121             : }
    8122             : {
    8123             : size_t exponent1_datalen, exponent1_oldlen;
    8124             : Der_type exponent1_type;
    8125          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &exponent1_type, UT_Integer, &exponent1_datalen, &l);
    8126         180 : if (e == 0 && exponent1_type != PRIM) { e = ASN1_BAD_ID; }
    8127          94 : if(e) goto fail;
    8128          94 : p += l; len -= l; ret += l;
    8129          94 : exponent1_oldlen = len;
    8130          94 : if (exponent1_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8131          94 : len = exponent1_datalen;
    8132          94 : e = der_get_heim_integer(p, len, &(data)->exponent1, &l);
    8133          94 : if(e) goto fail;
    8134          94 : p += l; len -= l; ret += l;
    8135          94 : len = exponent1_oldlen - exponent1_datalen;
    8136             : }
    8137             : {
    8138             : size_t exponent2_datalen, exponent2_oldlen;
    8139             : Der_type exponent2_type;
    8140          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &exponent2_type, UT_Integer, &exponent2_datalen, &l);
    8141         180 : if (e == 0 && exponent2_type != PRIM) { e = ASN1_BAD_ID; }
    8142          94 : if(e) goto fail;
    8143          94 : p += l; len -= l; ret += l;
    8144          94 : exponent2_oldlen = len;
    8145          94 : if (exponent2_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8146          94 : len = exponent2_datalen;
    8147          94 : e = der_get_heim_integer(p, len, &(data)->exponent2, &l);
    8148          94 : if(e) goto fail;
    8149          94 : p += l; len -= l; ret += l;
    8150          94 : len = exponent2_oldlen - exponent2_datalen;
    8151             : }
    8152             : {
    8153             : size_t coefficient_datalen, coefficient_oldlen;
    8154             : Der_type coefficient_type;
    8155          94 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &coefficient_type, UT_Integer, &coefficient_datalen, &l);
    8156         180 : if (e == 0 && coefficient_type != PRIM) { e = ASN1_BAD_ID; }
    8157          94 : if(e) goto fail;
    8158          94 : p += l; len -= l; ret += l;
    8159          94 : coefficient_oldlen = len;
    8160          94 : if (coefficient_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8161          94 : len = coefficient_datalen;
    8162          94 : e = der_get_heim_integer(p, len, &(data)->coefficient, &l);
    8163          94 : if(e) goto fail;
    8164          94 : p += l; len -= l; ret += l;
    8165          94 : len = coefficient_oldlen - coefficient_datalen;
    8166             : }
    8167          94 : len = Top_oldlen - Top_datalen;
    8168             : }
    8169         188 : if(size) *size = ret;
    8170          86 : return 0;
    8171           0 : fail:
    8172           0 : free_RSAPrivateKey(data);
    8173           0 : return e;
    8174             : }
    8175             : 
    8176             : void ASN1CALL
    8177          94 : free_RSAPrivateKey(RSAPrivateKey *data)
    8178             : {
    8179          94 : der_free_heim_integer(&(data)->modulus);
    8180          94 : der_free_heim_integer(&(data)->publicExponent);
    8181          94 : der_free_heim_integer(&(data)->privateExponent);
    8182          94 : der_free_heim_integer(&(data)->prime1);
    8183          94 : der_free_heim_integer(&(data)->prime2);
    8184          94 : der_free_heim_integer(&(data)->exponent1);
    8185          94 : der_free_heim_integer(&(data)->exponent2);
    8186          94 : der_free_heim_integer(&(data)->coefficient);
    8187          94 : }
    8188             : 
    8189             : size_t ASN1CALL
    8190           0 : length_RSAPrivateKey(const RSAPrivateKey *data)
    8191             : {
    8192           0 : size_t ret = 0;
    8193             : {
    8194           0 : size_t Top_tag_oldret = ret;
    8195           0 : ret = 0;
    8196           0 : ret += der_length_unsigned(&(data)->version);
    8197           0 : ret += 1 + der_length_len (ret);
    8198           0 : ret += Top_tag_oldret;
    8199             : }
    8200             : {
    8201           0 : size_t Top_tag_oldret = ret;
    8202           0 : ret = 0;
    8203           0 : ret += der_length_heim_integer(&(data)->modulus);
    8204           0 : ret += 1 + der_length_len (ret);
    8205           0 : ret += Top_tag_oldret;
    8206             : }
    8207             : {
    8208           0 : size_t Top_tag_oldret = ret;
    8209           0 : ret = 0;
    8210           0 : ret += der_length_heim_integer(&(data)->publicExponent);
    8211           0 : ret += 1 + der_length_len (ret);
    8212           0 : ret += Top_tag_oldret;
    8213             : }
    8214             : {
    8215           0 : size_t Top_tag_oldret = ret;
    8216           0 : ret = 0;
    8217           0 : ret += der_length_heim_integer(&(data)->privateExponent);
    8218           0 : ret += 1 + der_length_len (ret);
    8219           0 : ret += Top_tag_oldret;
    8220             : }
    8221             : {
    8222           0 : size_t Top_tag_oldret = ret;
    8223           0 : ret = 0;
    8224           0 : ret += der_length_heim_integer(&(data)->prime1);
    8225           0 : ret += 1 + der_length_len (ret);
    8226           0 : ret += Top_tag_oldret;
    8227             : }
    8228             : {
    8229           0 : size_t Top_tag_oldret = ret;
    8230           0 : ret = 0;
    8231           0 : ret += der_length_heim_integer(&(data)->prime2);
    8232           0 : ret += 1 + der_length_len (ret);
    8233           0 : ret += Top_tag_oldret;
    8234             : }
    8235             : {
    8236           0 : size_t Top_tag_oldret = ret;
    8237           0 : ret = 0;
    8238           0 : ret += der_length_heim_integer(&(data)->exponent1);
    8239           0 : ret += 1 + der_length_len (ret);
    8240           0 : ret += Top_tag_oldret;
    8241             : }
    8242             : {
    8243           0 : size_t Top_tag_oldret = ret;
    8244           0 : ret = 0;
    8245           0 : ret += der_length_heim_integer(&(data)->exponent2);
    8246           0 : ret += 1 + der_length_len (ret);
    8247           0 : ret += Top_tag_oldret;
    8248             : }
    8249             : {
    8250           0 : size_t Top_tag_oldret = ret;
    8251           0 : ret = 0;
    8252           0 : ret += der_length_heim_integer(&(data)->coefficient);
    8253           0 : ret += 1 + der_length_len (ret);
    8254           0 : ret += Top_tag_oldret;
    8255             : }
    8256           0 : ret += 1 + der_length_len (ret);
    8257           0 : return ret;
    8258             : }
    8259             : 
    8260             : int ASN1CALL
    8261           0 : copy_RSAPrivateKey(const RSAPrivateKey *from, RSAPrivateKey *to)
    8262             : {
    8263           0 : memset(to, 0, sizeof(*to));
    8264           0 : *(&(to)->version) = *(&(from)->version);
    8265           0 : if(der_copy_heim_integer(&(from)->modulus, &(to)->modulus)) goto fail;
    8266           0 : if(der_copy_heim_integer(&(from)->publicExponent, &(to)->publicExponent)) goto fail;
    8267           0 : if(der_copy_heim_integer(&(from)->privateExponent, &(to)->privateExponent)) goto fail;
    8268           0 : if(der_copy_heim_integer(&(from)->prime1, &(to)->prime1)) goto fail;
    8269           0 : if(der_copy_heim_integer(&(from)->prime2, &(to)->prime2)) goto fail;
    8270           0 : if(der_copy_heim_integer(&(from)->exponent1, &(to)->exponent1)) goto fail;
    8271           0 : if(der_copy_heim_integer(&(from)->exponent2, &(to)->exponent2)) goto fail;
    8272           0 : if(der_copy_heim_integer(&(from)->coefficient, &(to)->coefficient)) goto fail;
    8273           0 : return 0;
    8274           0 : fail:
    8275           0 : free_RSAPrivateKey(to);
    8276           0 : return ENOMEM;
    8277             : }
    8278             : 
    8279             : int ASN1CALL
    8280          66 : encode_DigestInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const DigestInfo *data, size_t *size)
    8281             : {
    8282          66 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    8283             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    8284             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    8285             : 
    8286             : /* digest */
    8287             : {
    8288          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8289          66 : ret = 0;
    8290          66 : e = der_put_octet_string(p, len, &(data)->digest, &l);
    8291          66 : if (e) return e;
    8292          66 : p -= l; len -= l; ret += l;
    8293             : 
    8294          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
    8295          66 : if (e) return e;
    8296          66 : p -= l; len -= l; ret += l;
    8297             : 
    8298          66 : ret += Top_tag_oldret;
    8299             : }
    8300             : /* digestAlgorithm */
    8301             : {
    8302          66 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8303          66 : ret = 0;
    8304          66 : e = encode_AlgorithmIdentifier(p, len, &(data)->digestAlgorithm, &l);
    8305          66 : if (e) return e;
    8306          66 : p -= l; len -= l; ret += l;
    8307             : 
    8308          66 : ret += Top_tag_oldret;
    8309             : }
    8310          66 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    8311          66 : if (e) return e;
    8312          66 : p -= l; len -= l; ret += l;
    8313             : 
    8314          66 : *size = ret;
    8315          66 : return 0;
    8316             : }
    8317             : 
    8318             : int ASN1CALL
    8319         180 : decode_DigestInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, DigestInfo *data, size_t *size)
    8320             : {
    8321         180 : size_t ret = 0;
    8322             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    8323             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    8324             : 
    8325         180 : memset(data, 0, sizeof(*data));
    8326             : {
    8327             : size_t Top_datalen, Top_oldlen;
    8328             : Der_type Top_type;
    8329         180 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    8330         180 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    8331         180 : if(e) goto fail;
    8332         180 : p += l; len -= l; ret += l;
    8333         180 : Top_oldlen = len;
    8334         180 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8335         180 : len = Top_datalen;
    8336         180 : e = decode_AlgorithmIdentifier(p, len, &(data)->digestAlgorithm, &l);
    8337         180 : if(e) goto fail;
    8338         180 : p += l; len -= l; ret += l;
    8339             : {
    8340             : size_t digest_datalen, digest_oldlen;
    8341             : Der_type digest_type;
    8342         180 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &digest_type, UT_OctetString, &digest_datalen, &l);
    8343         180 : if (e == 0 && digest_type != PRIM) { e = ASN1_BAD_ID; }
    8344         180 : if(e) goto fail;
    8345         180 : p += l; len -= l; ret += l;
    8346         180 : digest_oldlen = len;
    8347         180 : if (digest_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8348         180 : len = digest_datalen;
    8349         180 : e = der_get_octet_string(p, len, &(data)->digest, &l);
    8350         180 : if(e) goto fail;
    8351         180 : p += l; len -= l; ret += l;
    8352         180 : len = digest_oldlen - digest_datalen;
    8353             : }
    8354         180 : len = Top_oldlen - Top_datalen;
    8355             : }
    8356         360 : if(size) *size = ret;
    8357         180 : return 0;
    8358           0 : fail:
    8359           0 : free_DigestInfo(data);
    8360           0 : return e;
    8361             : }
    8362             : 
    8363             : void ASN1CALL
    8364         246 : free_DigestInfo(DigestInfo *data)
    8365             : {
    8366         246 : free_AlgorithmIdentifier(&(data)->digestAlgorithm);
    8367         246 : der_free_octet_string(&(data)->digest);
    8368         246 : }
    8369             : 
    8370             : size_t ASN1CALL
    8371          66 : length_DigestInfo(const DigestInfo *data)
    8372             : {
    8373          66 : size_t ret = 0;
    8374             : {
    8375          66 : size_t Top_tag_oldret = ret;
    8376          66 : ret = 0;
    8377          66 : ret += length_AlgorithmIdentifier(&(data)->digestAlgorithm);
    8378          66 : ret += Top_tag_oldret;
    8379             : }
    8380             : {
    8381          66 : size_t Top_tag_oldret = ret;
    8382          66 : ret = 0;
    8383          66 : ret += der_length_octet_string(&(data)->digest);
    8384          66 : ret += 1 + der_length_len (ret);
    8385          66 : ret += Top_tag_oldret;
    8386             : }
    8387          66 : ret += 1 + der_length_len (ret);
    8388          66 : return ret;
    8389             : }
    8390             : 
    8391             : int ASN1CALL
    8392           0 : copy_DigestInfo(const DigestInfo *from, DigestInfo *to)
    8393             : {
    8394           0 : memset(to, 0, sizeof(*to));
    8395           0 : if(copy_AlgorithmIdentifier(&(from)->digestAlgorithm, &(to)->digestAlgorithm)) goto fail;
    8396           0 : if(der_copy_octet_string(&(from)->digest, &(to)->digest)) goto fail;
    8397           0 : return 0;
    8398           0 : fail:
    8399           0 : free_DigestInfo(to);
    8400           0 : return ENOMEM;
    8401             : }
    8402             : 
    8403             : int ASN1CALL
    8404           0 : encode_TBSCRLCertList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const TBSCRLCertList *data, size_t *size)
    8405             : {
    8406           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    8407             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    8408             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    8409             : 
    8410             : /* crlExtensions */
    8411           0 : if((data)->crlExtensions) {
    8412           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8413           0 : ret = 0;
    8414           0 : e = encode_Extensions(p, len, (data)->crlExtensions, &l);
    8415           0 : if (e) return e;
    8416           0 : p -= l; len -= l; ret += l;
    8417             : 
    8418           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    8419           0 : if (e) return e;
    8420           0 : p -= l; len -= l; ret += l;
    8421             : 
    8422           0 : ret += Top_tag_oldret;
    8423             : }
    8424             : /* revokedCertificates */
    8425           0 : if((data)->revokedCertificates) {
    8426           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8427           0 : ret = 0;
    8428           0 : for(i = (int)((data)->revokedCertificates)->len - 1; i >= 0; --i) {
    8429           0 : size_t revokedCertificates_tag_for_oldret = ret;
    8430           0 : ret = 0;
    8431             : /* crlEntryExtensions */
    8432           0 : if((&((data)->revokedCertificates)->val[i])->crlEntryExtensions) {
    8433           0 : size_t revokedCertificates_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8434           0 : ret = 0;
    8435           0 : e = encode_Extensions(p, len, (&((data)->revokedCertificates)->val[i])->crlEntryExtensions, &l);
    8436           0 : if (e) return e;
    8437           0 : p -= l; len -= l; ret += l;
    8438             : 
    8439           0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
    8440             : }
    8441             : /* revocationDate */
    8442             : {
    8443           0 : size_t revokedCertificates_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8444           0 : ret = 0;
    8445           0 : e = encode_Time(p, len, &(&((data)->revokedCertificates)->val[i])->revocationDate, &l);
    8446           0 : if (e) return e;
    8447           0 : p -= l; len -= l; ret += l;
    8448             : 
    8449           0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
    8450             : }
    8451             : /* userCertificate */
    8452             : {
    8453           0 : size_t revokedCertificates_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8454           0 : ret = 0;
    8455           0 : e = encode_CertificateSerialNumber(p, len, &(&((data)->revokedCertificates)->val[i])->userCertificate, &l);
    8456           0 : if (e) return e;
    8457           0 : p -= l; len -= l; ret += l;
    8458             : 
    8459           0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
    8460             : }
    8461           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    8462           0 : if (e) return e;
    8463           0 : p -= l; len -= l; ret += l;
    8464             : 
    8465           0 : ret += revokedCertificates_tag_for_oldret;
    8466             : }
    8467           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    8468           0 : if (e) return e;
    8469           0 : p -= l; len -= l; ret += l;
    8470             : 
    8471           0 : ret += Top_tag_oldret;
    8472             : }
    8473             : /* nextUpdate */
    8474           0 : if((data)->nextUpdate) {
    8475           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8476           0 : ret = 0;
    8477           0 : e = encode_Time(p, len, (data)->nextUpdate, &l);
    8478           0 : if (e) return e;
    8479           0 : p -= l; len -= l; ret += l;
    8480             : 
    8481           0 : ret += Top_tag_oldret;
    8482             : }
    8483             : /* thisUpdate */
    8484             : {
    8485           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8486           0 : ret = 0;
    8487           0 : e = encode_Time(p, len, &(data)->thisUpdate, &l);
    8488           0 : if (e) return e;
    8489           0 : p -= l; len -= l; ret += l;
    8490             : 
    8491           0 : ret += Top_tag_oldret;
    8492             : }
    8493             : /* issuer */
    8494             : {
    8495           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8496           0 : ret = 0;
    8497           0 : e = encode_Name(p, len, &(data)->issuer, &l);
    8498           0 : if (e) return e;
    8499           0 : p -= l; len -= l; ret += l;
    8500             : 
    8501           0 : ret += Top_tag_oldret;
    8502             : }
    8503             : /* signature */
    8504             : {
    8505           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8506           0 : ret = 0;
    8507           0 : e = encode_AlgorithmIdentifier(p, len, &(data)->signature, &l);
    8508           0 : if (e) return e;
    8509           0 : p -= l; len -= l; ret += l;
    8510             : 
    8511           0 : ret += Top_tag_oldret;
    8512             : }
    8513             : /* version */
    8514           0 : if((data)->version) {
    8515           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8516           0 : ret = 0;
    8517           0 : e = encode_Version(p, len, (data)->version, &l);
    8518           0 : if (e) return e;
    8519           0 : p -= l; len -= l; ret += l;
    8520             : 
    8521           0 : ret += Top_tag_oldret;
    8522             : }
    8523           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    8524           0 : if (e) return e;
    8525           0 : p -= l; len -= l; ret += l;
    8526             : 
    8527           0 : *size = ret;
    8528           0 : return 0;
    8529             : }
    8530             : 
    8531             : int ASN1CALL
    8532           0 : decode_TBSCRLCertList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, TBSCRLCertList *data, size_t *size)
    8533             : {
    8534           0 : size_t ret = 0;
    8535             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    8536             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    8537           0 : const unsigned char *begin = p;
    8538             : 
    8539           0 : memset(data, 0, sizeof(*data));
    8540             : {
    8541             : size_t Top_datalen, Top_oldlen;
    8542             : Der_type Top_type;
    8543           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    8544           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    8545           0 : if(e) goto fail;
    8546           0 : p += l; len -= l; ret += l;
    8547           0 : Top_oldlen = len;
    8548           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8549           0 : len = Top_datalen;
    8550           0 : (data)->version = calloc(1, sizeof(*(data)->version));
    8551           0 : if ((data)->version == NULL) goto fail;
    8552           0 : e = decode_Version(p, len, (data)->version, &l);
    8553           0 : if(e) {
    8554           0 : free((data)->version);
    8555           0 : (data)->version = NULL;
    8556             : } else {
    8557           0 : p += l; len -= l; ret += l;
    8558             : }
    8559           0 : e = decode_AlgorithmIdentifier(p, len, &(data)->signature, &l);
    8560           0 : if(e) goto fail;
    8561           0 : p += l; len -= l; ret += l;
    8562           0 : e = decode_Name(p, len, &(data)->issuer, &l);
    8563           0 : if(e) goto fail;
    8564           0 : p += l; len -= l; ret += l;
    8565           0 : e = decode_Time(p, len, &(data)->thisUpdate, &l);
    8566           0 : if(e) goto fail;
    8567           0 : p += l; len -= l; ret += l;
    8568           0 : (data)->nextUpdate = calloc(1, sizeof(*(data)->nextUpdate));
    8569           0 : if ((data)->nextUpdate == NULL) goto fail;
    8570           0 : e = decode_Time(p, len, (data)->nextUpdate, &l);
    8571           0 : if(e) {
    8572           0 : free((data)->nextUpdate);
    8573           0 : (data)->nextUpdate = NULL;
    8574             : } else {
    8575           0 : p += l; len -= l; ret += l;
    8576             : }
    8577             : {
    8578             : size_t revokedCertificates_datalen, revokedCertificates_oldlen;
    8579             : Der_type revokedCertificates_type;
    8580           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &revokedCertificates_type, UT_Sequence, &revokedCertificates_datalen, &l);
    8581           0 : if (e == 0 && revokedCertificates_type != CONS) { e = ASN1_BAD_ID; }
    8582           0 : if(e) {
    8583           0 : (data)->revokedCertificates = NULL;
    8584             : } else {
    8585           0 : (data)->revokedCertificates = calloc(1, sizeof(*(data)->revokedCertificates));
    8586           0 : if ((data)->revokedCertificates == NULL) { e = ENOMEM; goto fail; }
    8587           0 : p += l; len -= l; ret += l;
    8588           0 : revokedCertificates_oldlen = len;
    8589           0 : if (revokedCertificates_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8590           0 : len = revokedCertificates_datalen;
    8591             : {
    8592           0 : size_t revokedCertificates_Tag_origlen = len;
    8593           0 : size_t revokedCertificates_Tag_oldret = ret;
    8594           0 : size_t revokedCertificates_Tag_olen = 0;
    8595             : void *revokedCertificates_Tag_tmp;
    8596           0 : ret = 0;
    8597           0 : ((data)->revokedCertificates)->len = 0;
    8598           0 : ((data)->revokedCertificates)->val = NULL;
    8599           0 : while(ret < revokedCertificates_Tag_origlen) {
    8600           0 : size_t revokedCertificates_Tag_nlen = revokedCertificates_Tag_olen + sizeof(*(((data)->revokedCertificates)->val));
    8601           0 : if (revokedCertificates_Tag_olen > revokedCertificates_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    8602           0 : revokedCertificates_Tag_olen = revokedCertificates_Tag_nlen;
    8603           0 : revokedCertificates_Tag_tmp = realloc(((data)->revokedCertificates)->val, revokedCertificates_Tag_olen);
    8604           0 : if (revokedCertificates_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    8605           0 : ((data)->revokedCertificates)->val = revokedCertificates_Tag_tmp;
    8606             : {
    8607             : size_t revokedCertificates_Tag_s_of_datalen, revokedCertificates_Tag_s_of_oldlen;
    8608             : Der_type revokedCertificates_Tag_s_of_type;
    8609           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &revokedCertificates_Tag_s_of_type, UT_Sequence, &revokedCertificates_Tag_s_of_datalen, &l);
    8610           0 : if (e == 0 && revokedCertificates_Tag_s_of_type != CONS) { e = ASN1_BAD_ID; }
    8611           0 : if(e) goto fail;
    8612           0 : p += l; len -= l; ret += l;
    8613           0 : revokedCertificates_Tag_s_of_oldlen = len;
    8614           0 : if (revokedCertificates_Tag_s_of_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8615           0 : len = revokedCertificates_Tag_s_of_datalen;
    8616           0 : e = decode_CertificateSerialNumber(p, len, &(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->userCertificate, &l);
    8617           0 : if(e) goto fail;
    8618           0 : p += l; len -= l; ret += l;
    8619           0 : e = decode_Time(p, len, &(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->revocationDate, &l);
    8620           0 : if(e) goto fail;
    8621           0 : p += l; len -= l; ret += l;
    8622           0 : (&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions = calloc(1, sizeof(*(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions));
    8623           0 : if ((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions == NULL) goto fail;
    8624           0 : e = decode_Extensions(p, len, (&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions, &l);
    8625           0 : if(e) {
    8626           0 : free((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions);
    8627           0 : (&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len])->crlEntryExtensions = NULL;
    8628             : } else {
    8629           0 : p += l; len -= l; ret += l;
    8630             : }
    8631           0 : len = revokedCertificates_Tag_s_of_oldlen - revokedCertificates_Tag_s_of_datalen;
    8632             : }
    8633           0 : ((data)->revokedCertificates)->len++;
    8634           0 : len = revokedCertificates_Tag_origlen - ret;
    8635             : }
    8636           0 : ret += revokedCertificates_Tag_oldret;
    8637             : }
    8638           0 : len = revokedCertificates_oldlen - revokedCertificates_datalen;
    8639             : }
    8640             : }
    8641             : {
    8642             : size_t crlExtensions_datalen, crlExtensions_oldlen;
    8643             : Der_type crlExtensions_type;
    8644           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &crlExtensions_type, 0, &crlExtensions_datalen, &l);
    8645           0 : if (e == 0 && crlExtensions_type != CONS) { e = ASN1_BAD_ID; }
    8646           0 : if(e) {
    8647           0 : (data)->crlExtensions = NULL;
    8648             : } else {
    8649           0 : (data)->crlExtensions = calloc(1, sizeof(*(data)->crlExtensions));
    8650           0 : if ((data)->crlExtensions == NULL) { e = ENOMEM; goto fail; }
    8651           0 : p += l; len -= l; ret += l;
    8652           0 : crlExtensions_oldlen = len;
    8653           0 : if (crlExtensions_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8654           0 : len = crlExtensions_datalen;
    8655           0 : e = decode_Extensions(p, len, (data)->crlExtensions, &l);
    8656           0 : if(e) goto fail;
    8657           0 : p += l; len -= l; ret += l;
    8658           0 : len = crlExtensions_oldlen - crlExtensions_datalen;
    8659             : }
    8660             : }
    8661           0 : len = Top_oldlen - Top_datalen;
    8662             : }
    8663           0 : data->_save.data = calloc(1, ret);
    8664           0 : if (data->_save.data == NULL) { 
    8665           0 : e = ENOMEM; goto fail; 
    8666             : }
    8667           0 : data->_save.length = ret;
    8668           0 : memcpy(data->_save.data, begin, ret);
    8669           0 : if(size) *size = ret;
    8670           0 : return 0;
    8671           0 : fail:
    8672           0 : free_TBSCRLCertList(data);
    8673           0 : return e;
    8674             : }
    8675             : 
    8676             : void ASN1CALL
    8677           0 : free_TBSCRLCertList(TBSCRLCertList *data)
    8678             : {
    8679           0 : der_free_octet_string(&data->_save);
    8680           0 : if((data)->version) {
    8681           0 : free_Version((data)->version);
    8682           0 : free((data)->version);
    8683           0 : (data)->version = NULL;
    8684             : }
    8685           0 : free_AlgorithmIdentifier(&(data)->signature);
    8686           0 : free_Name(&(data)->issuer);
    8687           0 : free_Time(&(data)->thisUpdate);
    8688           0 : if((data)->nextUpdate) {
    8689           0 : free_Time((data)->nextUpdate);
    8690           0 : free((data)->nextUpdate);
    8691           0 : (data)->nextUpdate = NULL;
    8692             : }
    8693           0 : if((data)->revokedCertificates) {
    8694           0 : while(((data)->revokedCertificates)->len){
    8695           0 : free_CertificateSerialNumber(&(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->userCertificate);
    8696           0 : free_Time(&(&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->revocationDate);
    8697           0 : if((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->crlEntryExtensions) {
    8698           0 : free_Extensions((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->crlEntryExtensions);
    8699           0 : free((&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->crlEntryExtensions);
    8700           0 : (&((data)->revokedCertificates)->val[((data)->revokedCertificates)->len-1])->crlEntryExtensions = NULL;
    8701             : }
    8702           0 : ((data)->revokedCertificates)->len--;
    8703             : }
    8704           0 : free(((data)->revokedCertificates)->val);
    8705           0 : ((data)->revokedCertificates)->val = NULL;
    8706           0 : free((data)->revokedCertificates);
    8707           0 : (data)->revokedCertificates = NULL;
    8708             : }
    8709           0 : if((data)->crlExtensions) {
    8710           0 : free_Extensions((data)->crlExtensions);
    8711           0 : free((data)->crlExtensions);
    8712           0 : (data)->crlExtensions = NULL;
    8713             : }
    8714           0 : }
    8715             : 
    8716             : size_t ASN1CALL
    8717           0 : length_TBSCRLCertList(const TBSCRLCertList *data)
    8718             : {
    8719           0 : size_t ret = 0;
    8720           0 : if((data)->version){
    8721           0 : size_t Top_tag_oldret = ret;
    8722           0 : ret = 0;
    8723           0 : ret += length_Version((data)->version);
    8724           0 : ret += Top_tag_oldret;
    8725             : }
    8726             : {
    8727           0 : size_t Top_tag_oldret = ret;
    8728           0 : ret = 0;
    8729           0 : ret += length_AlgorithmIdentifier(&(data)->signature);
    8730           0 : ret += Top_tag_oldret;
    8731             : }
    8732             : {
    8733           0 : size_t Top_tag_oldret = ret;
    8734           0 : ret = 0;
    8735           0 : ret += length_Name(&(data)->issuer);
    8736           0 : ret += Top_tag_oldret;
    8737             : }
    8738             : {
    8739           0 : size_t Top_tag_oldret = ret;
    8740           0 : ret = 0;
    8741           0 : ret += length_Time(&(data)->thisUpdate);
    8742           0 : ret += Top_tag_oldret;
    8743             : }
    8744           0 : if((data)->nextUpdate){
    8745           0 : size_t Top_tag_oldret = ret;
    8746           0 : ret = 0;
    8747           0 : ret += length_Time((data)->nextUpdate);
    8748           0 : ret += Top_tag_oldret;
    8749             : }
    8750           0 : if((data)->revokedCertificates){
    8751           0 : size_t Top_tag_oldret = ret;
    8752           0 : ret = 0;
    8753             : {
    8754           0 : size_t revokedCertificates_tag_oldret = ret;
    8755             : int i;
    8756           0 : ret = 0;
    8757           0 : for(i = ((data)->revokedCertificates)->len - 1; i >= 0; --i){
    8758           0 : size_t revokedCertificates_tag_for_oldret = ret;
    8759           0 : ret = 0;
    8760             : {
    8761           0 : size_t revokedCertificates_tag_S_Of_tag_oldret = ret;
    8762           0 : ret = 0;
    8763           0 : ret += length_CertificateSerialNumber(&(&((data)->revokedCertificates)->val[i])->userCertificate);
    8764           0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
    8765             : }
    8766             : {
    8767           0 : size_t revokedCertificates_tag_S_Of_tag_oldret = ret;
    8768           0 : ret = 0;
    8769           0 : ret += length_Time(&(&((data)->revokedCertificates)->val[i])->revocationDate);
    8770           0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
    8771             : }
    8772           0 : if((&((data)->revokedCertificates)->val[i])->crlEntryExtensions){
    8773           0 : size_t revokedCertificates_tag_S_Of_tag_oldret = ret;
    8774           0 : ret = 0;
    8775           0 : ret += length_Extensions((&((data)->revokedCertificates)->val[i])->crlEntryExtensions);
    8776           0 : ret += revokedCertificates_tag_S_Of_tag_oldret;
    8777             : }
    8778           0 : ret += 1 + der_length_len (ret);
    8779           0 : ret += revokedCertificates_tag_for_oldret;
    8780             : }
    8781           0 : ret += revokedCertificates_tag_oldret;
    8782             : }
    8783           0 : ret += 1 + der_length_len (ret);
    8784           0 : ret += Top_tag_oldret;
    8785             : }
    8786           0 : if((data)->crlExtensions){
    8787           0 : size_t Top_tag_oldret = ret;
    8788           0 : ret = 0;
    8789           0 : ret += length_Extensions((data)->crlExtensions);
    8790           0 : ret += 1 + der_length_len (ret);
    8791           0 : ret += Top_tag_oldret;
    8792             : }
    8793           0 : ret += 1 + der_length_len (ret);
    8794           0 : return ret;
    8795             : }
    8796             : 
    8797             : int ASN1CALL
    8798           0 : copy_TBSCRLCertList(const TBSCRLCertList *from, TBSCRLCertList *to)
    8799             : {
    8800           0 : memset(to, 0, sizeof(*to));
    8801             : { int ret;
    8802           0 : ret = der_copy_octet_string(&(from)->_save, &(to)->_save);
    8803           0 : if (ret) goto fail;
    8804             : }
    8805           0 : if((from)->version) {
    8806           0 : (to)->version = malloc(sizeof(*(to)->version));
    8807           0 : if((to)->version == NULL) goto fail;
    8808           0 : if(copy_Version((from)->version, (to)->version)) goto fail;
    8809             : }else
    8810           0 : (to)->version = NULL;
    8811           0 : if(copy_AlgorithmIdentifier(&(from)->signature, &(to)->signature)) goto fail;
    8812           0 : if(copy_Name(&(from)->issuer, &(to)->issuer)) goto fail;
    8813           0 : if(copy_Time(&(from)->thisUpdate, &(to)->thisUpdate)) goto fail;
    8814           0 : if((from)->nextUpdate) {
    8815           0 : (to)->nextUpdate = malloc(sizeof(*(to)->nextUpdate));
    8816           0 : if((to)->nextUpdate == NULL) goto fail;
    8817           0 : if(copy_Time((from)->nextUpdate, (to)->nextUpdate)) goto fail;
    8818             : }else
    8819           0 : (to)->nextUpdate = NULL;
    8820           0 : if((from)->revokedCertificates) {
    8821           0 : (to)->revokedCertificates = malloc(sizeof(*(to)->revokedCertificates));
    8822           0 : if((to)->revokedCertificates == NULL) goto fail;
    8823           0 : if((((to)->revokedCertificates)->val = malloc(((from)->revokedCertificates)->len * sizeof(*((to)->revokedCertificates)->val))) == NULL && ((from)->revokedCertificates)->len != 0)
    8824           0 : goto fail;
    8825           0 : for(((to)->revokedCertificates)->len = 0; ((to)->revokedCertificates)->len < ((from)->revokedCertificates)->len; ((to)->revokedCertificates)->len++){
    8826           0 : if(copy_CertificateSerialNumber(&(&((from)->revokedCertificates)->val[((to)->revokedCertificates)->len])->userCertificate, &(&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->userCertificate)) goto fail;
    8827           0 : if(copy_Time(&(&((from)->revokedCertificates)->val[((to)->revokedCertificates)->len])->revocationDate, &(&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->revocationDate)) goto fail;
    8828           0 : if((&((from)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions) {
    8829           0 : (&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions = malloc(sizeof(*(&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions));
    8830           0 : if((&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions == NULL) goto fail;
    8831           0 : if(copy_Extensions((&((from)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions, (&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions)) goto fail;
    8832             : }else
    8833           0 : (&((to)->revokedCertificates)->val[((to)->revokedCertificates)->len])->crlEntryExtensions = NULL;
    8834             : }
    8835             : }else
    8836           0 : (to)->revokedCertificates = NULL;
    8837           0 : if((from)->crlExtensions) {
    8838           0 : (to)->crlExtensions = malloc(sizeof(*(to)->crlExtensions));
    8839           0 : if((to)->crlExtensions == NULL) goto fail;
    8840           0 : if(copy_Extensions((from)->crlExtensions, (to)->crlExtensions)) goto fail;
    8841             : }else
    8842           0 : (to)->crlExtensions = NULL;
    8843           0 : return 0;
    8844           0 : fail:
    8845           0 : free_TBSCRLCertList(to);
    8846           0 : return ENOMEM;
    8847             : }
    8848             : 
    8849             : int ASN1CALL
    8850           0 : encode_CRLCertificateList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CRLCertificateList *data, size_t *size)
    8851             : {
    8852           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    8853             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    8854             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    8855             : 
    8856             : /* signatureValue */
    8857             : {
    8858           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8859           0 : ret = 0;
    8860           0 : e = der_put_bit_string(p, len, &(data)->signatureValue, &l);
    8861           0 : if (e) return e;
    8862           0 : p -= l; len -= l; ret += l;
    8863             : 
    8864           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
    8865           0 : if (e) return e;
    8866           0 : p -= l; len -= l; ret += l;
    8867             : 
    8868           0 : ret += Top_tag_oldret;
    8869             : }
    8870             : /* signatureAlgorithm */
    8871             : {
    8872           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8873           0 : ret = 0;
    8874           0 : e = encode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
    8875           0 : if (e) return e;
    8876           0 : p -= l; len -= l; ret += l;
    8877             : 
    8878           0 : ret += Top_tag_oldret;
    8879             : }
    8880             : /* tbsCertList */
    8881             : {
    8882           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    8883           0 : ret = 0;
    8884           0 : e = encode_TBSCRLCertList(p, len, &(data)->tbsCertList, &l);
    8885           0 : if (e) return e;
    8886           0 : p -= l; len -= l; ret += l;
    8887             : 
    8888           0 : ret += Top_tag_oldret;
    8889             : }
    8890           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    8891           0 : if (e) return e;
    8892           0 : p -= l; len -= l; ret += l;
    8893             : 
    8894           0 : *size = ret;
    8895           0 : return 0;
    8896             : }
    8897             : 
    8898             : int ASN1CALL
    8899           0 : decode_CRLCertificateList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CRLCertificateList *data, size_t *size)
    8900             : {
    8901           0 : size_t ret = 0;
    8902             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    8903             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    8904             : 
    8905           0 : memset(data, 0, sizeof(*data));
    8906             : {
    8907             : size_t Top_datalen, Top_oldlen;
    8908             : Der_type Top_type;
    8909           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    8910           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    8911           0 : if(e) goto fail;
    8912           0 : p += l; len -= l; ret += l;
    8913           0 : Top_oldlen = len;
    8914           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8915           0 : len = Top_datalen;
    8916           0 : e = decode_TBSCRLCertList(p, len, &(data)->tbsCertList, &l);
    8917           0 : if(e) goto fail;
    8918           0 : p += l; len -= l; ret += l;
    8919           0 : e = decode_AlgorithmIdentifier(p, len, &(data)->signatureAlgorithm, &l);
    8920           0 : if(e) goto fail;
    8921           0 : p += l; len -= l; ret += l;
    8922             : {
    8923             : size_t signatureValue_datalen, signatureValue_oldlen;
    8924             : Der_type signatureValue_type;
    8925           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &signatureValue_type, UT_BitString, &signatureValue_datalen, &l);
    8926           0 : if (e == 0 && signatureValue_type != PRIM) { e = ASN1_BAD_ID; }
    8927           0 : if(e) goto fail;
    8928           0 : p += l; len -= l; ret += l;
    8929           0 : signatureValue_oldlen = len;
    8930           0 : if (signatureValue_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    8931           0 : len = signatureValue_datalen;
    8932           0 : e = der_get_bit_string(p, len, &(data)->signatureValue, &l);
    8933           0 : if(e) goto fail;
    8934           0 : p += l; len -= l; ret += l;
    8935           0 : len = signatureValue_oldlen - signatureValue_datalen;
    8936             : }
    8937           0 : len = Top_oldlen - Top_datalen;
    8938             : }
    8939           0 : if(size) *size = ret;
    8940           0 : return 0;
    8941           0 : fail:
    8942           0 : free_CRLCertificateList(data);
    8943           0 : return e;
    8944             : }
    8945             : 
    8946             : void ASN1CALL
    8947           0 : free_CRLCertificateList(CRLCertificateList *data)
    8948             : {
    8949           0 : free_TBSCRLCertList(&(data)->tbsCertList);
    8950           0 : free_AlgorithmIdentifier(&(data)->signatureAlgorithm);
    8951           0 : der_free_bit_string(&(data)->signatureValue);
    8952           0 : }
    8953             : 
    8954             : size_t ASN1CALL
    8955           0 : length_CRLCertificateList(const CRLCertificateList *data)
    8956             : {
    8957           0 : size_t ret = 0;
    8958             : {
    8959           0 : size_t Top_tag_oldret = ret;
    8960           0 : ret = 0;
    8961           0 : ret += length_TBSCRLCertList(&(data)->tbsCertList);
    8962           0 : ret += Top_tag_oldret;
    8963             : }
    8964             : {
    8965           0 : size_t Top_tag_oldret = ret;
    8966           0 : ret = 0;
    8967           0 : ret += length_AlgorithmIdentifier(&(data)->signatureAlgorithm);
    8968           0 : ret += Top_tag_oldret;
    8969             : }
    8970             : {
    8971           0 : size_t Top_tag_oldret = ret;
    8972           0 : ret = 0;
    8973           0 : ret += der_length_bit_string(&(data)->signatureValue);
    8974           0 : ret += 1 + der_length_len (ret);
    8975           0 : ret += Top_tag_oldret;
    8976             : }
    8977           0 : ret += 1 + der_length_len (ret);
    8978           0 : return ret;
    8979             : }
    8980             : 
    8981             : int ASN1CALL
    8982           0 : copy_CRLCertificateList(const CRLCertificateList *from, CRLCertificateList *to)
    8983             : {
    8984           0 : memset(to, 0, sizeof(*to));
    8985           0 : if(copy_TBSCRLCertList(&(from)->tbsCertList, &(to)->tbsCertList)) goto fail;
    8986           0 : if(copy_AlgorithmIdentifier(&(from)->signatureAlgorithm, &(to)->signatureAlgorithm)) goto fail;
    8987           0 : if(der_copy_bit_string(&(from)->signatureValue, &(to)->signatureValue)) goto fail;
    8988           0 : return 0;
    8989           0 : fail:
    8990           0 : free_CRLCertificateList(to);
    8991           0 : return ENOMEM;
    8992             : }
    8993             : 
    8994             : static unsigned oid_id_x509_ce_cRLNumber_variable_num[4] =  {2, 5, 29, 20 };
    8995             : const heim_oid asn1_oid_id_x509_ce_cRLNumber = { 4, oid_id_x509_ce_cRLNumber_variable_num };
    8996             : 
    8997             : static unsigned oid_id_x509_ce_freshestCRL_variable_num[4] =  {2, 5, 29, 46 };
    8998             : const heim_oid asn1_oid_id_x509_ce_freshestCRL = { 4, oid_id_x509_ce_freshestCRL_variable_num };
    8999             : 
    9000             : static unsigned oid_id_x509_ce_cRLReason_variable_num[4] =  {2, 5, 29, 21 };
    9001             : const heim_oid asn1_oid_id_x509_ce_cRLReason = { 4, oid_id_x509_ce_cRLReason_variable_num };
    9002             : 
    9003             : int ASN1CALL
    9004           0 : encode_CRLReason(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CRLReason *data, size_t *size)
    9005             : {
    9006           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    9007             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9008             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    9009             : 
    9010             : {
    9011           0 : int enumint = (int)*data;
    9012           0 : e = der_put_integer(p, len, &enumint, &l);
    9013           0 : if (e) return e;
    9014           0 : p -= l; len -= l; ret += l;
    9015             : 
    9016             : }
    9017           0 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Enumerated, &l);
    9018           0 : if (e) return e;
    9019           0 : p -= l; len -= l; ret += l;
    9020             : 
    9021           0 : *size = ret;
    9022           0 : return 0;
    9023             : }
    9024             : 
    9025             : int ASN1CALL
    9026           0 : decode_CRLReason(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, CRLReason *data, size_t *size)
    9027             : {
    9028           0 : size_t ret = 0;
    9029             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9030             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    9031             : 
    9032           0 : memset(data, 0, sizeof(*data));
    9033             : {
    9034             : size_t Top_datalen, Top_oldlen;
    9035             : Der_type Top_type;
    9036           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Enumerated, &Top_datalen, &l);
    9037           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    9038           0 : if(e) goto fail;
    9039           0 : p += l; len -= l; ret += l;
    9040           0 : Top_oldlen = len;
    9041           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9042           0 : len = Top_datalen;
    9043             : {
    9044             : int enumint;
    9045           0 : e = der_get_integer(p, len, &enumint, &l);
    9046           0 : if(e) goto fail;
    9047           0 : p += l; len -= l; ret += l;
    9048           0 : *data = enumint;
    9049             : }
    9050           0 : len = Top_oldlen - Top_datalen;
    9051             : }
    9052           0 : if(size) *size = ret;
    9053           0 : return 0;
    9054           0 : fail:
    9055           0 : free_CRLReason(data);
    9056           0 : return e;
    9057             : }
    9058             : 
    9059             : void ASN1CALL
    9060           0 : free_CRLReason(CRLReason *data)
    9061             : {
    9062           0 : }
    9063             : 
    9064             : size_t ASN1CALL
    9065           0 : length_CRLReason(const CRLReason *data)
    9066             : {
    9067           0 : size_t ret = 0;
    9068             : {
    9069           0 : int enumint = *data;
    9070           0 : ret += der_length_integer(&enumint);
    9071             : }
    9072           0 : ret += 1 + der_length_len (ret);
    9073           0 : return ret;
    9074             : }
    9075             : 
    9076             : int ASN1CALL
    9077           0 : copy_CRLReason(const CRLReason *from, CRLReason *to)
    9078             : {
    9079           0 : memset(to, 0, sizeof(*to));
    9080           0 : *(to) = *(from);
    9081           0 : return 0;
    9082             : }
    9083             : 
    9084             : int ASN1CALL
    9085           0 : encode_PKIXXmppAddr(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const PKIXXmppAddr *data, size_t *size)
    9086             : {
    9087           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    9088             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9089             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    9090             : 
    9091           0 : e = der_put_utf8string(p, len, data, &l);
    9092           0 : if (e) return e;
    9093           0 : p -= l; len -= l; ret += l;
    9094             : 
    9095           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_UTF8String, &l);
    9096           0 : if (e) return e;
    9097           0 : p -= l; len -= l; ret += l;
    9098             : 
    9099           0 : *size = ret;
    9100           0 : return 0;
    9101             : }
    9102             : 
    9103             : int ASN1CALL
    9104           0 : decode_PKIXXmppAddr(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, PKIXXmppAddr *data, size_t *size)
    9105             : {
    9106           0 : size_t ret = 0;
    9107             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9108             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    9109             : 
    9110           0 : memset(data, 0, sizeof(*data));
    9111             : {
    9112             : size_t Top_datalen, Top_oldlen;
    9113             : Der_type Top_type;
    9114           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_UTF8String, &Top_datalen, &l);
    9115           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
    9116           0 : if(e) goto fail;
    9117           0 : p += l; len -= l; ret += l;
    9118           0 : Top_oldlen = len;
    9119           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9120           0 : len = Top_datalen;
    9121           0 : e = der_get_utf8string(p, len, data, &l);
    9122           0 : if(e) goto fail;
    9123           0 : p += l; len -= l; ret += l;
    9124           0 : len = Top_oldlen - Top_datalen;
    9125             : }
    9126           0 : if(size) *size = ret;
    9127           0 : return 0;
    9128           0 : fail:
    9129           0 : free_PKIXXmppAddr(data);
    9130           0 : return e;
    9131             : }
    9132             : 
    9133             : void ASN1CALL
    9134           0 : free_PKIXXmppAddr(PKIXXmppAddr *data)
    9135             : {
    9136           0 : der_free_utf8string(data);
    9137           0 : }
    9138             : 
    9139             : size_t ASN1CALL
    9140           0 : length_PKIXXmppAddr(const PKIXXmppAddr *data)
    9141             : {
    9142           0 : size_t ret = 0;
    9143           0 : ret += der_length_utf8string(data);
    9144           0 : ret += 1 + der_length_len (ret);
    9145           0 : return ret;
    9146             : }
    9147             : 
    9148             : int ASN1CALL
    9149           0 : copy_PKIXXmppAddr(const PKIXXmppAddr *from, PKIXXmppAddr *to)
    9150             : {
    9151           0 : memset(to, 0, sizeof(*to));
    9152           0 : if(der_copy_utf8string(from, to)) goto fail;
    9153           0 : return 0;
    9154           0 : fail:
    9155           0 : free_PKIXXmppAddr(to);
    9156           0 : return ENOMEM;
    9157             : }
    9158             : 
    9159             : static unsigned oid_id_pkix_variable_num[7] =  {1, 3, 6, 1, 5, 5, 7 };
    9160             : const heim_oid asn1_oid_id_pkix = { 7, oid_id_pkix_variable_num };
    9161             : 
    9162             : static unsigned oid_id_pkix_on_variable_num[8] =  {1, 3, 6, 1, 5, 5, 7, 8 };
    9163             : const heim_oid asn1_oid_id_pkix_on = { 8, oid_id_pkix_on_variable_num };
    9164             : 
    9165             : static unsigned oid_id_pkix_on_xmppAddr_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 8, 5 };
    9166             : const heim_oid asn1_oid_id_pkix_on_xmppAddr = { 9, oid_id_pkix_on_xmppAddr_variable_num };
    9167             : 
    9168             : static unsigned oid_id_pkix_on_dnsSRV_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 8, 7 };
    9169             : const heim_oid asn1_oid_id_pkix_on_dnsSRV = { 9, oid_id_pkix_on_dnsSRV_variable_num };
    9170             : 
    9171             : static unsigned oid_id_pkix_kp_variable_num[8] =  {1, 3, 6, 1, 5, 5, 7, 3 };
    9172             : const heim_oid asn1_oid_id_pkix_kp = { 8, oid_id_pkix_kp_variable_num };
    9173             : 
    9174             : static unsigned oid_id_pkix_kp_serverAuth_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 3, 1 };
    9175             : const heim_oid asn1_oid_id_pkix_kp_serverAuth = { 9, oid_id_pkix_kp_serverAuth_variable_num };
    9176             : 
    9177             : static unsigned oid_id_pkix_kp_clientAuth_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 3, 2 };
    9178             : const heim_oid asn1_oid_id_pkix_kp_clientAuth = { 9, oid_id_pkix_kp_clientAuth_variable_num };
    9179             : 
    9180             : static unsigned oid_id_pkix_kp_emailProtection_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 3, 4 };
    9181             : const heim_oid asn1_oid_id_pkix_kp_emailProtection = { 9, oid_id_pkix_kp_emailProtection_variable_num };
    9182             : 
    9183             : static unsigned oid_id_pkix_kp_timeStamping_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 3, 8 };
    9184             : const heim_oid asn1_oid_id_pkix_kp_timeStamping = { 9, oid_id_pkix_kp_timeStamping_variable_num };
    9185             : 
    9186             : static unsigned oid_id_pkix_kp_OCSPSigning_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 3, 9 };
    9187             : const heim_oid asn1_oid_id_pkix_kp_OCSPSigning = { 9, oid_id_pkix_kp_OCSPSigning_variable_num };
    9188             : 
    9189             : static unsigned oid_id_pkix_pe_variable_num[8] =  {1, 3, 6, 1, 5, 5, 7, 1 };
    9190             : const heim_oid asn1_oid_id_pkix_pe = { 8, oid_id_pkix_pe_variable_num };
    9191             : 
    9192             : static unsigned oid_id_pkix_pe_authorityInfoAccess_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 1, 1 };
    9193             : const heim_oid asn1_oid_id_pkix_pe_authorityInfoAccess = { 9, oid_id_pkix_pe_authorityInfoAccess_variable_num };
    9194             : 
    9195             : int ASN1CALL
    9196           0 : encode_AccessDescription(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AccessDescription *data, size_t *size)
    9197             : {
    9198           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    9199             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9200             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    9201             : 
    9202             : /* accessLocation */
    9203             : {
    9204           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    9205           0 : ret = 0;
    9206           0 : e = encode_GeneralName(p, len, &(data)->accessLocation, &l);
    9207           0 : if (e) return e;
    9208           0 : p -= l; len -= l; ret += l;
    9209             : 
    9210           0 : ret += Top_tag_oldret;
    9211             : }
    9212             : /* accessMethod */
    9213             : {
    9214           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    9215           0 : ret = 0;
    9216           0 : e = der_put_oid(p, len, &(data)->accessMethod, &l);
    9217           0 : if (e) return e;
    9218           0 : p -= l; len -= l; ret += l;
    9219             : 
    9220           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
    9221           0 : if (e) return e;
    9222           0 : p -= l; len -= l; ret += l;
    9223             : 
    9224           0 : ret += Top_tag_oldret;
    9225             : }
    9226           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    9227           0 : if (e) return e;
    9228           0 : p -= l; len -= l; ret += l;
    9229             : 
    9230           0 : *size = ret;
    9231           0 : return 0;
    9232             : }
    9233             : 
    9234             : int ASN1CALL
    9235           0 : decode_AccessDescription(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AccessDescription *data, size_t *size)
    9236             : {
    9237           0 : size_t ret = 0;
    9238             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9239             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    9240             : 
    9241           0 : memset(data, 0, sizeof(*data));
    9242             : {
    9243             : size_t Top_datalen, Top_oldlen;
    9244             : Der_type Top_type;
    9245           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    9246           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    9247           0 : if(e) goto fail;
    9248           0 : p += l; len -= l; ret += l;
    9249           0 : Top_oldlen = len;
    9250           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9251           0 : len = Top_datalen;
    9252             : {
    9253             : size_t accessMethod_datalen, accessMethod_oldlen;
    9254             : Der_type accessMethod_type;
    9255           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &accessMethod_type, UT_OID, &accessMethod_datalen, &l);
    9256           0 : if (e == 0 && accessMethod_type != PRIM) { e = ASN1_BAD_ID; }
    9257           0 : if(e) goto fail;
    9258           0 : p += l; len -= l; ret += l;
    9259           0 : accessMethod_oldlen = len;
    9260           0 : if (accessMethod_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9261           0 : len = accessMethod_datalen;
    9262           0 : e = der_get_oid(p, len, &(data)->accessMethod, &l);
    9263           0 : if(e) goto fail;
    9264           0 : p += l; len -= l; ret += l;
    9265           0 : len = accessMethod_oldlen - accessMethod_datalen;
    9266             : }
    9267           0 : e = decode_GeneralName(p, len, &(data)->accessLocation, &l);
    9268           0 : if(e) goto fail;
    9269           0 : p += l; len -= l; ret += l;
    9270           0 : len = Top_oldlen - Top_datalen;
    9271             : }
    9272           0 : if(size) *size = ret;
    9273           0 : return 0;
    9274           0 : fail:
    9275           0 : free_AccessDescription(data);
    9276           0 : return e;
    9277             : }
    9278             : 
    9279             : void ASN1CALL
    9280           0 : free_AccessDescription(AccessDescription *data)
    9281             : {
    9282           0 : der_free_oid(&(data)->accessMethod);
    9283           0 : free_GeneralName(&(data)->accessLocation);
    9284           0 : }
    9285             : 
    9286             : size_t ASN1CALL
    9287           0 : length_AccessDescription(const AccessDescription *data)
    9288             : {
    9289           0 : size_t ret = 0;
    9290             : {
    9291           0 : size_t Top_tag_oldret = ret;
    9292           0 : ret = 0;
    9293           0 : ret += der_length_oid(&(data)->accessMethod);
    9294           0 : ret += 1 + der_length_len (ret);
    9295           0 : ret += Top_tag_oldret;
    9296             : }
    9297             : {
    9298           0 : size_t Top_tag_oldret = ret;
    9299           0 : ret = 0;
    9300           0 : ret += length_GeneralName(&(data)->accessLocation);
    9301           0 : ret += Top_tag_oldret;
    9302             : }
    9303           0 : ret += 1 + der_length_len (ret);
    9304           0 : return ret;
    9305             : }
    9306             : 
    9307             : int ASN1CALL
    9308           0 : copy_AccessDescription(const AccessDescription *from, AccessDescription *to)
    9309             : {
    9310           0 : memset(to, 0, sizeof(*to));
    9311           0 : if(der_copy_oid(&(from)->accessMethod, &(to)->accessMethod)) goto fail;
    9312           0 : if(copy_GeneralName(&(from)->accessLocation, &(to)->accessLocation)) goto fail;
    9313           0 : return 0;
    9314           0 : fail:
    9315           0 : free_AccessDescription(to);
    9316           0 : return ENOMEM;
    9317             : }
    9318             : 
    9319             : int ASN1CALL
    9320           0 : encode_AuthorityInfoAccessSyntax(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const AuthorityInfoAccessSyntax *data, size_t *size)
    9321             : {
    9322           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    9323             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9324             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    9325             : 
    9326           0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
    9327           0 : size_t Top_tag_for_oldret = ret;
    9328           0 : ret = 0;
    9329           0 : e = encode_AccessDescription(p, len, &(data)->val[i], &l);
    9330           0 : if (e) return e;
    9331           0 : p -= l; len -= l; ret += l;
    9332             : 
    9333           0 : ret += Top_tag_for_oldret;
    9334             : }
    9335           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    9336           0 : if (e) return e;
    9337           0 : p -= l; len -= l; ret += l;
    9338             : 
    9339           0 : *size = ret;
    9340           0 : return 0;
    9341             : }
    9342             : 
    9343             : int ASN1CALL
    9344           0 : decode_AuthorityInfoAccessSyntax(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, AuthorityInfoAccessSyntax *data, size_t *size)
    9345             : {
    9346           0 : size_t ret = 0;
    9347             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9348             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    9349             : 
    9350           0 : memset(data, 0, sizeof(*data));
    9351             : {
    9352             : size_t Top_datalen, Top_oldlen;
    9353             : Der_type Top_type;
    9354           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    9355           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    9356           0 : if(e) goto fail;
    9357           0 : p += l; len -= l; ret += l;
    9358           0 : Top_oldlen = len;
    9359           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9360           0 : len = Top_datalen;
    9361             : {
    9362           0 : size_t Top_Tag_origlen = len;
    9363           0 : size_t Top_Tag_oldret = ret;
    9364           0 : size_t Top_Tag_olen = 0;
    9365             : void *Top_Tag_tmp;
    9366           0 : ret = 0;
    9367           0 : (data)->len = 0;
    9368           0 : (data)->val = NULL;
    9369           0 : while(ret < Top_Tag_origlen) {
    9370           0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
    9371           0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
    9372           0 : Top_Tag_olen = Top_Tag_nlen;
    9373           0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
    9374           0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
    9375           0 : (data)->val = Top_Tag_tmp;
    9376           0 : e = decode_AccessDescription(p, len, &(data)->val[(data)->len], &l);
    9377           0 : if(e) goto fail;
    9378           0 : p += l; len -= l; ret += l;
    9379           0 : (data)->len++;
    9380           0 : len = Top_Tag_origlen - ret;
    9381             : }
    9382           0 : ret += Top_Tag_oldret;
    9383             : }
    9384           0 : if ((data)->len < 1) {
    9385           0 : e = ASN1_MIN_CONSTRAINT; goto fail;
    9386             : }
    9387           0 : len = Top_oldlen - Top_datalen;
    9388             : }
    9389           0 : if(size) *size = ret;
    9390           0 : return 0;
    9391           0 : fail:
    9392           0 : free_AuthorityInfoAccessSyntax(data);
    9393           0 : return e;
    9394             : }
    9395             : 
    9396             : void ASN1CALL
    9397           0 : free_AuthorityInfoAccessSyntax(AuthorityInfoAccessSyntax *data)
    9398             : {
    9399           0 : while((data)->len){
    9400           0 : free_AccessDescription(&(data)->val[(data)->len-1]);
    9401           0 : (data)->len--;
    9402             : }
    9403           0 : free((data)->val);
    9404           0 : (data)->val = NULL;
    9405           0 : }
    9406             : 
    9407             : size_t ASN1CALL
    9408           0 : length_AuthorityInfoAccessSyntax(const AuthorityInfoAccessSyntax *data)
    9409             : {
    9410           0 : size_t ret = 0;
    9411             : {
    9412           0 : size_t Top_tag_oldret = ret;
    9413             : int i;
    9414           0 : ret = 0;
    9415           0 : for(i = (data)->len - 1; i >= 0; --i){
    9416           0 : size_t Top_tag_for_oldret = ret;
    9417           0 : ret = 0;
    9418           0 : ret += length_AccessDescription(&(data)->val[i]);
    9419           0 : ret += Top_tag_for_oldret;
    9420             : }
    9421           0 : ret += Top_tag_oldret;
    9422             : }
    9423           0 : ret += 1 + der_length_len (ret);
    9424           0 : return ret;
    9425             : }
    9426             : 
    9427             : int ASN1CALL
    9428           0 : copy_AuthorityInfoAccessSyntax(const AuthorityInfoAccessSyntax *from, AuthorityInfoAccessSyntax *to)
    9429             : {
    9430           0 : memset(to, 0, sizeof(*to));
    9431           0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
    9432           0 : goto fail;
    9433           0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
    9434           0 : if(copy_AccessDescription(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
    9435             : }
    9436           0 : return 0;
    9437           0 : fail:
    9438           0 : free_AuthorityInfoAccessSyntax(to);
    9439           0 : return ENOMEM;
    9440             : }
    9441             : 
    9442             : static unsigned oid_id_pkix_pe_proxyCertInfo_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 1, 14 };
    9443             : const heim_oid asn1_oid_id_pkix_pe_proxyCertInfo = { 9, oid_id_pkix_pe_proxyCertInfo_variable_num };
    9444             : 
    9445             : static unsigned oid_id_pkix_ppl_variable_num[8] =  {1, 3, 6, 1, 5, 5, 7, 21 };
    9446             : const heim_oid asn1_oid_id_pkix_ppl = { 8, oid_id_pkix_ppl_variable_num };
    9447             : 
    9448             : static unsigned oid_id_pkix_ppl_anyLanguage_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 21, 0 };
    9449             : const heim_oid asn1_oid_id_pkix_ppl_anyLanguage = { 9, oid_id_pkix_ppl_anyLanguage_variable_num };
    9450             : 
    9451             : static unsigned oid_id_pkix_ppl_inheritAll_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 21, 1 };
    9452             : const heim_oid asn1_oid_id_pkix_ppl_inheritAll = { 9, oid_id_pkix_ppl_inheritAll_variable_num };
    9453             : 
    9454             : static unsigned oid_id_pkix_ppl_independent_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 21, 2 };
    9455             : const heim_oid asn1_oid_id_pkix_ppl_independent = { 9, oid_id_pkix_ppl_independent_variable_num };
    9456             : 
    9457             : int ASN1CALL
    9458           0 : encode_ProxyPolicy(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ProxyPolicy *data, size_t *size)
    9459             : {
    9460           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    9461             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9462             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    9463             : 
    9464             : /* policy */
    9465           0 : if((data)->policy) {
    9466           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    9467           0 : ret = 0;
    9468           0 : e = der_put_octet_string(p, len, (data)->policy, &l);
    9469           0 : if (e) return e;
    9470           0 : p -= l; len -= l; ret += l;
    9471             : 
    9472           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
    9473           0 : if (e) return e;
    9474           0 : p -= l; len -= l; ret += l;
    9475             : 
    9476           0 : ret += Top_tag_oldret;
    9477             : }
    9478             : /* policyLanguage */
    9479             : {
    9480           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    9481           0 : ret = 0;
    9482           0 : e = der_put_oid(p, len, &(data)->policyLanguage, &l);
    9483           0 : if (e) return e;
    9484           0 : p -= l; len -= l; ret += l;
    9485             : 
    9486           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
    9487           0 : if (e) return e;
    9488           0 : p -= l; len -= l; ret += l;
    9489             : 
    9490           0 : ret += Top_tag_oldret;
    9491             : }
    9492           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    9493           0 : if (e) return e;
    9494           0 : p -= l; len -= l; ret += l;
    9495             : 
    9496           0 : *size = ret;
    9497           0 : return 0;
    9498             : }
    9499             : 
    9500             : int ASN1CALL
    9501           0 : decode_ProxyPolicy(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ProxyPolicy *data, size_t *size)
    9502             : {
    9503           0 : size_t ret = 0;
    9504             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9505             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    9506             : 
    9507           0 : memset(data, 0, sizeof(*data));
    9508             : {
    9509             : size_t Top_datalen, Top_oldlen;
    9510             : Der_type Top_type;
    9511           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    9512           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    9513           0 : if(e) goto fail;
    9514           0 : p += l; len -= l; ret += l;
    9515           0 : Top_oldlen = len;
    9516           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9517           0 : len = Top_datalen;
    9518             : {
    9519             : size_t policyLanguage_datalen, policyLanguage_oldlen;
    9520             : Der_type policyLanguage_type;
    9521           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &policyLanguage_type, UT_OID, &policyLanguage_datalen, &l);
    9522           0 : if (e == 0 && policyLanguage_type != PRIM) { e = ASN1_BAD_ID; }
    9523           0 : if(e) goto fail;
    9524           0 : p += l; len -= l; ret += l;
    9525           0 : policyLanguage_oldlen = len;
    9526           0 : if (policyLanguage_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9527           0 : len = policyLanguage_datalen;
    9528           0 : e = der_get_oid(p, len, &(data)->policyLanguage, &l);
    9529           0 : if(e) goto fail;
    9530           0 : p += l; len -= l; ret += l;
    9531           0 : len = policyLanguage_oldlen - policyLanguage_datalen;
    9532             : }
    9533             : {
    9534             : size_t policy_datalen, policy_oldlen;
    9535             : Der_type policy_type;
    9536           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &policy_type, UT_OctetString, &policy_datalen, &l);
    9537           0 : if (e == 0 && policy_type != PRIM) { e = ASN1_BAD_ID; }
    9538           0 : if(e) {
    9539           0 : (data)->policy = NULL;
    9540             : } else {
    9541           0 : (data)->policy = calloc(1, sizeof(*(data)->policy));
    9542           0 : if ((data)->policy == NULL) { e = ENOMEM; goto fail; }
    9543           0 : p += l; len -= l; ret += l;
    9544           0 : policy_oldlen = len;
    9545           0 : if (policy_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9546           0 : len = policy_datalen;
    9547           0 : e = der_get_octet_string(p, len, (data)->policy, &l);
    9548           0 : if(e) goto fail;
    9549           0 : p += l; len -= l; ret += l;
    9550           0 : len = policy_oldlen - policy_datalen;
    9551             : }
    9552             : }
    9553           0 : len = Top_oldlen - Top_datalen;
    9554             : }
    9555           0 : if(size) *size = ret;
    9556           0 : return 0;
    9557           0 : fail:
    9558           0 : free_ProxyPolicy(data);
    9559           0 : return e;
    9560             : }
    9561             : 
    9562             : void ASN1CALL
    9563           0 : free_ProxyPolicy(ProxyPolicy *data)
    9564             : {
    9565           0 : der_free_oid(&(data)->policyLanguage);
    9566           0 : if((data)->policy) {
    9567           0 : der_free_octet_string((data)->policy);
    9568           0 : free((data)->policy);
    9569           0 : (data)->policy = NULL;
    9570             : }
    9571           0 : }
    9572             : 
    9573             : size_t ASN1CALL
    9574           0 : length_ProxyPolicy(const ProxyPolicy *data)
    9575             : {
    9576           0 : size_t ret = 0;
    9577             : {
    9578           0 : size_t Top_tag_oldret = ret;
    9579           0 : ret = 0;
    9580           0 : ret += der_length_oid(&(data)->policyLanguage);
    9581           0 : ret += 1 + der_length_len (ret);
    9582           0 : ret += Top_tag_oldret;
    9583             : }
    9584           0 : if((data)->policy){
    9585           0 : size_t Top_tag_oldret = ret;
    9586           0 : ret = 0;
    9587           0 : ret += der_length_octet_string((data)->policy);
    9588           0 : ret += 1 + der_length_len (ret);
    9589           0 : ret += Top_tag_oldret;
    9590             : }
    9591           0 : ret += 1 + der_length_len (ret);
    9592           0 : return ret;
    9593             : }
    9594             : 
    9595             : int ASN1CALL
    9596           0 : copy_ProxyPolicy(const ProxyPolicy *from, ProxyPolicy *to)
    9597             : {
    9598           0 : memset(to, 0, sizeof(*to));
    9599           0 : if(der_copy_oid(&(from)->policyLanguage, &(to)->policyLanguage)) goto fail;
    9600           0 : if((from)->policy) {
    9601           0 : (to)->policy = malloc(sizeof(*(to)->policy));
    9602           0 : if((to)->policy == NULL) goto fail;
    9603           0 : if(der_copy_octet_string((from)->policy, (to)->policy)) goto fail;
    9604             : }else
    9605           0 : (to)->policy = NULL;
    9606           0 : return 0;
    9607           0 : fail:
    9608           0 : free_ProxyPolicy(to);
    9609           0 : return ENOMEM;
    9610             : }
    9611             : 
    9612             : int ASN1CALL
    9613           0 : encode_ProxyCertInfo(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ProxyCertInfo *data, size_t *size)
    9614             : {
    9615           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    9616             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9617             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    9618             : 
    9619             : /* proxyPolicy */
    9620             : {
    9621           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    9622           0 : ret = 0;
    9623           0 : e = encode_ProxyPolicy(p, len, &(data)->proxyPolicy, &l);
    9624           0 : if (e) return e;
    9625           0 : p -= l; len -= l; ret += l;
    9626             : 
    9627           0 : ret += Top_tag_oldret;
    9628             : }
    9629             : /* pCPathLenConstraint */
    9630           0 : if((data)->pCPathLenConstraint) {
    9631           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    9632           0 : ret = 0;
    9633           0 : e = der_put_unsigned(p, len, (data)->pCPathLenConstraint, &l);
    9634           0 : if (e) return e;
    9635           0 : p -= l; len -= l; ret += l;
    9636             : 
    9637           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer, &l);
    9638           0 : if (e) return e;
    9639           0 : p -= l; len -= l; ret += l;
    9640             : 
    9641           0 : ret += Top_tag_oldret;
    9642             : }
    9643           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    9644           0 : if (e) return e;
    9645           0 : p -= l; len -= l; ret += l;
    9646             : 
    9647           0 : *size = ret;
    9648           0 : return 0;
    9649             : }
    9650             : 
    9651             : int ASN1CALL
    9652           0 : decode_ProxyCertInfo(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ProxyCertInfo *data, size_t *size)
    9653             : {
    9654           0 : size_t ret = 0;
    9655             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    9656             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    9657             : 
    9658           0 : memset(data, 0, sizeof(*data));
    9659             : {
    9660             : size_t Top_datalen, Top_oldlen;
    9661             : Der_type Top_type;
    9662           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    9663           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    9664           0 : if(e) goto fail;
    9665           0 : p += l; len -= l; ret += l;
    9666           0 : Top_oldlen = len;
    9667           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9668           0 : len = Top_datalen;
    9669             : {
    9670             : size_t pCPathLenConstraint_datalen, pCPathLenConstraint_oldlen;
    9671             : Der_type pCPathLenConstraint_type;
    9672           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &pCPathLenConstraint_type, UT_Integer, &pCPathLenConstraint_datalen, &l);
    9673           0 : if (e == 0 && pCPathLenConstraint_type != PRIM) { e = ASN1_BAD_ID; }
    9674           0 : if(e) {
    9675           0 : (data)->pCPathLenConstraint = NULL;
    9676             : } else {
    9677           0 : (data)->pCPathLenConstraint = calloc(1, sizeof(*(data)->pCPathLenConstraint));
    9678           0 : if ((data)->pCPathLenConstraint == NULL) { e = ENOMEM; goto fail; }
    9679           0 : p += l; len -= l; ret += l;
    9680           0 : pCPathLenConstraint_oldlen = len;
    9681           0 : if (pCPathLenConstraint_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    9682           0 : len = pCPathLenConstraint_datalen;
    9683           0 : e = der_get_unsigned(p, len, (data)->pCPathLenConstraint, &l);
    9684           0 : if(e) goto fail;
    9685           0 : p += l; len -= l; ret += l;
    9686           0 : len = pCPathLenConstraint_oldlen - pCPathLenConstraint_datalen;
    9687             : }
    9688             : }
    9689           0 : e = decode_ProxyPolicy(p, len, &(data)->proxyPolicy, &l);
    9690           0 : if(e) goto fail;
    9691           0 : p += l; len -= l; ret += l;
    9692           0 : len = Top_oldlen - Top_datalen;
    9693             : }
    9694           0 : if(size) *size = ret;
    9695           0 : return 0;
    9696           0 : fail:
    9697           0 : free_ProxyCertInfo(data);
    9698           0 : return e;
    9699             : }
    9700             : 
    9701             : void ASN1CALL
    9702           0 : free_ProxyCertInfo(ProxyCertInfo *data)
    9703             : {
    9704           0 : if((data)->pCPathLenConstraint) {
    9705           0 : free((data)->pCPathLenConstraint);
    9706           0 : (data)->pCPathLenConstraint = NULL;
    9707             : }
    9708           0 : free_ProxyPolicy(&(data)->proxyPolicy);
    9709           0 : }
    9710             : 
    9711             : size_t ASN1CALL
    9712           0 : length_ProxyCertInfo(const ProxyCertInfo *data)
    9713             : {
    9714           0 : size_t ret = 0;
    9715           0 : if((data)->pCPathLenConstraint){
    9716           0 : size_t Top_tag_oldret = ret;
    9717           0 : ret = 0;
    9718           0 : ret += der_length_unsigned((data)->pCPathLenConstraint);
    9719           0 : ret += 1 + der_length_len (ret);
    9720           0 : ret += Top_tag_oldret;
    9721             : }
    9722             : {
    9723           0 : size_t Top_tag_oldret = ret;
    9724           0 : ret = 0;
    9725           0 : ret += length_ProxyPolicy(&(data)->proxyPolicy);
    9726           0 : ret += Top_tag_oldret;
    9727             : }
    9728           0 : ret += 1 + der_length_len (ret);
    9729           0 : return ret;
    9730             : }
    9731             : 
    9732             : int ASN1CALL
    9733           0 : copy_ProxyCertInfo(const ProxyCertInfo *from, ProxyCertInfo *to)
    9734             : {
    9735           0 : memset(to, 0, sizeof(*to));
    9736           0 : if((from)->pCPathLenConstraint) {
    9737           0 : (to)->pCPathLenConstraint = malloc(sizeof(*(to)->pCPathLenConstraint));
    9738           0 : if((to)->pCPathLenConstraint == NULL) goto fail;
    9739           0 : *((to)->pCPathLenConstraint) = *((from)->pCPathLenConstraint);
    9740             : }else
    9741           0 : (to)->pCPathLenConstraint = NULL;
    9742           0 : if(copy_ProxyPolicy(&(from)->proxyPolicy, &(to)->proxyPolicy)) goto fail;
    9743           0 : return 0;
    9744           0 : fail:
    9745           0 : free_ProxyCertInfo(to);
    9746           0 : return ENOMEM;
    9747             : }
    9748             : 
    9749             : static unsigned oid_id_uspkicommon_card_id_variable_num[8] =  {2, 16, 840, 1, 101, 3, 6, 6 };
    9750             : const heim_oid asn1_oid_id_uspkicommon_card_id = { 8, oid_id_uspkicommon_card_id_variable_num };
    9751             : 
    9752             : static unsigned oid_id_uspkicommon_piv_interim_variable_num[9] =  {2, 16, 840, 1, 101, 3, 6, 9, 1 };
    9753             : const heim_oid asn1_oid_id_uspkicommon_piv_interim = { 9, oid_id_uspkicommon_piv_interim_variable_num };
    9754             : 
    9755             : static unsigned oid_id_netscape_variable_num[5] =  {2, 16, 840, 1, 113730 };
    9756             : const heim_oid asn1_oid_id_netscape = { 5, oid_id_netscape_variable_num };
    9757             : 
    9758             : static unsigned oid_id_netscape_cert_comment_variable_num[7] =  {2, 16, 840, 1, 113730, 1, 13 };
    9759             : const heim_oid asn1_oid_id_netscape_cert_comment = { 7, oid_id_netscape_cert_comment_variable_num };
    9760             : 
    9761             : static unsigned oid_id_ms_cert_enroll_domaincontroller_variable_num[9] =  {1, 3, 6, 1, 4, 1, 311, 20, 2 };
    9762             : const heim_oid asn1_oid_id_ms_cert_enroll_domaincontroller = { 9, oid_id_ms_cert_enroll_domaincontroller_variable_num };
    9763             : 
    9764             : static unsigned oid_id_ms_client_authentication_variable_num[9] =  {1, 3, 6, 1, 5, 5, 7, 3, 2 };
    9765             : const heim_oid asn1_oid_id_ms_client_authentication = { 9, oid_id_ms_client_authentication_variable_num };
    9766             : 

Generated by: LCOV version 1.13