LCOV - code coverage report
Current view: top level - lib - decoding.c (source / functions) Hit Total Coverage
Test: GNU Libtasn1 Lines: 772 1447 53.4 %
Date: 2013-03-24 Functions: 17 19 89.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 476 1036 45.9 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (C) 2002-2013 Free Software Foundation, Inc.
       3                 :            :  *
       4                 :            :  * This file is part of LIBTASN1.
       5                 :            :  *
       6                 :            :  * The LIBTASN1 library is free software; you can redistribute it
       7                 :            :  * and/or modify it under the terms of the GNU Lesser General Public
       8                 :            :  * License as published by the Free Software Foundation; either
       9                 :            :  * version 2.1 of the License, or (at your option) any later version.
      10                 :            :  *
      11                 :            :  * This library is distributed in the hope that it will be useful, but
      12                 :            :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14                 :            :  * Lesser General Public License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU Lesser General Public
      17                 :            :  * License along with this library; if not, write to the Free Software
      18                 :            :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
      19                 :            :  * 02110-1301, USA
      20                 :            :  */
      21                 :            : 
      22                 :            : 
      23                 :            : /*****************************************************/
      24                 :            : /* File: decoding.c                                  */
      25                 :            : /* Description: Functions to manage DER decoding     */
      26                 :            : /*****************************************************/
      27                 :            : 
      28                 :            : #include <int.h>
      29                 :            : #include <parser_aux.h>
      30                 :            : #include <gstr.h>
      31                 :            : #include <structure.h>
      32                 :            : #include <element.h>
      33                 :            : #include <limits.h>
      34                 :            : #include <intprops.h>
      35                 :            : 
      36                 :            : static int
      37                 :            : _asn1_get_indefinite_length_string (const unsigned char *der, int *len);
      38                 :            : 
      39                 :            : static void
      40                 :          0 : _asn1_error_description_tag_error (asn1_node node, char *ErrorDescription)
      41                 :            : {
      42                 :            : 
      43                 :          0 :   Estrcpy (ErrorDescription, ":: tag error near element '");
      44                 :          0 :   _asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
      45                 :            :                            ASN1_MAX_ERROR_DESCRIPTION_SIZE - 40);
      46                 :          0 :   Estrcat (ErrorDescription, "'");
      47                 :            : 
      48                 :          0 : }
      49                 :            : 
      50                 :            : /**
      51                 :            :  * asn1_get_length_der:
      52                 :            :  * @der: DER data to decode.
      53                 :            :  * @der_len: Length of DER data to decode.
      54                 :            :  * @len: Output variable containing the length of the DER length field.
      55                 :            :  *
      56                 :            :  * Extract a length field from DER data.
      57                 :            :  *
      58                 :            :  * Returns: Return the decoded length value, or -1 on indefinite
      59                 :            :  *   length, or -2 when the value was too big to fit in a int, or -4
      60                 :            :  *   when the decoded length value plus @len would exceed @der_len.
      61                 :            :  **/
      62                 :            : long
      63                 :        413 : asn1_get_length_der (const unsigned char *der, int der_len, int *len)
      64                 :            : {
      65                 :            :   unsigned int ans;
      66                 :            :   int k, punt, sum;
      67                 :            : 
      68                 :        413 :   *len = 0;
      69         [ -  + ]:        413 :   if (der_len <= 0)
      70                 :          0 :     return 0;
      71                 :            : 
      72         [ +  + ]:        413 :   if (!(der[0] & 128))
      73                 :            :     {
      74                 :            :       /* short form */
      75                 :        379 :       *len = 1;
      76                 :        379 :       ans = der[0];
      77                 :            :     }
      78                 :            :   else
      79                 :            :     {
      80                 :            :       /* Long form */
      81                 :         34 :       k = der[0] & 0x7F;
      82                 :         34 :       punt = 1;
      83         [ +  + ]:         34 :       if (k)
      84                 :            :         {                       /* definite length method */
      85                 :         20 :           ans = 0;
      86 [ +  + ][ +  - ]:         65 :           while (punt <= k && punt < der_len)
      87                 :            :             {
      88         [ +  + ]:         47 :               if (INT_MULTIPLY_OVERFLOW (ans, 256))
      89                 :          2 :                 return -2;
      90                 :         45 :               ans *= 256;
      91                 :            : 
      92         [ -  + ]:         45 :               if (INT_ADD_OVERFLOW (ans, ((unsigned) der[punt])))
      93                 :          0 :                 return -2;
      94                 :         45 :               ans += der[punt];
      95                 :         45 :               punt++;
      96                 :            :             }
      97                 :            :         }
      98                 :            :       else
      99                 :            :         {                       /* indefinite length method */
     100                 :         14 :           *len = punt;
     101                 :         14 :           return -1;
     102                 :            :         }
     103                 :            : 
     104                 :         18 :       *len = punt;
     105                 :            :     }
     106                 :            : 
     107                 :        397 :   sum = ans;
     108 [ +  + ][ -  + ]:        397 :   if (ans >= INT_MAX || INT_ADD_OVERFLOW (sum, (*len)))
         [ #  # ][ -  + ]
     109                 :          1 :     return -2;
     110                 :        396 :   sum += *len;
     111                 :            : 
     112         [ +  + ]:        396 :   if (sum > der_len)
     113                 :          3 :     return -4;
     114                 :            : 
     115                 :        413 :   return ans;
     116                 :            : }
     117                 :            : 
     118                 :            : /**
     119                 :            :  * asn1_get_tag_der:
     120                 :            :  * @der: DER data to decode.
     121                 :            :  * @der_len: Length of DER data to decode.
     122                 :            :  * @cls: Output variable containing decoded class.
     123                 :            :  * @len: Output variable containing the length of the DER TAG data.
     124                 :            :  * @tag: Output variable containing the decoded tag.
     125                 :            :  *
     126                 :            :  * Decode the class and TAG from DER code.
     127                 :            :  *
     128                 :            :  * Returns: Returns %ASN1_SUCCESS on success, or an error.
     129                 :            :  **/
     130                 :            : int
     131                 :        274 : asn1_get_tag_der (const unsigned char *der, int der_len,
     132                 :            :                   unsigned char *cls, int *len, unsigned long *tag)
     133                 :            : {
     134                 :            :   unsigned int ris;
     135                 :            :   int punt;
     136                 :            : 
     137 [ +  - ][ +  + ]:        274 :   if (der == NULL || der_len < 2 || len == NULL)
                 [ -  + ]
     138                 :          1 :     return ASN1_DER_ERROR;
     139                 :            : 
     140                 :        273 :   *cls = der[0] & 0xE0;
     141         [ +  - ]:        273 :   if ((der[0] & 0x1F) != 0x1F)
     142                 :            :     {
     143                 :            :       /* short form */
     144                 :        273 :       *len = 1;
     145                 :        273 :       ris = der[0] & 0x1F;
     146                 :            :     }
     147                 :            :   else
     148                 :            :     {
     149                 :            :       /* Long form */
     150                 :          0 :       punt = 1;
     151                 :          0 :       ris = 0;
     152 [ #  # ][ #  # ]:          0 :       while (punt <= der_len && der[punt] & 128)
     153                 :            :         {
     154                 :            : 
     155         [ #  # ]:          0 :           if (INT_MULTIPLY_OVERFLOW (ris, 128))
     156                 :          0 :             return ASN1_DER_ERROR;
     157                 :          0 :           ris *= 128;
     158                 :            : 
     159         [ #  # ]:          0 :           if (INT_ADD_OVERFLOW (ris, ((unsigned) (der[punt] & 0x7F))))
     160                 :          0 :             return ASN1_DER_ERROR;
     161                 :          0 :           ris += (der[punt] & 0x7F);
     162                 :          0 :           punt++;
     163                 :            :         }
     164                 :            : 
     165         [ #  # ]:          0 :       if (punt >= der_len)
     166                 :          0 :         return ASN1_DER_ERROR;
     167                 :            : 
     168         [ #  # ]:          0 :       if (INT_MULTIPLY_OVERFLOW (ris, 128))
     169                 :          0 :         return ASN1_DER_ERROR;
     170                 :          0 :       ris *= 128;
     171                 :            : 
     172         [ #  # ]:          0 :       if (INT_ADD_OVERFLOW (ris, ((unsigned) (der[punt] & 0x7F))))
     173                 :          0 :         return ASN1_DER_ERROR;
     174                 :          0 :       ris += (der[punt] & 0x7F);
     175                 :          0 :       punt++;
     176                 :            : 
     177                 :          0 :       *len = punt;
     178                 :            :     }
     179                 :            : 
     180         [ +  + ]:        273 :   if (tag)
     181                 :        262 :     *tag = ris;
     182                 :        274 :   return ASN1_SUCCESS;
     183                 :            : }
     184                 :            : 
     185                 :            : /**
     186                 :            :  * asn1_get_length_ber:
     187                 :            :  * @ber: BER data to decode.
     188                 :            :  * @ber_len: Length of BER data to decode.
     189                 :            :  * @len: Output variable containing the length of the BER length field.
     190                 :            :  *
     191                 :            :  * Extract a length field from BER data.  The difference to
     192                 :            :  * asn1_get_length_der() is that this function will return a length
     193                 :            :  * even if the value has indefinite encoding.
     194                 :            :  *
     195                 :            :  * Returns: Return the decoded length value, or negative value when
     196                 :            :  *   the value was too big.
     197                 :            :  *
     198                 :            :  * Since: 2.0
     199                 :            :  **/
     200                 :            : long
     201                 :         10 : asn1_get_length_ber (const unsigned char *ber, int ber_len, int *len)
     202                 :            : {
     203                 :            :   int ret;
     204                 :            :   long err;
     205                 :            : 
     206                 :         10 :   ret = asn1_get_length_der (ber, ber_len, len);
     207         [ +  + ]:         10 :   if (ret == -1)
     208                 :            :     {                           /* indefinite length method */
     209                 :          1 :       ret = ber_len;
     210                 :          1 :       err = _asn1_get_indefinite_length_string (ber + 1, &ret);
     211         [ -  + ]:          1 :       if (err != ASN1_SUCCESS)
     212                 :          0 :         return -3;
     213                 :            :     }
     214                 :            : 
     215                 :         10 :   return ret;
     216                 :            : }
     217                 :            : 
     218                 :            : /**
     219                 :            :  * asn1_get_octet_der:
     220                 :            :  * @der: DER data to decode containing the OCTET SEQUENCE.
     221                 :            :  * @der_len: Length of DER data to decode.
     222                 :            :  * @ret_len: Output variable containing the length of the DER data.
     223                 :            :  * @str: Pre-allocated output buffer to put decoded OCTET SEQUENCE in.
     224                 :            :  * @str_size: Length of pre-allocated output buffer.
     225                 :            :  * @str_len: Output variable containing the length of the OCTET SEQUENCE.
     226                 :            :  *
     227                 :            :  * Extract an OCTET SEQUENCE from DER data.
     228                 :            :  *
     229                 :            :  * Returns: Returns %ASN1_SUCCESS on success, or an error.
     230                 :            :  **/
     231                 :            : int
     232                 :          9 : asn1_get_octet_der (const unsigned char *der, int der_len,
     233                 :            :                     int *ret_len, unsigned char *str, int str_size,
     234                 :            :                     int *str_len)
     235                 :            : {
     236                 :            :   int len_len;
     237                 :            : 
     238         [ -  + ]:          9 :   if (der_len <= 0)
     239                 :          0 :     return ASN1_GENERIC_ERROR;
     240                 :            : 
     241                 :            :   /* if(str==NULL) return ASN1_SUCCESS; */
     242                 :          9 :   *str_len = asn1_get_length_der (der, der_len, &len_len);
     243                 :            : 
     244         [ -  + ]:          9 :   if (*str_len < 0)
     245                 :          0 :     return ASN1_DER_ERROR;
     246                 :            : 
     247                 :          9 :   *ret_len = *str_len + len_len;
     248         [ +  + ]:          9 :   if (str_size >= *str_len)
     249                 :          4 :     memcpy (str, der + len_len, *str_len);
     250                 :            :   else
     251                 :            :     {
     252                 :          9 :       return ASN1_MEM_ERROR;
     253                 :            :     }
     254                 :            : 
     255                 :          4 :   return ASN1_SUCCESS;
     256                 :            : }
     257                 :            : 
     258                 :            : /* Returns ASN1_SUCCESS on success or an error code on error.
     259                 :            :  */
     260                 :            : static int
     261                 :          4 : _asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
     262                 :            :                     char *str, int str_size)
     263                 :            : {
     264                 :            :   int len_len, str_len;
     265                 :            : 
     266 [ +  - ][ -  + ]:          4 :   if (der_len <= 0 || str == NULL)
     267                 :          0 :     return ASN1_DER_ERROR;
     268                 :          4 :   str_len = asn1_get_length_der (der, der_len, &len_len);
     269 [ +  - ][ -  + ]:          4 :   if (str_len < 0 || str_size < str_len)
     270                 :          0 :     return ASN1_DER_ERROR;
     271                 :          4 :   memcpy (str, der + len_len, str_len);
     272                 :          4 :   str[str_len] = 0;
     273                 :          4 :   *ret_len = str_len + len_len;
     274                 :            : 
     275                 :          4 :   return ASN1_SUCCESS;
     276                 :            : }
     277                 :            : 
     278                 :            : static int
     279                 :         26 : _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
     280                 :            :                         char *str, int str_size)
     281                 :            : {
     282                 :            :   int len_len, len, k;
     283                 :            :   int leading;
     284                 :            :   char temp[20];
     285                 :            :   unsigned long val, val1;
     286                 :            : 
     287                 :         26 :   *ret_len = 0;
     288 [ +  - ][ +  - ]:         26 :   if (str && str_size > 0)
     289                 :         26 :     str[0] = 0;                 /* no oid */
     290                 :            : 
     291 [ +  - ][ -  + ]:         26 :   if (str == NULL || der_len <= 0)
     292                 :          0 :     return ASN1_GENERIC_ERROR;
     293                 :            : 
     294                 :         26 :   len = asn1_get_length_der (der, der_len, &len_len);
     295                 :            : 
     296 [ +  - ][ +  - ]:         26 :   if (len < 0 || len > der_len || len_len > der_len)
                 [ -  + ]
     297                 :          0 :     return ASN1_DER_ERROR;
     298                 :            : 
     299                 :         26 :   val1 = der[len_len] / 40;
     300                 :         26 :   val = der[len_len] - val1 * 40;
     301                 :            : 
     302                 :         26 :   _asn1_str_cpy (str, str_size, _asn1_ltostr (val1, temp));
     303                 :         26 :   _asn1_str_cat (str, str_size, ".");
     304                 :         26 :   _asn1_str_cat (str, str_size, _asn1_ltostr (val, temp));
     305                 :            : 
     306                 :         26 :   val = 0;
     307                 :         26 :   leading = 1;
     308         [ +  + ]:        110 :   for (k = 1; k < len; k++)
     309                 :            :     {
     310                 :            :       /* X.690 mandates that the leading byte must never be 0x80
     311                 :            :        */
     312 [ +  + ][ -  + ]:         84 :       if (leading != 0 && der[len_len + k] == 0x80)
     313                 :          0 :         return ASN1_DER_ERROR;
     314                 :         84 :       leading = 0;
     315                 :            : 
     316                 :            :       /* check for wrap around */
     317         [ -  + ]:         84 :       if (INT_LEFT_SHIFT_OVERFLOW (val, 7))
     318                 :          0 :         return ASN1_DER_ERROR;
     319                 :            : 
     320                 :         84 :       val = val << 7;
     321                 :         84 :       val |= der[len_len + k] & 0x7F;
     322                 :            : 
     323         [ +  + ]:         84 :       if (!(der[len_len + k] & 0x80))
     324                 :            :         {
     325                 :         69 :           _asn1_str_cat (str, str_size, ".");
     326                 :         69 :           _asn1_str_cat (str, str_size, _asn1_ltostr (val, temp));
     327                 :         69 :           val = 0;
     328                 :         69 :           leading = 1;
     329                 :            :         }
     330                 :            :     }
     331                 :            : 
     332 [ -  + ][ -  + ]:         26 :   if (INT_ADD_OVERFLOW (len, len_len))
     333                 :          0 :     return ASN1_DER_ERROR;
     334                 :            : 
     335                 :         26 :   *ret_len = len + len_len;
     336                 :            : 
     337                 :         26 :   return ASN1_SUCCESS;
     338                 :            : }
     339                 :            : 
     340                 :            : /**
     341                 :            :  * asn1_get_bit_der:
     342                 :            :  * @der: DER data to decode containing the BIT SEQUENCE.
     343                 :            :  * @der_len: Length of DER data to decode.
     344                 :            :  * @ret_len: Output variable containing the length of the DER data.
     345                 :            :  * @str: Pre-allocated output buffer to put decoded BIT SEQUENCE in.
     346                 :            :  * @str_size: Length of pre-allocated output buffer.
     347                 :            :  * @bit_len: Output variable containing the size of the BIT SEQUENCE.
     348                 :            :  *
     349                 :            :  * Extract a BIT SEQUENCE from DER data.
     350                 :            :  *
     351                 :            :  * Returns: Return %ASN1_SUCCESS on success, or an error.
     352                 :            :  **/
     353                 :            : int
     354                 :         45 : asn1_get_bit_der (const unsigned char *der, int der_len,
     355                 :            :                   int *ret_len, unsigned char *str, int str_size,
     356                 :            :                   int *bit_len)
     357                 :            : {
     358                 :            :   int len_len, len_byte;
     359                 :            : 
     360         [ +  + ]:         45 :   if (der_len <= 0)
     361                 :          1 :     return ASN1_GENERIC_ERROR;
     362                 :         44 :   len_byte = asn1_get_length_der (der, der_len, &len_len) - 1;
     363         [ -  + ]:         44 :   if (len_byte < 0)
     364                 :          0 :     return ASN1_DER_ERROR;
     365                 :            : 
     366                 :         44 :   *ret_len = len_byte + len_len + 1;
     367                 :         44 :   *bit_len = len_byte * 8 - der[len_len];
     368                 :            : 
     369         [ +  + ]:         44 :   if (str_size >= len_byte)
     370                 :         43 :     memcpy (str, der + len_len + 1, len_byte);
     371                 :            :   else
     372                 :            :     {
     373                 :         45 :       return ASN1_MEM_ERROR;
     374                 :            :     }
     375                 :            : 
     376                 :         43 :   return ASN1_SUCCESS;
     377                 :            : }
     378                 :            : 
     379                 :            : static int
     380                 :        225 : _asn1_extract_tag_der (asn1_node node, const unsigned char *der, int der_len,
     381                 :            :                        int *ret_len)
     382                 :            : {
     383                 :            :   asn1_node p;
     384                 :            :   int counter, len2, len3, is_tag_implicit;
     385                 :        225 :   unsigned long tag, tag_implicit = 0;
     386                 :        225 :   unsigned char class, class2, class_implicit = 0;
     387                 :            : 
     388         [ -  + ]:        225 :   if (der_len <= 0)
     389                 :          0 :     return ASN1_GENERIC_ERROR;
     390                 :            : 
     391                 :        225 :   counter = is_tag_implicit = 0;
     392                 :            : 
     393         [ +  + ]:        225 :   if (node->type & CONST_TAG)
     394                 :            :     {
     395                 :         39 :       p = node->down;
     396         [ +  + ]:        127 :       while (p)
     397                 :            :         {
     398         [ +  + ]:         88 :           if (type_field (p->type) == ASN1_ETYPE_TAG)
     399                 :            :             {
     400         [ +  + ]:         41 :               if (p->type & CONST_APPLICATION)
     401                 :          1 :                 class2 = ASN1_CLASS_APPLICATION;
     402         [ -  + ]:         40 :               else if (p->type & CONST_UNIVERSAL)
     403                 :          0 :                 class2 = ASN1_CLASS_UNIVERSAL;
     404         [ -  + ]:         40 :               else if (p->type & CONST_PRIVATE)
     405                 :          0 :                 class2 = ASN1_CLASS_PRIVATE;
     406                 :            :               else
     407                 :         40 :                 class2 = ASN1_CLASS_CONTEXT_SPECIFIC;
     408                 :            : 
     409         [ +  + ]:         41 :               if (p->type & CONST_EXPLICIT)
     410                 :            :                 {
     411         [ -  + ]:         10 :                   if (asn1_get_tag_der
     412                 :         10 :                       (der + counter, der_len - counter, &class, &len2,
     413                 :            :                        &tag) != ASN1_SUCCESS)
     414                 :          0 :                     return ASN1_DER_ERROR;
     415                 :            : 
     416         [ -  + ]:         10 :                   if (counter + len2 > der_len)
     417                 :          0 :                     return ASN1_DER_ERROR;
     418                 :         10 :                   counter += len2;
     419                 :            : 
     420                 :         10 :                   len3 =
     421                 :         10 :                     asn1_get_length_ber (der + counter, der_len - counter,
     422                 :            :                                          &len2);
     423         [ -  + ]:         10 :                   if (len3 < 0)
     424                 :          0 :                     return ASN1_DER_ERROR;
     425                 :            : 
     426                 :         10 :                   counter += len2;
     427         [ -  + ]:         10 :                   if (counter > der_len)
     428                 :          0 :                     return ASN1_DER_ERROR;
     429                 :            : 
     430         [ +  - ]:         10 :                   if (!is_tag_implicit)
     431                 :            :                     {
     432   [ +  -  -  + ]:         20 :                       if ((class != (class2 | ASN1_CLASS_STRUCTURED)) ||
     433                 :         10 :                           (tag != strtoul ((char *) p->value, NULL, 10)))
     434                 :          0 :                         return ASN1_TAG_ERROR;
     435                 :            :                     }
     436                 :            :                   else
     437                 :            :                     {           /* ASN1_TAG_IMPLICIT */
     438 [ #  # ][ #  # ]:          0 :                       if ((class != class_implicit) || (tag != tag_implicit))
     439                 :          0 :                         return ASN1_TAG_ERROR;
     440                 :            :                     }
     441                 :         10 :                   is_tag_implicit = 0;
     442                 :            :                 }
     443                 :            :               else
     444                 :            :                 {               /* ASN1_TAG_IMPLICIT */
     445         [ +  - ]:         31 :                   if (!is_tag_implicit)
     446                 :            :                     {
     447   [ +  +  +  - ]:         51 :                       if ((type_field (node->type) == ASN1_ETYPE_SEQUENCE) ||
     448                 :         20 :                           (type_field (node->type) == ASN1_ETYPE_SEQUENCE_OF)
     449         [ +  - ]:         20 :                           || (type_field (node->type) == ASN1_ETYPE_SET)
     450         [ +  + ]:         20 :                           || (type_field (node->type) == ASN1_ETYPE_SET_OF))
     451                 :         13 :                         class2 |= ASN1_CLASS_STRUCTURED;
     452                 :         31 :                       class_implicit = class2;
     453                 :         31 :                       tag_implicit = strtoul ((char *) p->value, NULL, 10);
     454                 :         31 :                       is_tag_implicit = 1;
     455                 :            :                     }
     456                 :            :                 }
     457                 :            :             }
     458                 :         88 :           p = p->right;
     459                 :            :         }
     460                 :            :     }
     461                 :            : 
     462         [ +  + ]:        225 :   if (is_tag_implicit)
     463                 :            :     {
     464         [ -  + ]:         31 :       if (asn1_get_tag_der
     465                 :         31 :           (der + counter, der_len - counter, &class, &len2,
     466                 :            :            &tag) != ASN1_SUCCESS)
     467                 :          0 :         return ASN1_DER_ERROR;
     468         [ -  + ]:         31 :       if (counter + len2 > der_len)
     469                 :          0 :         return ASN1_DER_ERROR;
     470                 :            : 
     471 [ +  + ][ +  + ]:         31 :       if ((class != class_implicit) || (tag != tag_implicit))
     472                 :            :         {
     473         [ -  + ]:         11 :           if (type_field (node->type) == ASN1_ETYPE_OCTET_STRING)
     474                 :            :             {
     475                 :          0 :               class_implicit |= ASN1_CLASS_STRUCTURED;
     476 [ #  # ][ #  # ]:          0 :               if ((class != class_implicit) || (tag != tag_implicit))
     477                 :          0 :                 return ASN1_TAG_ERROR;
     478                 :            :             }
     479                 :            :           else
     480                 :         11 :             return ASN1_TAG_ERROR;
     481                 :            :         }
     482                 :            :     }
     483                 :            :   else
     484                 :            :     {
     485                 :        194 :       unsigned type = type_field (node->type);
     486         [ +  + ]:        194 :       if (type == ASN1_ETYPE_TAG)
     487                 :            :         {
     488                 :          6 :           counter = 0;
     489                 :          6 :           *ret_len = counter;
     490                 :          6 :           return ASN1_SUCCESS;
     491                 :            :         }
     492                 :            : 
     493         [ -  + ]:        188 :       if (asn1_get_tag_der
     494                 :        188 :           (der + counter, der_len - counter, &class, &len2,
     495                 :            :            &tag) != ASN1_SUCCESS)
     496                 :          0 :         return ASN1_DER_ERROR;
     497                 :            : 
     498         [ -  + ]:        188 :       if (counter + len2 > der_len)
     499                 :          0 :         return ASN1_DER_ERROR;
     500                 :            : 
     501   [ +  +  +  - ]:        188 :       switch (type)
     502                 :            :         {
     503                 :            :         case ASN1_ETYPE_NULL:
     504                 :            :         case ASN1_ETYPE_BOOLEAN:
     505                 :            :         case ASN1_ETYPE_INTEGER:
     506                 :            :         case ASN1_ETYPE_ENUMERATED:
     507                 :            :         case ASN1_ETYPE_OBJECT_ID:
     508                 :            :         case ASN1_ETYPE_GENERALSTRING:
     509                 :            :         case ASN1_ETYPE_NUMERIC_STRING:
     510                 :            :         case ASN1_ETYPE_IA5_STRING:
     511                 :            :         case ASN1_ETYPE_TELETEX_STRING:
     512                 :            :         case ASN1_ETYPE_PRINTABLE_STRING:
     513                 :            :         case ASN1_ETYPE_UNIVERSAL_STRING:
     514                 :            :         case ASN1_ETYPE_BMP_STRING:
     515                 :            :         case ASN1_ETYPE_UTF8_STRING:
     516                 :            :         case ASN1_ETYPE_VISIBLE_STRING:
     517                 :            :         case ASN1_ETYPE_BIT_STRING:
     518                 :            :         case ASN1_ETYPE_SEQUENCE:
     519                 :            :         case ASN1_ETYPE_SEQUENCE_OF:
     520                 :            :         case ASN1_ETYPE_SET:
     521                 :            :         case ASN1_ETYPE_SET_OF:
     522                 :            :         case ASN1_ETYPE_GENERALIZED_TIME:
     523                 :            :         case ASN1_ETYPE_UTC_TIME:
     524         [ +  - ]:        161 :           if ((class != _asn1_tags[type].class)
     525         [ +  + ]:        161 :               || (tag != _asn1_tags[type].tag))
     526                 :          3 :             return ASN1_DER_ERROR;
     527                 :        158 :           break;
     528                 :            : 
     529                 :            :         case ASN1_ETYPE_OCTET_STRING:
     530                 :            :           /* OCTET STRING is handled differently to allow
     531                 :            :            * BER encodings (structured class). */
     532         [ -  + ]:          8 :           if (((class != ASN1_CLASS_UNIVERSAL)
     533         [ #  # ]:          0 :                && (class != (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED)))
     534         [ -  + ]:          8 :               || (tag != ASN1_TAG_OCTET_STRING))
     535                 :          0 :             return ASN1_DER_ERROR;
     536                 :          8 :           break;
     537                 :            :         case ASN1_ETYPE_ANY:
     538                 :         19 :           counter -= len2;
     539                 :         19 :           break;
     540                 :            :         default:
     541                 :          0 :           return ASN1_DER_ERROR;
     542                 :            :           break;
     543                 :            :         }
     544                 :            :     }
     545                 :            : 
     546                 :        205 :   counter += len2;
     547                 :        205 :   *ret_len = counter;
     548                 :        225 :   return ASN1_SUCCESS;
     549                 :            : }
     550                 :            : 
     551                 :            : static int
     552                 :         21 : _asn1_delete_not_used (asn1_node node)
     553                 :            : {
     554                 :            :   asn1_node p, p2;
     555                 :            : 
     556         [ -  + ]:         21 :   if (node == NULL)
     557                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
     558                 :            : 
     559                 :         21 :   p = node;
     560         [ +  + ]:        313 :   while (p)
     561                 :            :     {
     562         [ +  + ]:        292 :       if (p->type & CONST_NOT_USED)
     563                 :            :         {
     564                 :          3 :           p2 = NULL;
     565         [ +  - ]:          3 :           if (p != node)
     566                 :            :             {
     567                 :          3 :               p2 = _asn1_find_left (p);
     568         [ +  + ]:          3 :               if (!p2)
     569                 :          1 :                 p2 = _asn1_find_up (p);
     570                 :            :             }
     571                 :          3 :           asn1_delete_structure (&p);
     572                 :          3 :           p = p2;
     573                 :            :         }
     574                 :            : 
     575         [ -  + ]:        292 :       if (!p)
     576                 :          0 :         break;                  /* reach node */
     577                 :            : 
     578         [ +  + ]:        292 :       if (p->down)
     579                 :            :         {
     580                 :        114 :           p = p->down;
     581                 :            :         }
     582                 :            :       else
     583                 :            :         {
     584         [ +  + ]:        178 :           if (p == node)
     585                 :          2 :             p = NULL;
     586         [ +  + ]:        176 :           else if (p->right)
     587                 :         99 :             p = p->right;
     588                 :            :           else
     589                 :            :             {
     590                 :            :               while (1)
     591                 :            :                 {
     592                 :        113 :                   p = _asn1_find_up (p);
     593         [ +  + ]:        113 :                   if (p == node)
     594                 :            :                     {
     595                 :         19 :                       p = NULL;
     596                 :         19 :                       break;
     597                 :            :                     }
     598         [ +  + ]:         94 :                   if (p->right)
     599                 :            :                     {
     600                 :         58 :                       p = p->right;
     601                 :         58 :                       break;
     602                 :            :                     }
     603                 :         36 :                 }
     604                 :            :             }
     605                 :            :         }
     606                 :            :     }
     607                 :         21 :   return ASN1_SUCCESS;
     608                 :            : }
     609                 :            : 
     610                 :            : static int
     611                 :          0 : _asn1_extract_der_octet (asn1_node node, const unsigned char *der,
     612                 :            :                          int der_len)
     613                 :            : {
     614                 :            :   int len2, len3;
     615                 :            :   int counter2, counter_end;
     616                 :            : 
     617                 :          0 :   len2 = asn1_get_length_der (der, der_len, &len3);
     618         [ #  # ]:          0 :   if (len2 < -1)
     619                 :          0 :     return ASN1_DER_ERROR;
     620                 :            : 
     621                 :          0 :   counter2 = len3 + 1;
     622                 :            : 
     623         [ #  # ]:          0 :   if (len2 == -1)
     624                 :          0 :     counter_end = der_len - 2;
     625                 :            :   else
     626                 :          0 :     counter_end = der_len;
     627                 :            : 
     628         [ #  # ]:          0 :   while (counter2 < counter_end)
     629                 :            :     {
     630                 :          0 :       len2 = asn1_get_length_der (der + counter2, der_len - counter2, &len3);
     631                 :            : 
     632         [ #  # ]:          0 :       if (len2 < -1)
     633                 :          0 :         return ASN1_DER_ERROR;
     634                 :            : 
     635         [ #  # ]:          0 :       if (len2 > 0)
     636                 :            :         {
     637                 :          0 :           _asn1_append_value (node, der + counter2 + len3, len2);
     638                 :            :         }
     639                 :            :       else
     640                 :            :         {                       /* indefinite */
     641                 :            : 
     642                 :          0 :           len2 =
     643                 :          0 :             _asn1_extract_der_octet (node, der + counter2 + len3,
     644                 :          0 :                                      der_len - counter2 - len3);
     645         [ #  # ]:          0 :           if (len2 < 0)
     646                 :          0 :             return len2;
     647                 :            :         }
     648                 :            : 
     649                 :          0 :       counter2 += len2 + len3 + 1;
     650                 :            :     }
     651                 :            : 
     652                 :          0 :   return ASN1_SUCCESS;
     653                 :            : }
     654                 :            : 
     655                 :            : static int
     656                 :         10 : _asn1_get_octet_string (const unsigned char *der, asn1_node node, int *len)
     657                 :            : {
     658                 :            :   int len2, len3, counter, tot_len, indefinite;
     659                 :            : 
     660                 :         10 :   counter = 0;
     661                 :            : 
     662         [ -  + ]:         10 :   if (*(der - 1) & ASN1_CLASS_STRUCTURED)
     663                 :            :     {
     664                 :          0 :       tot_len = 0;
     665                 :          0 :       indefinite = asn1_get_length_der (der, *len, &len3);
     666         [ #  # ]:          0 :       if (indefinite < -1)
     667                 :          0 :         return ASN1_DER_ERROR;
     668                 :            : 
     669                 :          0 :       counter += len3;
     670         [ #  # ]:          0 :       if (indefinite >= 0)
     671                 :          0 :         indefinite += len3;
     672                 :            : 
     673                 :            :       while (1)
     674                 :            :         {
     675         [ #  # ]:          0 :           if (counter > (*len))
     676                 :          0 :             return ASN1_DER_ERROR;
     677                 :            : 
     678         [ #  # ]:          0 :           if (indefinite == -1)
     679                 :            :             {
     680 [ #  # ][ #  # ]:          0 :               if ((der[counter] == 0) && (der[counter + 1] == 0))
     681                 :            :                 {
     682                 :          0 :                   counter += 2;
     683                 :          0 :                   break;
     684                 :            :                 }
     685                 :            :             }
     686         [ #  # ]:          0 :           else if (counter >= indefinite)
     687                 :          0 :             break;
     688                 :            : 
     689         [ #  # ]:          0 :           if (der[counter] != ASN1_TAG_OCTET_STRING)
     690                 :          0 :             return ASN1_DER_ERROR;
     691                 :            : 
     692                 :          0 :           counter++;
     693                 :            : 
     694                 :          0 :           len2 = asn1_get_length_der (der + counter, *len - counter, &len3);
     695         [ #  # ]:          0 :           if (len2 <= 0)
     696                 :          0 :             return ASN1_DER_ERROR;
     697                 :            : 
     698                 :          0 :           counter += len3 + len2;
     699                 :          0 :           tot_len += len2;
     700                 :          0 :         }
     701                 :            : 
     702                 :            :       /* copy */
     703         [ #  # ]:          0 :       if (node)
     704                 :            :         {
     705                 :            :           unsigned char temp[DER_LEN];
     706                 :            :           int ret;
     707                 :            : 
     708                 :          0 :           len2 = sizeof (temp);
     709                 :            : 
     710                 :          0 :           asn1_length_der (tot_len, temp, &len2);
     711                 :          0 :           _asn1_set_value (node, temp, len2);
     712                 :            : 
     713                 :          0 :           ret = _asn1_extract_der_octet (node, der, *len);
     714         [ #  # ]:          0 :           if (ret != ASN1_SUCCESS)
     715                 :          0 :             return ret;
     716                 :            : 
     717                 :            :         }
     718                 :            :     }
     719                 :            :   else
     720                 :            :     {                           /* NOT STRUCTURED */
     721                 :         10 :       len2 = asn1_get_length_der (der, *len, &len3);
     722         [ -  + ]:         10 :       if (len2 < 0)
     723                 :          0 :         return ASN1_DER_ERROR;
     724                 :            : 
     725                 :         10 :       counter = len3 + len2;
     726         [ +  - ]:         10 :       if (node)
     727                 :         10 :         _asn1_set_value (node, der, counter);
     728                 :            :     }
     729                 :            : 
     730                 :         10 :   *len = counter;
     731                 :         10 :   return ASN1_SUCCESS;
     732                 :            : 
     733                 :            : }
     734                 :            : 
     735                 :            : static int
     736                 :          2 : _asn1_get_indefinite_length_string (const unsigned char *der, int *len)
     737                 :            : {
     738                 :            :   int len2, len3, counter, indefinite;
     739                 :            :   unsigned long tag;
     740                 :            :   unsigned char class;
     741                 :            : 
     742                 :          2 :   counter = indefinite = 0;
     743                 :            : 
     744                 :            :   while (1)
     745                 :            :     {
     746         [ -  + ]:         10 :       if ((*len) < counter)
     747                 :          0 :         return ASN1_DER_ERROR;
     748                 :            : 
     749 [ +  + ][ +  - ]:         10 :       if ((der[counter] == 0) && (der[counter + 1] == 0))
     750                 :            :         {
     751                 :          2 :           counter += 2;
     752                 :          2 :           indefinite--;
     753         [ +  - ]:          2 :           if (indefinite <= 0)
     754                 :          2 :             break;
     755                 :            :           else
     756                 :          0 :             continue;
     757                 :            :         }
     758                 :            : 
     759         [ -  + ]:          8 :       if (asn1_get_tag_der
     760                 :          8 :           (der + counter, *len - counter, &class, &len2,
     761                 :            :            &tag) != ASN1_SUCCESS)
     762                 :          0 :         return ASN1_DER_ERROR;
     763         [ -  + ]:          8 :       if (counter + len2 > *len)
     764                 :          0 :         return ASN1_DER_ERROR;
     765                 :          8 :       counter += len2;
     766                 :          8 :       len2 = asn1_get_length_der (der + counter, *len - counter, &len3);
     767         [ -  + ]:          8 :       if (len2 < -1)
     768                 :          0 :         return ASN1_DER_ERROR;
     769         [ +  + ]:          8 :       if (len2 == -1)
     770                 :            :         {
     771                 :          2 :           indefinite++;
     772                 :          2 :           counter += 1;
     773                 :            :         }
     774                 :            :       else
     775                 :            :         {
     776                 :          6 :           counter += len2 + len3;
     777                 :            :         }
     778                 :          8 :     }
     779                 :            : 
     780                 :          2 :   *len = counter;
     781                 :          2 :   return ASN1_SUCCESS;
     782                 :            : 
     783                 :            : }
     784                 :            : 
     785                 :            : /**
     786                 :            :  * asn1_der_decoding:
     787                 :            :  * @element: pointer to an ASN1 structure.
     788                 :            :  * @ider: vector that contains the DER encoding.
     789                 :            :  * @len: number of bytes of *@ider: @ider[0]..@ider[len-1].
     790                 :            :  * @errorDescription: null-terminated string contains details when an
     791                 :            :  *   error occurred.
     792                 :            :  *
     793                 :            :  * Fill the structure *@ELEMENT with values of a DER encoding
     794                 :            :  * string. The structure must just be created with function
     795                 :            :  * asn1_create_element().  If an error occurs during the decoding
     796                 :            :  * procedure, the *@ELEMENT is deleted and set equal to
     797                 :            :  * %NULL.
     798                 :            :  *
     799                 :            :  * Returns: %ASN1_SUCCESS if DER encoding OK, %ASN1_ELEMENT_NOT_FOUND
     800                 :            :  *   if @ELEMENT is %NULL, and %ASN1_TAG_ERROR or
     801                 :            :  *   %ASN1_DER_ERROR if the der encoding doesn't match the structure
     802                 :            :  *   name (*@ELEMENT deleted).
     803                 :            :  **/
     804                 :            : int
     805                 :         18 : asn1_der_decoding (asn1_node * element, const void *ider, int len,
     806                 :            :                    char *errorDescription)
     807                 :            : {
     808                 :            :   asn1_node node, p, p2, p3;
     809                 :            :   char temp[128];
     810                 :            :   int counter, len2, len3, len4, move, ris, tlen;
     811                 :            :   unsigned char class;
     812                 :            :   unsigned long tag;
     813                 :            :   int indefinite, result;
     814                 :         18 :   const unsigned char *der = ider;
     815                 :            : 
     816                 :         18 :   node = *element;
     817                 :            : 
     818         [ +  + ]:         18 :   if (errorDescription != NULL)
     819                 :         17 :     errorDescription[0] = 0;
     820                 :            : 
     821         [ -  + ]:         18 :   if (node == NULL)
     822                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
     823                 :            : 
     824         [ -  + ]:         18 :   if (node->type & CONST_OPTION)
     825                 :            :     {
     826                 :          0 :       result = ASN1_GENERIC_ERROR;
     827                 :          0 :       goto cleanup;
     828                 :            :     }
     829                 :            : 
     830                 :         18 :   counter = 0;
     831                 :         18 :   move = DOWN;
     832                 :         18 :   p = node;
     833                 :            :   while (1)
     834                 :            :     {
     835                 :        237 :       ris = ASN1_SUCCESS;
     836         [ +  + ]:        237 :       if (move != UP)
     837                 :            :         {
     838         [ -  + ]:        162 :           if (p->type & CONST_SET)
     839                 :            :             {
     840                 :          0 :               p2 = _asn1_find_up (p);
     841                 :          0 :               len2 = _asn1_strtol (p2->value, NULL, 10);
     842         [ #  # ]:          0 :               if (len2 == -1)
     843                 :            :                 {
     844 [ #  # ][ #  # ]:          0 :                   if (!der[counter] && !der[counter + 1])
     845                 :            :                     {
     846                 :          0 :                       p = p2;
     847                 :          0 :                       move = UP;
     848                 :          0 :                       counter += 2;
     849                 :          0 :                       continue;
     850                 :            :                     }
     851                 :            :                 }
     852         [ #  # ]:          0 :               else if (counter == len2)
     853                 :            :                 {
     854                 :          0 :                   p = p2;
     855                 :          0 :                   move = UP;
     856                 :          0 :                   continue;
     857                 :            :                 }
     858         [ #  # ]:          0 :               else if (counter > len2)
     859                 :            :                 {
     860                 :          0 :                   result = ASN1_DER_ERROR;
     861                 :          0 :                   goto cleanup;
     862                 :            :                 }
     863                 :          0 :               p2 = p2->down;
     864         [ #  # ]:          0 :               while (p2)
     865                 :            :                 {
     866 [ #  # ][ #  # ]:          0 :                   if ((p2->type & CONST_SET) && (p2->type & CONST_NOT_USED))
     867                 :            :                     {
     868         [ #  # ]:          0 :                       if (type_field (p2->type) != ASN1_ETYPE_CHOICE)
     869                 :          0 :                         ris =
     870                 :          0 :                           _asn1_extract_tag_der (p2, der + counter,
     871                 :            :                                                  len - counter, &len2);
     872                 :            :                       else
     873                 :            :                         {
     874                 :          0 :                           p3 = p2->down;
     875         [ #  # ]:          0 :                           while (p3)
     876                 :            :                             {
     877                 :          0 :                               ris =
     878                 :          0 :                                 _asn1_extract_tag_der (p3, der + counter,
     879                 :            :                                                        len - counter, &len2);
     880         [ #  # ]:          0 :                               if (ris == ASN1_SUCCESS)
     881                 :          0 :                                 break;
     882                 :          0 :                               p3 = p3->right;
     883                 :            :                             }
     884                 :            :                         }
     885         [ #  # ]:          0 :                       if (ris == ASN1_SUCCESS)
     886                 :            :                         {
     887                 :          0 :                           p2->type &= ~CONST_NOT_USED;
     888                 :          0 :                           p = p2;
     889                 :          0 :                           break;
     890                 :            :                         }
     891                 :            :                     }
     892                 :          0 :                   p2 = p2->right;
     893                 :            :                 }
     894         [ #  # ]:          0 :               if (p2 == NULL)
     895                 :            :                 {
     896                 :          0 :                   result = ASN1_DER_ERROR;
     897                 :          0 :                   goto cleanup;
     898                 :            :                 }
     899                 :            :             }
     900                 :            : 
     901 [ +  + ][ +  + ]:        162 :           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
     902                 :            :             {
     903                 :         30 :               p2 = _asn1_find_up (p);
     904                 :         30 :               len2 = _asn1_strtol (p2->value, NULL, 10);
     905         [ +  + ]:         30 :               if (counter == len2)
     906                 :            :                 {
     907         [ -  + ]:          4 :                   if (p->right)
     908                 :            :                     {
     909                 :          0 :                       p2 = p->right;
     910                 :          0 :                       move = RIGHT;
     911                 :            :                     }
     912                 :            :                   else
     913                 :          4 :                     move = UP;
     914                 :            : 
     915         [ +  + ]:          4 :                   if (p->type & CONST_OPTION)
     916                 :          3 :                     asn1_delete_structure (&p);
     917                 :            : 
     918                 :          4 :                   p = p2;
     919                 :          4 :                   continue;
     920                 :            :                 }
     921                 :            :             }
     922                 :            : 
     923         [ +  + ]:        158 :           if (type_field (p->type) == ASN1_ETYPE_CHOICE)
     924                 :            :             {
     925         [ +  - ]:          6 :               while (p->down)
     926                 :            :                 {
     927         [ +  - ]:          6 :                   if (counter < len)
     928                 :          6 :                     ris =
     929                 :          6 :                       _asn1_extract_tag_der (p->down, der + counter,
     930                 :            :                                              len - counter, &len2);
     931                 :            :                   else
     932                 :          0 :                     ris = ASN1_DER_ERROR;
     933         [ +  - ]:          6 :                   if (ris == ASN1_SUCCESS)
     934                 :            :                     {
     935         [ +  + ]:         12 :                       while (p->down->right)
     936                 :            :                         {
     937                 :          6 :                           p2 = p->down->right;
     938                 :          6 :                           asn1_delete_structure (&p2);
     939                 :            :                         }
     940                 :          6 :                       break;
     941                 :            :                     }
     942         [ #  # ]:          0 :                   else if (ris == ASN1_ERROR_TYPE_ANY)
     943                 :            :                     {
     944                 :          0 :                       result = ASN1_ERROR_TYPE_ANY;
     945                 :          0 :                       goto cleanup;
     946                 :            :                     }
     947                 :            :                   else
     948                 :            :                     {
     949                 :          0 :                       p2 = p->down;
     950                 :          0 :                       asn1_delete_structure (&p2);
     951                 :            :                     }
     952                 :            :                 }
     953                 :            : 
     954         [ -  + ]:          6 :               if (p->down == NULL)
     955                 :            :                 {
     956         [ #  # ]:          0 :                   if (!(p->type & CONST_OPTION))
     957                 :            :                     {
     958                 :          0 :                       result = ASN1_DER_ERROR;
     959                 :          0 :                       goto cleanup;
     960                 :            :                     }
     961                 :            :                 }
     962                 :            :               else
     963                 :          6 :                 p = p->down;
     964                 :            :             }
     965                 :            : 
     966 [ +  + ][ +  + ]:        158 :           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
     967                 :            :             {
     968                 :         25 :               p2 = _asn1_find_up (p);
     969                 :         25 :               len2 = _asn1_strtol (p2->value, NULL, 10);
     970 [ +  + ][ -  + ]:         25 :               if ((len2 != -1) && (counter > len2))
     971                 :          0 :                 ris = ASN1_TAG_ERROR;
     972                 :            :             }
     973                 :            : 
     974         [ +  - ]:        158 :           if (ris == ASN1_SUCCESS)
     975                 :        158 :             ris =
     976                 :        158 :               _asn1_extract_tag_der (p, der + counter, len - counter, &len2);
     977         [ +  + ]:        158 :           if (ris != ASN1_SUCCESS)
     978                 :            :             {
     979         [ +  + ]:          9 :               if (p->type & CONST_OPTION)
     980                 :            :                 {
     981                 :          3 :                   p->type |= CONST_NOT_USED;
     982                 :          3 :                   move = RIGHT;
     983                 :            :                 }
     984         [ +  - ]:          6 :               else if (p->type & CONST_DEFAULT)
     985                 :            :                 {
     986                 :          6 :                   _asn1_set_value (p, NULL, 0);
     987                 :          6 :                   move = RIGHT;
     988                 :            :                 }
     989                 :            :               else
     990                 :            :                 {
     991         [ #  # ]:          0 :                   if (errorDescription != NULL)
     992                 :          0 :                     _asn1_error_description_tag_error (p, errorDescription);
     993                 :            : 
     994                 :          0 :                   result = ASN1_TAG_ERROR;
     995                 :          0 :                   goto cleanup;
     996                 :            :                 }
     997                 :            :             }
     998                 :            :           else
     999                 :        149 :             counter += len2;
    1000                 :            :         }
    1001                 :            : 
    1002         [ +  + ]:        233 :       if (ris == ASN1_SUCCESS)
    1003                 :            :         {
    1004   [ -  +  +  +  :        224 :           switch (type_field (p->type))
          +  +  +  +  +  
                   +  + ]
    1005                 :            :             {
    1006                 :            :             case ASN1_ETYPE_NULL:
    1007         [ #  # ]:          0 :               if (der[counter])
    1008                 :            :                 {
    1009                 :          0 :                   result = ASN1_DER_ERROR;
    1010                 :          0 :                   goto cleanup;
    1011                 :            :                 }
    1012                 :          0 :               counter++;
    1013                 :          0 :               move = RIGHT;
    1014                 :          0 :               break;
    1015                 :            :             case ASN1_ETYPE_BOOLEAN:
    1016         [ -  + ]:          1 :               if (der[counter++] != 1)
    1017                 :            :                 {
    1018                 :          0 :                   result = ASN1_DER_ERROR;
    1019                 :          0 :                   goto cleanup;
    1020                 :            :                 }
    1021         [ -  + ]:          1 :               if (der[counter++] == 0)
    1022                 :          0 :                 _asn1_set_value (p, "F", 1);
    1023                 :            :               else
    1024                 :          1 :                 _asn1_set_value (p, "T", 1);
    1025                 :          1 :               move = RIGHT;
    1026                 :          1 :               break;
    1027                 :            :             case ASN1_ETYPE_INTEGER:
    1028                 :            :             case ASN1_ETYPE_ENUMERATED:
    1029                 :         23 :               len2 =
    1030                 :         23 :                 asn1_get_length_der (der + counter, len - counter, &len3);
    1031         [ -  + ]:         23 :               if (len2 < 0)
    1032                 :            :                 {
    1033                 :          0 :                   result = ASN1_DER_ERROR;
    1034                 :          0 :                   goto cleanup;
    1035                 :            :                 }
    1036                 :            : 
    1037                 :         23 :               _asn1_set_value (p, der + counter, len3 + len2);
    1038                 :         23 :               counter += len3 + len2;
    1039                 :         23 :               move = RIGHT;
    1040                 :         23 :               break;
    1041                 :            :             case ASN1_ETYPE_OBJECT_ID:
    1042                 :         26 :               result =
    1043                 :         26 :                 _asn1_get_objectid_der (der + counter, len - counter, &len2,
    1044                 :            :                                         temp, sizeof (temp));
    1045         [ -  + ]:         26 :               if (result != ASN1_SUCCESS)
    1046                 :          0 :                 goto cleanup;
    1047                 :            : 
    1048                 :         26 :               tlen = strlen (temp);
    1049         [ +  - ]:         26 :               if (tlen > 0)
    1050                 :         26 :                 _asn1_set_value (p, temp, tlen + 1);
    1051                 :         26 :               counter += len2;
    1052                 :         26 :               move = RIGHT;
    1053                 :         26 :               break;
    1054                 :            :             case ASN1_ETYPE_GENERALIZED_TIME:
    1055                 :            :             case ASN1_ETYPE_UTC_TIME:
    1056                 :          4 :               result =
    1057                 :          4 :                 _asn1_get_time_der (der + counter, len - counter, &len2, temp,
    1058                 :            :                                     sizeof (temp) - 1);
    1059         [ -  + ]:          4 :               if (result != ASN1_SUCCESS)
    1060                 :          0 :                 goto cleanup;
    1061                 :            : 
    1062                 :          4 :               tlen = strlen (temp);
    1063         [ +  - ]:          4 :               if (tlen > 0)
    1064                 :          4 :                 _asn1_set_value (p, temp, tlen);
    1065                 :          4 :               counter += len2;
    1066                 :          4 :               move = RIGHT;
    1067                 :          4 :               break;
    1068                 :            :             case ASN1_ETYPE_OCTET_STRING:
    1069                 :          9 :               len3 = len - counter;
    1070                 :          9 :               result = _asn1_get_octet_string (der + counter, p, &len3);
    1071         [ -  + ]:          9 :               if (result != ASN1_SUCCESS)
    1072                 :          0 :                 goto cleanup;
    1073                 :            : 
    1074                 :          9 :               counter += len3;
    1075                 :          9 :               move = RIGHT;
    1076                 :          9 :               break;
    1077                 :            :             case ASN1_ETYPE_GENERALSTRING:
    1078                 :            :             case ASN1_ETYPE_NUMERIC_STRING:
    1079                 :            :             case ASN1_ETYPE_IA5_STRING:
    1080                 :            :             case ASN1_ETYPE_TELETEX_STRING:
    1081                 :            :             case ASN1_ETYPE_PRINTABLE_STRING:
    1082                 :            :             case ASN1_ETYPE_UNIVERSAL_STRING:
    1083                 :            :             case ASN1_ETYPE_BMP_STRING:
    1084                 :            :             case ASN1_ETYPE_UTF8_STRING:
    1085                 :            :             case ASN1_ETYPE_VISIBLE_STRING:
    1086                 :            :             case ASN1_ETYPE_BIT_STRING:
    1087                 :          6 :               len2 =
    1088                 :          6 :                 asn1_get_length_der (der + counter, len - counter, &len3);
    1089         [ -  + ]:          6 :               if (len2 < 0)
    1090                 :            :                 {
    1091                 :          0 :                   result = ASN1_DER_ERROR;
    1092                 :          0 :                   goto cleanup;
    1093                 :            :                 }
    1094                 :            : 
    1095                 :          6 :               _asn1_set_value (p, der + counter, len3 + len2);
    1096                 :          6 :               counter += len3 + len2;
    1097                 :          6 :               move = RIGHT;
    1098                 :          6 :               break;
    1099                 :            :             case ASN1_ETYPE_SEQUENCE:
    1100                 :            :             case ASN1_ETYPE_SET:
    1101         [ +  + ]:         83 :               if (move == UP)
    1102                 :            :                 {
    1103                 :         41 :                   len2 = _asn1_strtol (p->value, NULL, 10);
    1104                 :         41 :                   _asn1_set_value (p, NULL, 0);
    1105         [ +  + ]:         41 :                   if (len2 == -1)
    1106                 :            :                     {           /* indefinite length method */
    1107         [ +  - ]:          3 :                       if (len - counter + 1 > 0)
    1108                 :            :                         {
    1109 [ +  - ][ -  + ]:          3 :                           if ((der[counter]) || der[counter + 1])
    1110                 :            :                             {
    1111                 :          0 :                               result = ASN1_DER_ERROR;
    1112                 :          0 :                               goto cleanup;
    1113                 :            :                             }
    1114                 :            :                         }
    1115                 :            :                       else
    1116                 :            :                         {
    1117                 :          0 :                           result = ASN1_DER_ERROR;
    1118                 :          0 :                           goto cleanup;
    1119                 :            :                         }
    1120                 :          3 :                       counter += 2;
    1121                 :            :                     }
    1122                 :            :                   else
    1123                 :            :                     {           /* definite length method */
    1124         [ -  + ]:         38 :                       if (len2 != counter)
    1125                 :            :                         {
    1126                 :          0 :                           result = ASN1_DER_ERROR;
    1127                 :          0 :                           goto cleanup;
    1128                 :            :                         }
    1129                 :            :                     }
    1130                 :         41 :                   move = RIGHT;
    1131                 :            :                 }
    1132                 :            :               else
    1133                 :            :                 {               /* move==DOWN || move==RIGHT */
    1134                 :         42 :                   len3 =
    1135                 :         42 :                     asn1_get_length_der (der + counter, len - counter, &len2);
    1136         [ -  + ]:         42 :                   if (len3 < -1)
    1137                 :            :                     {
    1138                 :          0 :                       result = ASN1_DER_ERROR;
    1139                 :          0 :                       goto cleanup;
    1140                 :            :                     }
    1141                 :         42 :                   counter += len2;
    1142         [ +  + ]:         42 :                   if (len3 > 0)
    1143                 :            :                     {
    1144                 :         38 :                       _asn1_ltostr (counter + len3, temp);
    1145                 :         38 :                       tlen = strlen (temp);
    1146         [ +  - ]:         38 :                       if (tlen > 0)
    1147                 :         38 :                         _asn1_set_value (p, temp, tlen + 1);
    1148                 :         38 :                       move = DOWN;
    1149                 :            :                     }
    1150         [ +  + ]:          4 :                   else if (len3 == 0)
    1151                 :            :                     {
    1152                 :          1 :                       p2 = p->down;
    1153         [ +  + ]:          3 :                       while (p2)
    1154                 :            :                         {
    1155         [ +  + ]:          2 :                           if (type_field (p2->type) != ASN1_ETYPE_TAG)
    1156                 :            :                             {
    1157                 :          1 :                               p3 = p2->right;
    1158                 :          1 :                               asn1_delete_structure (&p2);
    1159                 :          1 :                               p2 = p3;
    1160                 :            :                             }
    1161                 :            :                           else
    1162                 :          1 :                             p2 = p2->right;
    1163                 :            :                         }
    1164                 :          1 :                       move = RIGHT;
    1165                 :            :                     }
    1166                 :            :                   else
    1167                 :            :                     {           /* indefinite length method */
    1168                 :          3 :                       _asn1_set_value (p, "-1", 3);
    1169                 :          3 :                       move = DOWN;
    1170                 :            :                     }
    1171                 :            :                 }
    1172                 :         83 :               break;
    1173                 :            :             case ASN1_ETYPE_SEQUENCE_OF:
    1174                 :            :             case ASN1_ETYPE_SET_OF:
    1175         [ +  + ]:         44 :               if (move == UP)
    1176                 :            :                 {
    1177                 :         28 :                   len2 = _asn1_strtol (p->value, NULL, 10);
    1178         [ +  + ]:         28 :                   if (len2 == -1)
    1179                 :            :                     {           /* indefinite length method */
    1180         [ -  + ]:          2 :                       if ((counter + 2) > len)
    1181                 :            :                         {
    1182                 :          0 :                           result = ASN1_DER_ERROR;
    1183                 :          0 :                           goto cleanup;
    1184                 :            :                         }
    1185                 :            : 
    1186 [ +  + ][ -  + ]:          2 :                       if ((der[counter]) || der[counter + 1])
    1187                 :            :                         {
    1188                 :          1 :                           _asn1_append_sequence_set (p);
    1189                 :          1 :                           p = p->down;
    1190         [ +  + ]:          3 :                           while (p->right)
    1191                 :          2 :                             p = p->right;
    1192                 :          1 :                           move = RIGHT;
    1193                 :          1 :                           continue;
    1194                 :            :                         }
    1195                 :          1 :                       _asn1_set_value (p, NULL, 0);
    1196                 :          1 :                       counter += 2;
    1197                 :            :                     }
    1198                 :            :                   else
    1199                 :            :                     {           /* definite length method */
    1200         [ +  + ]:         26 :                       if (len2 > counter)
    1201                 :            :                         {
    1202                 :         13 :                           _asn1_append_sequence_set (p);
    1203                 :         13 :                           p = p->down;
    1204         [ +  + ]:         70 :                           while (p->right)
    1205                 :         57 :                             p = p->right;
    1206                 :         13 :                           move = RIGHT;
    1207                 :         13 :                           continue;
    1208                 :            :                         }
    1209                 :         13 :                       _asn1_set_value (p, NULL, 0);
    1210         [ -  + ]:         13 :                       if (len2 != counter)
    1211                 :            :                         {
    1212                 :          0 :                           result = ASN1_DER_ERROR;
    1213                 :          0 :                           goto cleanup;
    1214                 :            :                         }
    1215                 :            :                     }
    1216                 :            :                 }
    1217                 :            :               else
    1218                 :            :                 {               /* move==DOWN || move==RIGHT */
    1219                 :         16 :                   len3 =
    1220                 :         16 :                     asn1_get_length_der (der + counter, len - counter, &len2);
    1221         [ -  + ]:         16 :                   if (len3 < -1)
    1222                 :            :                     {
    1223                 :          0 :                       result = ASN1_DER_ERROR;
    1224                 :          0 :                       goto cleanup;
    1225                 :            :                     }
    1226                 :         16 :                   counter += len2;
    1227         [ +  + ]:         16 :                   if (len3)
    1228                 :            :                     {
    1229         [ +  + ]:         14 :                       if (len3 > 0)
    1230                 :            :                         {       /* definite length method */
    1231                 :         13 :                           _asn1_ltostr (counter + len3, temp);
    1232                 :         13 :                           tlen = strlen (temp);
    1233                 :            : 
    1234         [ +  - ]:         13 :                           if (tlen > 0)
    1235                 :         13 :                             _asn1_set_value (p, temp, tlen + 1);
    1236                 :            :                         }
    1237                 :            :                       else
    1238                 :            :                         {       /* indefinite length method */
    1239                 :          1 :                           _asn1_set_value (p, "-1", 3);
    1240                 :            :                         }
    1241                 :         14 :                       p2 = p->down;
    1242         [ +  + ]:         24 :                       while ((type_field (p2->type) == ASN1_ETYPE_TAG)
    1243         [ +  + ]:         22 :                              || (type_field (p2->type) == ASN1_ETYPE_SIZE))
    1244                 :         10 :                         p2 = p2->right;
    1245         [ +  + ]:         14 :                       if (p2->right == NULL)
    1246                 :         13 :                         _asn1_append_sequence_set (p);
    1247                 :         14 :                       p = p2;
    1248                 :            :                     }
    1249                 :            :                 }
    1250                 :         30 :               move = RIGHT;
    1251                 :         30 :               break;
    1252                 :            :             case ASN1_ETYPE_ANY:
    1253         [ -  + ]:         20 :               if (asn1_get_tag_der
    1254                 :         20 :                   (der + counter, len - counter, &class, &len2,
    1255                 :            :                    &tag) != ASN1_SUCCESS)
    1256                 :            :                 {
    1257                 :          0 :                   result = ASN1_DER_ERROR;
    1258                 :          0 :                   goto cleanup;
    1259                 :            :                 }
    1260                 :            : 
    1261         [ -  + ]:         20 :               if (counter + len2 > len)
    1262                 :            :                 {
    1263                 :          0 :                   result = ASN1_DER_ERROR;
    1264                 :          0 :                   goto cleanup;
    1265                 :            :                 }
    1266                 :         20 :               len4 =
    1267                 :         20 :                 asn1_get_length_der (der + counter + len2,
    1268                 :         20 :                                      len - counter - len2, &len3);
    1269         [ -  + ]:         20 :               if (len4 < -1)
    1270                 :            :                 {
    1271                 :          0 :                   result = ASN1_DER_ERROR;
    1272                 :          0 :                   goto cleanup;
    1273                 :            :                 }
    1274         [ +  + ]:         20 :               if (len4 != -1)
    1275                 :            :                 {
    1276                 :         19 :                   len2 += len4;
    1277                 :         19 :                   _asn1_set_value_lv (p, der + counter, len2 + len3);
    1278                 :         19 :                   counter += len2 + len3;
    1279                 :            :                 }
    1280                 :            :               else
    1281                 :            :                 {               /* indefinite length */
    1282                 :            :                   /* Check indefinite lenth method in an EXPLICIT TAG */
    1283 [ +  - ][ +  - ]:          1 :                   if ((p->type & CONST_TAG) && (der[counter - 1] == 0x80))
    1284                 :          1 :                     indefinite = 1;
    1285                 :            :                   else
    1286                 :          0 :                     indefinite = 0;
    1287                 :            : 
    1288                 :          1 :                   len2 = len - counter;
    1289                 :          1 :                   result =
    1290                 :          1 :                     _asn1_get_indefinite_length_string (der + counter, &len2);
    1291         [ -  + ]:          1 :                   if (result != ASN1_SUCCESS)
    1292                 :          0 :                     goto cleanup;
    1293                 :            : 
    1294                 :          1 :                   _asn1_set_value_lv (p, der + counter, len2);
    1295                 :          1 :                   counter += len2;
    1296                 :            : 
    1297                 :            :                   /* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
    1298                 :            :                      an indefinite length method. */
    1299         [ +  - ]:          1 :                   if (indefinite)
    1300                 :            :                     {
    1301 [ +  - ][ +  - ]:          1 :                       if (!der[counter] && !der[counter + 1])
    1302                 :            :                         {
    1303                 :          1 :                           counter += 2;
    1304                 :            :                         }
    1305                 :            :                       else
    1306                 :            :                         {
    1307                 :          0 :                           result = ASN1_DER_ERROR;
    1308                 :          0 :                           goto cleanup;
    1309                 :            :                         }
    1310                 :            :                     }
    1311                 :            :                 }
    1312                 :         20 :               move = RIGHT;
    1313                 :         20 :               break;
    1314                 :            :             default:
    1315         [ +  + ]:          8 :               move = (move == UP) ? RIGHT : DOWN;
    1316                 :          8 :               break;
    1317                 :            :             }
    1318                 :            :         }
    1319                 :            : 
    1320 [ +  + ][ +  + ]:        219 :       if (p == node && move != DOWN)
    1321                 :         18 :         break;
    1322                 :            : 
    1323         [ +  + ]:        201 :       if (move == DOWN)
    1324                 :            :         {
    1325         [ +  + ]:         43 :           if (p->down)
    1326                 :         41 :             p = p->down;
    1327                 :            :           else
    1328                 :          2 :             move = RIGHT;
    1329                 :            :         }
    1330 [ +  + ][ +  - ]:        201 :       if ((move == RIGHT) && !(p->type & CONST_SET))
    1331                 :            :         {
    1332         [ +  + ]:        160 :           if (p->right)
    1333                 :         89 :             p = p->right;
    1334                 :            :           else
    1335                 :         71 :             move = UP;
    1336                 :            :         }
    1337         [ +  + ]:        201 :       if (move == UP)
    1338                 :         71 :         p = _asn1_find_up (p);
    1339                 :        219 :     }
    1340                 :            : 
    1341                 :         18 :   _asn1_delete_not_used (*element);
    1342                 :            : 
    1343         [ -  + ]:         18 :   if (counter != len)
    1344                 :            :     {
    1345                 :          0 :       result = ASN1_DER_ERROR;
    1346                 :          0 :       goto cleanup;
    1347                 :            :     }
    1348                 :            : 
    1349                 :         18 :   return ASN1_SUCCESS;
    1350                 :            : 
    1351                 :            : cleanup:
    1352                 :          0 :   asn1_delete_structure (element);
    1353                 :         18 :   return result;
    1354                 :            : }
    1355                 :            : 
    1356                 :            : #define FOUND        1
    1357                 :            : #define SAME_BRANCH  2
    1358                 :            : #define OTHER_BRANCH 3
    1359                 :            : #define EXIT         4
    1360                 :            : 
    1361                 :            : /**
    1362                 :            :  * asn1_der_decoding_element:
    1363                 :            :  * @structure: pointer to an ASN1 structure
    1364                 :            :  * @elementName: name of the element to fill
    1365                 :            :  * @ider: vector that contains the DER encoding of the whole structure.
    1366                 :            :  * @len: number of bytes of *der: der[0]..der[len-1]
    1367                 :            :  * @errorDescription: null-terminated string contains details when an
    1368                 :            :  *   error occurred.
    1369                 :            :  *
    1370                 :            :  * Fill the element named @ELEMENTNAME with values of a DER encoding
    1371                 :            :  * string.  The structure must just be created with function
    1372                 :            :  * asn1_create_element().  The DER vector must contain the encoding
    1373                 :            :  * string of the whole @STRUCTURE.  If an error occurs during the
    1374                 :            :  * decoding procedure, the *@STRUCTURE is deleted and set equal to
    1375                 :            :  * %NULL.
    1376                 :            :  *
    1377                 :            :  * Returns: %ASN1_SUCCESS if DER encoding OK, %ASN1_ELEMENT_NOT_FOUND
    1378                 :            :  *   if ELEMENT is %NULL or @elementName == NULL, and
    1379                 :            :  *   %ASN1_TAG_ERROR or %ASN1_DER_ERROR if the der encoding doesn't
    1380                 :            :  *   match the structure @structure (*ELEMENT deleted).
    1381                 :            :  **/
    1382                 :            : int
    1383                 :          3 : asn1_der_decoding_element (asn1_node * structure, const char *elementName,
    1384                 :            :                            const void *ider, int len, char *errorDescription)
    1385                 :            : {
    1386                 :          3 :   asn1_node node, p, p2, p3, nodeFound = NULL;
    1387                 :            :   char temp[128], currentName[ASN1_MAX_NAME_SIZE * 10], *dot_p, *char_p;
    1388                 :          3 :   int nameLen = ASN1_MAX_NAME_SIZE * 10 - 1, state;
    1389                 :            :   int counter, len2, len3, len4, move, ris, tlen;
    1390                 :            :   unsigned char class;
    1391                 :            :   unsigned long tag;
    1392                 :            :   int indefinite, result;
    1393                 :          3 :   const unsigned char *der = ider;
    1394                 :            : 
    1395                 :          3 :   node = *structure;
    1396                 :            : 
    1397         [ -  + ]:          3 :   if (node == NULL)
    1398                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    1399                 :            : 
    1400         [ -  + ]:          3 :   if (elementName == NULL)
    1401                 :            :     {
    1402                 :          0 :       result = ASN1_ELEMENT_NOT_FOUND;
    1403                 :          0 :       goto cleanup;
    1404                 :            :     }
    1405                 :            : 
    1406         [ -  + ]:          3 :   if (node->type & CONST_OPTION)
    1407                 :            :     {
    1408                 :          0 :       result = ASN1_GENERIC_ERROR;
    1409                 :          0 :       goto cleanup;
    1410                 :            :     }
    1411                 :            : 
    1412         [ -  + ]:          3 :   if ((*structure)->name[0] != 0)
    1413                 :            :     {                           /* Has *structure got a name? */
    1414                 :          0 :       nameLen -= strlen ((*structure)->name);
    1415         [ #  # ]:          0 :       if (nameLen > 0)
    1416                 :          0 :         strcpy (currentName, (*structure)->name);
    1417                 :            :       else
    1418                 :            :         {
    1419                 :          0 :           result = ASN1_MEM_ERROR;
    1420                 :          0 :           goto cleanup;
    1421                 :            :         }
    1422         [ #  # ]:          0 :       if (!(strcmp (currentName, elementName)))
    1423                 :            :         {
    1424                 :          0 :           state = FOUND;
    1425                 :          0 :           nodeFound = *structure;
    1426                 :            :         }
    1427         [ #  # ]:          0 :       else if (!memcmp (currentName, elementName, strlen (currentName)))
    1428                 :          0 :         state = SAME_BRANCH;
    1429                 :            :       else
    1430                 :          0 :         state = OTHER_BRANCH;
    1431                 :            :     }
    1432                 :            :   else
    1433                 :            :     {                           /* *structure doesn't have a name? */
    1434                 :          3 :       currentName[0] = 0;
    1435         [ -  + ]:          3 :       if (elementName[0] == 0)
    1436                 :            :         {
    1437                 :          0 :           state = FOUND;
    1438                 :          0 :           nodeFound = *structure;
    1439                 :            :         }
    1440                 :            :       else
    1441                 :            :         {
    1442                 :          3 :           state = SAME_BRANCH;
    1443                 :            :         }
    1444                 :            :     }
    1445                 :            : 
    1446                 :          3 :   counter = 0;
    1447                 :          3 :   move = DOWN;
    1448                 :          3 :   p = node;
    1449                 :            :   while (1)
    1450                 :            :     {
    1451                 :            : 
    1452                 :          8 :       ris = ASN1_SUCCESS;
    1453                 :            : 
    1454         [ +  - ]:          8 :       if (move != UP)
    1455                 :            :         {
    1456         [ -  + ]:          8 :           if (p->type & CONST_SET)
    1457                 :            :             {
    1458                 :          0 :               p2 = _asn1_find_up (p);
    1459                 :          0 :               len2 = _asn1_strtol (p2->value, NULL, 10);
    1460         [ #  # ]:          0 :               if (counter == len2)
    1461                 :            :                 {
    1462                 :          0 :                   p = p2;
    1463                 :          0 :                   move = UP;
    1464                 :          0 :                   continue;
    1465                 :            :                 }
    1466         [ #  # ]:          0 :               else if (counter > len2)
    1467                 :            :                 {
    1468                 :          0 :                   result = ASN1_DER_ERROR;
    1469                 :          0 :                   goto cleanup;
    1470                 :            :                 }
    1471                 :          0 :               p2 = p2->down;
    1472         [ #  # ]:          0 :               while (p2)
    1473                 :            :                 {
    1474 [ #  # ][ #  # ]:          0 :                   if ((p2->type & CONST_SET) && (p2->type & CONST_NOT_USED))
    1475                 :            :                     {
    1476         [ #  # ]:          0 :                       if (type_field (p2->type) != ASN1_ETYPE_CHOICE)
    1477                 :          0 :                         ris =
    1478                 :          0 :                           _asn1_extract_tag_der (p2, der + counter,
    1479                 :            :                                                  len - counter, &len2);
    1480                 :            :                       else
    1481                 :            :                         {
    1482                 :          0 :                           p3 = p2->down;
    1483         [ #  # ]:          0 :                           while (p3)
    1484                 :            :                             {
    1485                 :          0 :                               ris =
    1486                 :          0 :                                 _asn1_extract_tag_der (p3, der + counter,
    1487                 :            :                                                        len - counter, &len2);
    1488         [ #  # ]:          0 :                               if (ris == ASN1_SUCCESS)
    1489                 :          0 :                                 break;
    1490                 :          0 :                               p3 = p3->right;
    1491                 :            :                             }
    1492                 :            :                         }
    1493         [ #  # ]:          0 :                       if (ris == ASN1_SUCCESS)
    1494                 :            :                         {
    1495                 :          0 :                           p2->type &= ~CONST_NOT_USED;
    1496                 :          0 :                           p = p2;
    1497                 :          0 :                           break;
    1498                 :            :                         }
    1499                 :            :                     }
    1500                 :          0 :                   p2 = p2->right;
    1501                 :            :                 }
    1502         [ #  # ]:          0 :               if (p2 == NULL)
    1503                 :            :                 {
    1504                 :          0 :                   result = ASN1_DER_ERROR;
    1505                 :          0 :                   goto cleanup;
    1506                 :            :                 }
    1507                 :            :             }
    1508                 :            : 
    1509 [ +  - ][ +  + ]:          8 :           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
    1510                 :            :             {
    1511                 :          1 :               p2 = _asn1_find_up (p);
    1512                 :          1 :               len2 = _asn1_strtol (p2->value, NULL, 10);
    1513         [ -  + ]:          1 :               if (counter == len2)
    1514                 :            :                 {
    1515         [ #  # ]:          0 :                   if (p->right)
    1516                 :            :                     {
    1517                 :          0 :                       p2 = p->right;
    1518                 :          0 :                       move = RIGHT;
    1519                 :            :                     }
    1520                 :            :                   else
    1521                 :          0 :                     move = UP;
    1522                 :            : 
    1523         [ #  # ]:          0 :                   if (p->type & CONST_OPTION)
    1524                 :          0 :                     asn1_delete_structure (&p);
    1525                 :            : 
    1526                 :          0 :                   p = p2;
    1527                 :          0 :                   continue;
    1528                 :            :                 }
    1529                 :            :             }
    1530                 :            : 
    1531         [ -  + ]:          8 :           if (type_field (p->type) == ASN1_ETYPE_CHOICE)
    1532                 :            :             {
    1533         [ #  # ]:          0 :               while (p->down)
    1534                 :            :                 {
    1535         [ #  # ]:          0 :                   if (counter < len)
    1536                 :          0 :                     ris =
    1537                 :          0 :                       _asn1_extract_tag_der (p->down, der + counter,
    1538                 :            :                                              len - counter, &len2);
    1539                 :            :                   else
    1540                 :          0 :                     ris = ASN1_DER_ERROR;
    1541         [ #  # ]:          0 :                   if (ris == ASN1_SUCCESS)
    1542                 :            :                     {
    1543         [ #  # ]:          0 :                       while (p->down->right)
    1544                 :            :                         {
    1545                 :          0 :                           p2 = p->down->right;
    1546                 :          0 :                           asn1_delete_structure (&p2);
    1547                 :            :                         }
    1548                 :          0 :                       break;
    1549                 :            :                     }
    1550         [ #  # ]:          0 :                   else if (ris == ASN1_ERROR_TYPE_ANY)
    1551                 :            :                     {
    1552                 :          0 :                       result = ASN1_ERROR_TYPE_ANY;
    1553                 :          0 :                       goto cleanup;
    1554                 :            :                     }
    1555                 :            :                   else
    1556                 :            :                     {
    1557                 :          0 :                       p2 = p->down;
    1558                 :          0 :                       asn1_delete_structure (&p2);
    1559                 :            :                     }
    1560                 :            :                 }
    1561                 :            : 
    1562         [ #  # ]:          0 :               if (p->down == NULL)
    1563                 :            :                 {
    1564         [ #  # ]:          0 :                   if (!(p->type & CONST_OPTION))
    1565                 :            :                     {
    1566                 :          0 :                       result = ASN1_DER_ERROR;
    1567                 :          0 :                       goto cleanup;
    1568                 :            :                     }
    1569                 :            :                 }
    1570                 :            :               else
    1571                 :          0 :                 p = p->down;
    1572                 :            :             }
    1573                 :            : 
    1574 [ +  - ][ +  + ]:          8 :           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
    1575                 :            :             {
    1576                 :          1 :               p2 = _asn1_find_up (p);
    1577                 :          1 :               len2 = _asn1_strtol (p2->value, NULL, 10);
    1578         [ -  + ]:          1 :               if (counter > len2)
    1579                 :          0 :                 ris = ASN1_TAG_ERROR;
    1580                 :            :             }
    1581                 :            : 
    1582         [ +  - ]:          8 :           if (ris == ASN1_SUCCESS)
    1583                 :          8 :             ris =
    1584                 :          8 :               _asn1_extract_tag_der (p, der + counter, len - counter, &len2);
    1585         [ +  + ]:          8 :           if (ris != ASN1_SUCCESS)
    1586                 :            :             {
    1587         [ -  + ]:          1 :               if (p->type & CONST_OPTION)
    1588                 :            :                 {
    1589                 :          0 :                   p->type |= CONST_NOT_USED;
    1590                 :          0 :                   move = RIGHT;
    1591                 :            :                 }
    1592         [ +  - ]:          1 :               else if (p->type & CONST_DEFAULT)
    1593                 :            :                 {
    1594                 :          1 :                   _asn1_set_value (p, NULL, 0);
    1595                 :          1 :                   move = RIGHT;
    1596                 :            :                 }
    1597                 :            :               else
    1598                 :            :                 {
    1599         [ #  # ]:          0 :                   if (errorDescription != NULL)
    1600                 :          0 :                     _asn1_error_description_tag_error (p, errorDescription);
    1601                 :            : 
    1602                 :          0 :                   result = ASN1_TAG_ERROR;
    1603                 :          0 :                   goto cleanup;
    1604                 :            :                 }
    1605                 :            :             }
    1606                 :            :           else
    1607                 :          7 :             counter += len2;
    1608                 :            :         }
    1609                 :            : 
    1610         [ +  + ]:          8 :       if (ris == ASN1_SUCCESS)
    1611                 :            :         {
    1612   [ -  -  +  -  :          7 :           switch (type_field (p->type))
          -  +  +  +  -  
                   -  - ]
    1613                 :            :             {
    1614                 :            :             case ASN1_ETYPE_NULL:
    1615         [ #  # ]:          0 :               if (der[counter])
    1616                 :            :                 {
    1617                 :          0 :                   result = ASN1_DER_ERROR;
    1618                 :          0 :                   goto cleanup;
    1619                 :            :                 }
    1620                 :            : 
    1621         [ #  # ]:          0 :               if (p == nodeFound)
    1622                 :          0 :                 state = EXIT;
    1623                 :            : 
    1624                 :          0 :               counter++;
    1625                 :          0 :               move = RIGHT;
    1626                 :          0 :               break;
    1627                 :            :             case ASN1_ETYPE_BOOLEAN:
    1628         [ #  # ]:          0 :               if (der[counter++] != 1)
    1629                 :            :                 {
    1630                 :          0 :                   result = ASN1_DER_ERROR;
    1631                 :          0 :                   goto cleanup;
    1632                 :            :                 }
    1633                 :            : 
    1634         [ #  # ]:          0 :               if (state == FOUND)
    1635                 :            :                 {
    1636         [ #  # ]:          0 :                   if (der[counter++] == 0)
    1637                 :          0 :                     _asn1_set_value (p, "F", 1);
    1638                 :            :                   else
    1639                 :          0 :                     _asn1_set_value (p, "T", 1);
    1640                 :            : 
    1641         [ #  # ]:          0 :                   if (p == nodeFound)
    1642                 :          0 :                     state = EXIT;
    1643                 :            : 
    1644                 :            :                 }
    1645                 :            :               else
    1646                 :          0 :                 counter++;
    1647                 :            : 
    1648                 :          0 :               move = RIGHT;
    1649                 :          0 :               break;
    1650                 :            :             case ASN1_ETYPE_INTEGER:
    1651                 :            :             case ASN1_ETYPE_ENUMERATED:
    1652                 :          2 :               len2 =
    1653                 :          2 :                 asn1_get_length_der (der + counter, len - counter, &len3);
    1654         [ -  + ]:          2 :               if (len2 < 0)
    1655                 :            :                 {
    1656                 :          0 :                   result = ASN1_DER_ERROR;
    1657                 :          0 :                   goto cleanup;
    1658                 :            :                 }
    1659                 :            : 
    1660         [ +  + ]:          2 :               if (state == FOUND)
    1661                 :            :                 {
    1662         [ -  + ]:          1 :                   if (len3 + len2 > len - counter)
    1663                 :            :                     {
    1664                 :          0 :                       result = ASN1_DER_ERROR;
    1665                 :          0 :                       goto cleanup;
    1666                 :            :                     }
    1667                 :          1 :                   _asn1_set_value (p, der + counter, len3 + len2);
    1668                 :            : 
    1669         [ +  - ]:          1 :                   if (p == nodeFound)
    1670                 :          1 :                     state = EXIT;
    1671                 :            :                 }
    1672                 :          2 :               counter += len3 + len2;
    1673                 :          2 :               move = RIGHT;
    1674                 :          2 :               break;
    1675                 :            :             case ASN1_ETYPE_OBJECT_ID:
    1676         [ #  # ]:          0 :               if (state == FOUND)
    1677                 :            :                 {
    1678                 :          0 :                   result =
    1679                 :          0 :                     _asn1_get_objectid_der (der + counter, len - counter,
    1680                 :            :                                             &len2, temp, sizeof (temp));
    1681         [ #  # ]:          0 :                   if (result != ASN1_SUCCESS)
    1682                 :          0 :                     goto cleanup;
    1683                 :            : 
    1684                 :          0 :                   tlen = strlen (temp);
    1685                 :            : 
    1686         [ #  # ]:          0 :                   if (tlen > 0)
    1687                 :          0 :                     _asn1_set_value (p, temp, tlen + 1);
    1688                 :            : 
    1689         [ #  # ]:          0 :                   if (p == nodeFound)
    1690                 :          0 :                     state = EXIT;
    1691                 :            :                 }
    1692                 :            :               else
    1693                 :            :                 {
    1694                 :          0 :                   len2 =
    1695                 :          0 :                     asn1_get_length_der (der + counter, len - counter, &len3);
    1696         [ #  # ]:          0 :                   if (len2 < 0)
    1697                 :            :                     {
    1698                 :          0 :                       result = ASN1_DER_ERROR;
    1699                 :          0 :                       goto cleanup;
    1700                 :            :                     }
    1701                 :          0 :                   len2 += len3;
    1702                 :            :                 }
    1703                 :            : 
    1704                 :          0 :               counter += len2;
    1705                 :          0 :               move = RIGHT;
    1706                 :          0 :               break;
    1707                 :            :             case ASN1_ETYPE_GENERALIZED_TIME:
    1708                 :            :             case ASN1_ETYPE_UTC_TIME:
    1709         [ #  # ]:          0 :               if (state == FOUND)
    1710                 :            :                 {
    1711                 :          0 :                   result =
    1712                 :          0 :                     _asn1_get_time_der (der + counter, len - counter, &len2,
    1713                 :            :                                         temp, sizeof (temp) - 1);
    1714         [ #  # ]:          0 :                   if (result != ASN1_SUCCESS)
    1715                 :          0 :                     goto cleanup;
    1716                 :            : 
    1717                 :          0 :                   tlen = strlen (temp);
    1718         [ #  # ]:          0 :                   if (tlen > 0)
    1719                 :          0 :                     _asn1_set_value (p, temp, tlen + 1);
    1720                 :            : 
    1721         [ #  # ]:          0 :                   if (p == nodeFound)
    1722                 :          0 :                     state = EXIT;
    1723                 :            :                 }
    1724                 :            :               else
    1725                 :            :                 {
    1726                 :          0 :                   len2 =
    1727                 :          0 :                     asn1_get_length_der (der + counter, len - counter, &len3);
    1728         [ #  # ]:          0 :                   if (len2 < 0)
    1729                 :            :                     {
    1730                 :          0 :                       result = ASN1_DER_ERROR;
    1731                 :          0 :                       goto cleanup;
    1732                 :            :                     }
    1733                 :          0 :                   len2 += len3;
    1734                 :            :                 }
    1735                 :            : 
    1736                 :          0 :               counter += len2;
    1737                 :          0 :               move = RIGHT;
    1738                 :          0 :               break;
    1739                 :            :             case ASN1_ETYPE_OCTET_STRING:
    1740                 :          1 :               len3 = len - counter;
    1741         [ +  - ]:          1 :               if (state == FOUND)
    1742                 :            :                 {
    1743                 :          1 :                   result = _asn1_get_octet_string (der + counter, p, &len3);
    1744         [ +  - ]:          1 :                   if (p == nodeFound)
    1745                 :          1 :                     state = EXIT;
    1746                 :            :                 }
    1747                 :            :               else
    1748                 :          0 :                 result = _asn1_get_octet_string (der + counter, NULL, &len3);
    1749                 :            : 
    1750         [ -  + ]:          1 :               if (result != ASN1_SUCCESS)
    1751                 :          0 :                 goto cleanup;
    1752                 :            : 
    1753                 :          1 :               counter += len3;
    1754                 :          1 :               move = RIGHT;
    1755                 :          1 :               break;
    1756                 :            :             case ASN1_ETYPE_GENERALSTRING:
    1757                 :            :             case ASN1_ETYPE_NUMERIC_STRING:
    1758                 :            :             case ASN1_ETYPE_IA5_STRING:
    1759                 :            :             case ASN1_ETYPE_TELETEX_STRING:
    1760                 :            :             case ASN1_ETYPE_PRINTABLE_STRING:
    1761                 :            :             case ASN1_ETYPE_UNIVERSAL_STRING:
    1762                 :            :             case ASN1_ETYPE_BMP_STRING:
    1763                 :            :             case ASN1_ETYPE_UTF8_STRING:
    1764                 :            :             case ASN1_ETYPE_VISIBLE_STRING:
    1765                 :            :             case ASN1_ETYPE_BIT_STRING:
    1766                 :          1 :               len2 =
    1767                 :          1 :                 asn1_get_length_der (der + counter, len - counter, &len3);
    1768         [ -  + ]:          1 :               if (len2 < 0)
    1769                 :            :                 {
    1770                 :          0 :                   result = ASN1_DER_ERROR;
    1771                 :          0 :                   goto cleanup;
    1772                 :            :                 }
    1773                 :            : 
    1774         [ +  - ]:          1 :               if (state == FOUND)
    1775                 :            :                 {
    1776         [ -  + ]:          1 :                   if (len3 + len2 > len - counter)
    1777                 :            :                     {
    1778                 :          0 :                       result = ASN1_DER_ERROR;
    1779                 :          0 :                       goto cleanup;
    1780                 :            :                     }
    1781                 :          1 :                   _asn1_set_value (p, der + counter, len3 + len2);
    1782                 :            : 
    1783         [ +  - ]:          1 :                   if (p == nodeFound)
    1784                 :          1 :                     state = EXIT;
    1785                 :            :                 }
    1786                 :          1 :               counter += len3 + len2;
    1787                 :          1 :               move = RIGHT;
    1788                 :          1 :               break;
    1789                 :            :             case ASN1_ETYPE_SEQUENCE:
    1790                 :            :             case ASN1_ETYPE_SET:
    1791         [ -  + ]:          3 :               if (move == UP)
    1792                 :            :                 {
    1793                 :          0 :                   len2 = _asn1_strtol (p->value, NULL, 10);
    1794                 :          0 :                   _asn1_set_value (p, NULL, 0);
    1795         [ #  # ]:          0 :                   if (len2 == -1)
    1796                 :            :                     {           /* indefinite length method */
    1797 [ #  # ][ #  # ]:          0 :                       if ((der[counter]) || der[counter + 1])
    1798                 :            :                         {
    1799                 :          0 :                           result = ASN1_DER_ERROR;
    1800                 :          0 :                           goto cleanup;
    1801                 :            :                         }
    1802                 :          0 :                       counter += 2;
    1803                 :            :                     }
    1804                 :            :                   else
    1805                 :            :                     {           /* definite length method */
    1806         [ #  # ]:          0 :                       if (len2 != counter)
    1807                 :            :                         {
    1808                 :          0 :                           result = ASN1_DER_ERROR;
    1809                 :          0 :                           goto cleanup;
    1810                 :            :                         }
    1811                 :            :                     }
    1812         [ #  # ]:          0 :                   if (p == nodeFound)
    1813                 :          0 :                     state = EXIT;
    1814                 :          0 :                   move = RIGHT;
    1815                 :            :                 }
    1816                 :            :               else
    1817                 :            :                 {               /* move==DOWN || move==RIGHT */
    1818         [ -  + ]:          3 :                   if (state == OTHER_BRANCH)
    1819                 :            :                     {
    1820                 :          0 :                       len3 =
    1821                 :          0 :                         asn1_get_length_der (der + counter, len - counter,
    1822                 :            :                                              &len2);
    1823         [ #  # ]:          0 :                       if (len3 < 0)
    1824                 :            :                         {
    1825                 :          0 :                           result = ASN1_DER_ERROR;
    1826                 :          0 :                           goto cleanup;
    1827                 :            :                         }
    1828                 :          0 :                       counter += len2 + len3;
    1829                 :          0 :                       move = RIGHT;
    1830                 :            :                     }
    1831                 :            :                   else
    1832                 :            :                     {           /*  state==SAME_BRANCH or state==FOUND */
    1833                 :          3 :                       len3 =
    1834                 :          3 :                         asn1_get_length_der (der + counter, len - counter,
    1835                 :            :                                              &len2);
    1836         [ -  + ]:          3 :                       if (len3 < 0)
    1837                 :            :                         {
    1838                 :          0 :                           result = ASN1_DER_ERROR;
    1839                 :          0 :                           goto cleanup;
    1840                 :            :                         }
    1841                 :          3 :                       counter += len2;
    1842         [ +  - ]:          3 :                       if (len3 > 0)
    1843                 :            :                         {
    1844                 :          3 :                           _asn1_ltostr (counter + len3, temp);
    1845                 :          3 :                           tlen = strlen (temp);
    1846                 :            : 
    1847         [ +  - ]:          3 :                           if (tlen > 0)
    1848                 :          3 :                             _asn1_set_value (p, temp, tlen + 1);
    1849                 :          3 :                           move = DOWN;
    1850                 :            :                         }
    1851         [ #  # ]:          0 :                       else if (len3 == 0)
    1852                 :            :                         {
    1853                 :          0 :                           p2 = p->down;
    1854         [ #  # ]:          0 :                           while (p2)
    1855                 :            :                             {
    1856         [ #  # ]:          0 :                               if (type_field (p2->type) != ASN1_ETYPE_TAG)
    1857                 :            :                                 {
    1858                 :          0 :                                   p3 = p2->right;
    1859                 :          0 :                                   asn1_delete_structure (&p2);
    1860                 :          0 :                                   p2 = p3;
    1861                 :            :                                 }
    1862                 :            :                               else
    1863                 :          0 :                                 p2 = p2->right;
    1864                 :            :                             }
    1865                 :          0 :                           move = RIGHT;
    1866                 :            :                         }
    1867                 :            :                       else
    1868                 :            :                         {       /* indefinite length method */
    1869                 :          0 :                           _asn1_set_value (p, "-1", 3);
    1870                 :          0 :                           move = DOWN;
    1871                 :            :                         }
    1872                 :            :                     }
    1873                 :            :                 }
    1874                 :          3 :               break;
    1875                 :            :             case ASN1_ETYPE_SEQUENCE_OF:
    1876                 :            :             case ASN1_ETYPE_SET_OF:
    1877         [ #  # ]:          0 :               if (move == UP)
    1878                 :            :                 {
    1879                 :          0 :                   len2 = _asn1_strtol (p->value, NULL, 10);
    1880         [ #  # ]:          0 :                   if (len2 > counter)
    1881                 :            :                     {
    1882                 :          0 :                       _asn1_append_sequence_set (p);
    1883                 :          0 :                       p = p->down;
    1884         [ #  # ]:          0 :                       while (p->right)
    1885                 :          0 :                         p = p->right;
    1886                 :          0 :                       move = RIGHT;
    1887                 :          0 :                       continue;
    1888                 :            :                     }
    1889                 :          0 :                   _asn1_set_value (p, NULL, 0);
    1890         [ #  # ]:          0 :                   if (len2 != counter)
    1891                 :            :                     {
    1892                 :          0 :                       result = ASN1_DER_ERROR;
    1893                 :          0 :                       goto cleanup;
    1894                 :            :                     }
    1895                 :            : 
    1896         [ #  # ]:          0 :                   if (p == nodeFound)
    1897                 :          0 :                     state = EXIT;
    1898                 :            :                 }
    1899                 :            :               else
    1900                 :            :                 {               /* move==DOWN || move==RIGHT */
    1901         [ #  # ]:          0 :                   if (state == OTHER_BRANCH)
    1902                 :            :                     {
    1903                 :          0 :                       len3 =
    1904                 :          0 :                         asn1_get_length_der (der + counter, len - counter,
    1905                 :            :                                              &len2);
    1906         [ #  # ]:          0 :                       if (len3 < 0)
    1907                 :            :                         {
    1908                 :          0 :                           result = ASN1_DER_ERROR;
    1909                 :          0 :                           goto cleanup;
    1910                 :            :                         }
    1911                 :          0 :                       counter += len2 + len3;
    1912                 :          0 :                       move = RIGHT;
    1913                 :            :                     }
    1914                 :            :                   else
    1915                 :            :                     {           /* state==FOUND or state==SAME_BRANCH */
    1916                 :          0 :                       len3 =
    1917                 :          0 :                         asn1_get_length_der (der + counter, len - counter,
    1918                 :            :                                              &len2);
    1919         [ #  # ]:          0 :                       if (len3 < 0)
    1920                 :            :                         {
    1921                 :          0 :                           result = ASN1_DER_ERROR;
    1922                 :          0 :                           goto cleanup;
    1923                 :            :                         }
    1924                 :          0 :                       counter += len2;
    1925         [ #  # ]:          0 :                       if (len3)
    1926                 :            :                         {
    1927                 :          0 :                           _asn1_ltostr (counter + len3, temp);
    1928                 :          0 :                           tlen = strlen (temp);
    1929                 :            : 
    1930         [ #  # ]:          0 :                           if (tlen > 0)
    1931                 :          0 :                             _asn1_set_value (p, temp, tlen + 1);
    1932                 :          0 :                           p2 = p->down;
    1933         [ #  # ]:          0 :                           while ((type_field (p2->type) == ASN1_ETYPE_TAG)
    1934         [ #  # ]:          0 :                                  || (type_field (p2->type) ==
    1935                 :            :                                      ASN1_ETYPE_SIZE))
    1936                 :          0 :                             p2 = p2->right;
    1937         [ #  # ]:          0 :                           if (p2->right == NULL)
    1938                 :          0 :                             _asn1_append_sequence_set (p);
    1939                 :          0 :                           p = p2;
    1940                 :          0 :                           state = FOUND;
    1941                 :            :                         }
    1942                 :            :                     }
    1943                 :            :                 }
    1944                 :            : 
    1945                 :          0 :               break;
    1946                 :            :             case ASN1_ETYPE_ANY:
    1947         [ #  # ]:          0 :               if (asn1_get_tag_der
    1948                 :          0 :                   (der + counter, len - counter, &class, &len2,
    1949                 :            :                    &tag) != ASN1_SUCCESS)
    1950                 :            :                 {
    1951                 :          0 :                   result = ASN1_DER_ERROR;
    1952                 :          0 :                   goto cleanup;
    1953                 :            :                 }
    1954                 :            : 
    1955         [ #  # ]:          0 :               if (counter + len2 > len)
    1956                 :            :                 {
    1957                 :          0 :                   result = ASN1_DER_ERROR;
    1958                 :          0 :                   goto cleanup;
    1959                 :            :                 }
    1960                 :            : 
    1961                 :          0 :               len4 =
    1962                 :          0 :                 asn1_get_length_der (der + counter + len2,
    1963                 :          0 :                                      len - counter - len2, &len3);
    1964         [ #  # ]:          0 :               if (len4 < -1)
    1965                 :            :                 {
    1966                 :          0 :                   result = ASN1_DER_ERROR;
    1967                 :          0 :                   goto cleanup;
    1968                 :            :                 }
    1969                 :            : 
    1970         [ #  # ]:          0 :               if (len4 != -1)
    1971                 :            :                 {
    1972                 :          0 :                   len2 += len4;
    1973         [ #  # ]:          0 :                   if (state == FOUND)
    1974                 :            :                     {
    1975                 :          0 :                       _asn1_set_value_lv (p, der + counter, len2 + len3);
    1976                 :            : 
    1977         [ #  # ]:          0 :                       if (p == nodeFound)
    1978                 :          0 :                         state = EXIT;
    1979                 :            :                     }
    1980                 :          0 :                   counter += len2 + len3;
    1981                 :            :                 }
    1982                 :            :               else
    1983                 :            :                 {               /* indefinite length */
    1984                 :            :                   /* Check indefinite lenth method in an EXPLICIT TAG */
    1985 [ #  # ][ #  # ]:          0 :                   if ((p->type & CONST_TAG) && (der[counter - 1] == 0x80))
    1986                 :          0 :                     indefinite = 1;
    1987                 :            :                   else
    1988                 :          0 :                     indefinite = 0;
    1989                 :            : 
    1990                 :          0 :                   len2 = len - counter;
    1991                 :          0 :                   result =
    1992                 :          0 :                     _asn1_get_indefinite_length_string (der + counter, &len2);
    1993         [ #  # ]:          0 :                   if (result != ASN1_SUCCESS)
    1994                 :          0 :                     goto cleanup;
    1995                 :            : 
    1996         [ #  # ]:          0 :                   if (state == FOUND)
    1997                 :            :                     {
    1998                 :          0 :                       _asn1_set_value_lv (p, der + counter, len2);
    1999                 :            : 
    2000         [ #  # ]:          0 :                       if (p == nodeFound)
    2001                 :          0 :                         state = EXIT;
    2002                 :            :                     }
    2003                 :            : 
    2004                 :          0 :                   counter += len2;
    2005                 :            : 
    2006                 :            :                   /* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
    2007                 :            :                      an indefinite length method. */
    2008         [ #  # ]:          0 :                   if (indefinite)
    2009                 :            :                     {
    2010 [ #  # ][ #  # ]:          0 :                       if (!der[counter] && !der[counter + 1])
    2011                 :            :                         {
    2012                 :          0 :                           counter += 2;
    2013                 :            :                         }
    2014                 :            :                       else
    2015                 :            :                         {
    2016                 :          0 :                           result = ASN1_DER_ERROR;
    2017                 :          0 :                           goto cleanup;
    2018                 :            :                         }
    2019                 :            :                     }
    2020                 :            :                 }
    2021                 :          0 :               move = RIGHT;
    2022                 :          0 :               break;
    2023                 :            : 
    2024                 :            :             default:
    2025         [ #  # ]:          0 :               move = (move == UP) ? RIGHT : DOWN;
    2026                 :          0 :               break;
    2027                 :            :             }
    2028                 :            :         }
    2029                 :            : 
    2030 [ +  + ][ +  - ]:          8 :       if ((p == node && move != DOWN) || (state == EXIT))
                 [ +  + ]
    2031                 :            :         break;
    2032                 :            : 
    2033         [ +  + ]:          5 :       if (move == DOWN)
    2034                 :            :         {
    2035         [ +  - ]:          3 :           if (p->down)
    2036                 :            :             {
    2037                 :          3 :               p = p->down;
    2038                 :            : 
    2039         [ +  - ]:          3 :               if (state != FOUND)
    2040                 :            :                 {
    2041                 :          3 :                   nameLen -= strlen (p->name) + 1;
    2042         [ +  - ]:          3 :                   if (nameLen > 0)
    2043                 :            :                     {
    2044         [ -  + ]:          3 :                       if (currentName[0])
    2045                 :          0 :                         strcat (currentName, ".");
    2046                 :          3 :                       strcat (currentName, p->name);
    2047                 :            :                     }
    2048                 :            :                   else
    2049                 :            :                     {
    2050                 :          0 :                       result = ASN1_MEM_ERROR;
    2051                 :          0 :                       goto cleanup;
    2052                 :            :                     }
    2053         [ +  + ]:          3 :                   if (!(strcmp (currentName, elementName)))
    2054                 :            :                     {
    2055                 :          1 :                       state = FOUND;
    2056                 :          1 :                       nodeFound = p;
    2057                 :            :                     }
    2058                 :            :                   else
    2059         [ -  + ]:          2 :                     if (!memcmp
    2060                 :          2 :                         (currentName, elementName, strlen (currentName)))
    2061                 :          0 :                     state = SAME_BRANCH;
    2062                 :            :                   else
    2063                 :          2 :                     state = OTHER_BRANCH;
    2064                 :            :                 }
    2065                 :            :             }
    2066                 :            :           else
    2067                 :          0 :             move = RIGHT;
    2068                 :            :         }
    2069                 :            : 
    2070 [ +  + ][ +  - ]:          5 :       if ((move == RIGHT) && !(p->type & CONST_SET))
    2071                 :            :         {
    2072         [ +  - ]:          2 :           if (p->right)
    2073                 :            :             {
    2074                 :          2 :               p = p->right;
    2075                 :            : 
    2076         [ +  - ]:          2 :               if (state != FOUND)
    2077                 :            :                 {
    2078                 :          2 :                   dot_p = char_p = currentName;
    2079         [ -  + ]:          2 :                   while ((char_p = strchr (char_p, '.')))
    2080                 :            :                     {
    2081                 :          0 :                       dot_p = char_p++;
    2082                 :          0 :                       dot_p++;
    2083                 :            :                     }
    2084                 :            : 
    2085                 :          2 :                   nameLen += strlen (currentName) - (dot_p - currentName);
    2086                 :          2 :                   *dot_p = 0;
    2087                 :            : 
    2088                 :          2 :                   nameLen -= strlen (p->name);
    2089         [ +  - ]:          2 :                   if (nameLen > 0)
    2090                 :          2 :                     strcat (currentName, p->name);
    2091                 :            :                   else
    2092                 :            :                     {
    2093                 :          0 :                       result = ASN1_MEM_ERROR;
    2094                 :          0 :                       goto cleanup;
    2095                 :            :                     }
    2096                 :            : 
    2097         [ +  - ]:          2 :                   if (!(strcmp (currentName, elementName)))
    2098                 :            :                     {
    2099                 :          2 :                       state = FOUND;
    2100                 :          2 :                       nodeFound = p;
    2101                 :            :                     }
    2102                 :            :                   else
    2103         [ #  # ]:          0 :                     if (!memcmp
    2104                 :          0 :                         (currentName, elementName, strlen (currentName)))
    2105                 :          0 :                     state = SAME_BRANCH;
    2106                 :            :                   else
    2107                 :          0 :                     state = OTHER_BRANCH;
    2108                 :            :                 }
    2109                 :            :             }
    2110                 :            :           else
    2111                 :          0 :             move = UP;
    2112                 :            :         }
    2113                 :            : 
    2114         [ -  + ]:          5 :       if (move == UP)
    2115                 :            :         {
    2116                 :          0 :           p = _asn1_find_up (p);
    2117                 :            : 
    2118         [ #  # ]:          0 :           if (state != FOUND)
    2119                 :            :             {
    2120                 :          0 :               dot_p = char_p = currentName;
    2121         [ #  # ]:          0 :               while ((char_p = strchr (char_p, '.')))
    2122                 :            :                 {
    2123                 :          0 :                   dot_p = char_p++;
    2124                 :          0 :                   dot_p++;
    2125                 :            :                 }
    2126                 :            : 
    2127                 :          0 :               nameLen += strlen (currentName) - (dot_p - currentName);
    2128                 :          0 :               *dot_p = 0;
    2129                 :            : 
    2130         [ #  # ]:          0 :               if (!(strcmp (currentName, elementName)))
    2131                 :            :                 {
    2132                 :          0 :                   state = FOUND;
    2133                 :          0 :                   nodeFound = p;
    2134                 :            :                 }
    2135                 :            :               else
    2136         [ #  # ]:          0 :                 if (!memcmp (currentName, elementName, strlen (currentName)))
    2137                 :          0 :                 state = SAME_BRANCH;
    2138                 :            :               else
    2139                 :          0 :                 state = OTHER_BRANCH;
    2140                 :            :             }
    2141                 :            :         }
    2142                 :          5 :     }
    2143                 :            : 
    2144                 :          3 :   _asn1_delete_not_used (*structure);
    2145                 :            : 
    2146         [ -  + ]:          3 :   if (counter > len)
    2147                 :            :     {
    2148                 :          0 :       result = ASN1_DER_ERROR;
    2149                 :          0 :       goto cleanup;
    2150                 :            :     }
    2151                 :            : 
    2152                 :          3 :   return ASN1_SUCCESS;
    2153                 :            : 
    2154                 :            : cleanup:
    2155                 :          0 :   asn1_delete_structure (structure);
    2156                 :          3 :   return result;
    2157                 :            : }
    2158                 :            : 
    2159                 :            : /**
    2160                 :            :  * asn1_der_decoding_startEnd:
    2161                 :            :  * @element: pointer to an ASN1 element
    2162                 :            :  * @ider: vector that contains the DER encoding.
    2163                 :            :  * @len: number of bytes of *@ider: @ider[0]..@ider[len-1]
    2164                 :            :  * @name_element: an element of NAME structure.
    2165                 :            :  * @start: the position of the first byte of NAME_ELEMENT decoding
    2166                 :            :  *   (@ider[*start])
    2167                 :            :  * @end: the position of the last byte of NAME_ELEMENT decoding
    2168                 :            :  *  (@ider[*end])
    2169                 :            :  *
    2170                 :            :  * Find the start and end point of an element in a DER encoding
    2171                 :            :  * string. I mean that if you have a der encoding and you have already
    2172                 :            :  * used the function asn1_der_decoding() to fill a structure, it may
    2173                 :            :  * happen that you want to find the piece of string concerning an
    2174                 :            :  * element of the structure.
    2175                 :            :  *
    2176                 :            :  * One example is the sequence "tbsCertificate" inside an X509
    2177                 :            :  * certificate.
    2178                 :            :  *
    2179                 :            :  * Returns: %ASN1_SUCCESS if DER encoding OK, %ASN1_ELEMENT_NOT_FOUND
    2180                 :            :  *   if ELEMENT is %asn1_node EMPTY or @name_element is not a valid
    2181                 :            :  *   element, %ASN1_TAG_ERROR or %ASN1_DER_ERROR if the der encoding
    2182                 :            :  *   doesn't match the structure ELEMENT.
    2183                 :            :  **/
    2184                 :            : int
    2185                 :         14 : asn1_der_decoding_startEnd (asn1_node element, const void *ider, int len,
    2186                 :            :                             const char *name_element, int *start, int *end)
    2187                 :            : {
    2188                 :            :   asn1_node node, node_to_find, p, p2, p3;
    2189                 :            :   int counter, len2, len3, len4, move, ris;
    2190                 :            :   unsigned char class;
    2191                 :            :   unsigned long tag;
    2192                 :            :   int indefinite;
    2193                 :         14 :   const unsigned char *der = ider;
    2194                 :            : 
    2195                 :         14 :   node = element;
    2196                 :            : 
    2197         [ -  + ]:         14 :   if (node == NULL)
    2198                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    2199                 :            : 
    2200                 :         14 :   node_to_find = asn1_find_node (node, name_element);
    2201                 :            : 
    2202         [ -  + ]:         14 :   if (node_to_find == NULL)
    2203                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    2204                 :            : 
    2205         [ +  + ]:         14 :   if (node_to_find == node)
    2206                 :            :     {
    2207                 :          2 :       *start = 0;
    2208                 :          2 :       *end = len - 1;
    2209                 :          2 :       return ASN1_SUCCESS;
    2210                 :            :     }
    2211                 :            : 
    2212         [ -  + ]:         12 :   if (node->type & CONST_OPTION)
    2213                 :          0 :     return ASN1_GENERIC_ERROR;
    2214                 :            : 
    2215                 :         12 :   counter = 0;
    2216                 :         12 :   move = DOWN;
    2217                 :         12 :   p = node;
    2218                 :            :   while (1)
    2219                 :            :     {
    2220         [ -  + ]:         59 :       if (p == NULL)
    2221                 :          0 :         return ASN1_DER_ERROR;
    2222                 :            : 
    2223                 :         59 :       ris = ASN1_SUCCESS;
    2224                 :            : 
    2225         [ +  + ]:         59 :       if (move != UP)
    2226                 :            :         {
    2227         [ -  + ]:         53 :           if (p->type & CONST_SET)
    2228                 :            :             {
    2229                 :          0 :               p2 = _asn1_find_up (p);
    2230         [ #  # ]:          0 :               if (p2 == NULL)
    2231                 :          0 :                 return ASN1_DER_ERROR;
    2232                 :            : 
    2233                 :          0 :               len2 = _asn1_strtol (p2->value, NULL, 10);
    2234         [ #  # ]:          0 :               if (len2 == -1)
    2235                 :            :                 {
    2236 [ #  # ][ #  # ]:          0 :                   if (!der[counter] && !der[counter + 1])
    2237                 :            :                     {
    2238                 :          0 :                       p = p2;
    2239                 :          0 :                       move = UP;
    2240                 :          0 :                       counter += 2;
    2241                 :          0 :                       continue;
    2242                 :            :                     }
    2243                 :            :                 }
    2244         [ #  # ]:          0 :               else if (counter == len2)
    2245                 :            :                 {
    2246                 :          0 :                   p = p2;
    2247                 :          0 :                   move = UP;
    2248                 :          0 :                   continue;
    2249                 :            :                 }
    2250         [ #  # ]:          0 :               else if (counter > len2)
    2251                 :          0 :                 return ASN1_DER_ERROR;
    2252                 :            : 
    2253                 :          0 :               p2 = p2->down;
    2254                 :            : 
    2255         [ #  # ]:          0 :               while (p2)
    2256                 :            :                 {
    2257 [ #  # ][ #  # ]:          0 :                   if ((p2->type & CONST_SET) && (p2->type & CONST_NOT_USED))
    2258                 :            :                     {           /* CONTROLLARE */
    2259         [ #  # ]:          0 :                       if (type_field (p2->type) != ASN1_ETYPE_CHOICE)
    2260                 :          0 :                         ris =
    2261                 :          0 :                           _asn1_extract_tag_der (p2, der + counter,
    2262                 :            :                                                  len - counter, &len2);
    2263                 :            :                       else
    2264                 :            :                         {
    2265                 :          0 :                           p3 = p2->down;
    2266         [ #  # ]:          0 :                           if (p3 == NULL)
    2267                 :          0 :                             return ASN1_DER_ERROR;
    2268                 :            : 
    2269                 :          0 :                           ris =
    2270                 :          0 :                             _asn1_extract_tag_der (p3, der + counter,
    2271                 :            :                                                    len - counter, &len2);
    2272                 :            :                         }
    2273         [ #  # ]:          0 :                       if (ris == ASN1_SUCCESS)
    2274                 :            :                         {
    2275                 :          0 :                           p2->type &= ~CONST_NOT_USED;
    2276                 :          0 :                           p = p2;
    2277                 :          0 :                           break;
    2278                 :            :                         }
    2279                 :            :                     }
    2280                 :          0 :                   p2 = p2->right;
    2281                 :            :                 }
    2282         [ #  # ]:          0 :               if (p2 == NULL)
    2283                 :          0 :                 return ASN1_DER_ERROR;
    2284                 :            :             }
    2285                 :            : 
    2286         [ +  + ]:         53 :           if (p == node_to_find)
    2287                 :         12 :             *start = counter;
    2288                 :            : 
    2289         [ -  + ]:         53 :           if (type_field (p->type) == ASN1_ETYPE_CHOICE)
    2290                 :            :             {
    2291                 :          0 :               p = p->down;
    2292         [ #  # ]:          0 :               if (p == NULL)
    2293                 :          0 :                 return ASN1_DER_ERROR;
    2294                 :            : 
    2295                 :          0 :               ris =
    2296                 :          0 :                 _asn1_extract_tag_der (p, der + counter, len - counter,
    2297                 :            :                                        &len2);
    2298         [ #  # ]:          0 :               if (p == node_to_find)
    2299                 :          0 :                 *start = counter;
    2300                 :            :             }
    2301                 :            : 
    2302         [ +  - ]:         53 :           if (ris == ASN1_SUCCESS)
    2303                 :         53 :             ris =
    2304                 :         53 :               _asn1_extract_tag_der (p, der + counter, len - counter, &len2);
    2305         [ +  + ]:         53 :           if (ris != ASN1_SUCCESS)
    2306                 :            :             {
    2307         [ -  + ]:          4 :               if (p->type & CONST_OPTION)
    2308                 :            :                 {
    2309                 :          0 :                   p->type |= CONST_NOT_USED;
    2310                 :          0 :                   move = RIGHT;
    2311                 :            :                 }
    2312         [ +  - ]:          4 :               else if (p->type & CONST_DEFAULT)
    2313                 :            :                 {
    2314                 :          4 :                   move = RIGHT;
    2315                 :            :                 }
    2316                 :            :               else
    2317                 :            :                 {
    2318                 :          0 :                   return ASN1_TAG_ERROR;
    2319                 :            :                 }
    2320                 :            :             }
    2321                 :            :           else
    2322                 :         49 :             counter += len2;
    2323                 :            :         }
    2324                 :            : 
    2325         [ +  + ]:         59 :       if (ris == ASN1_SUCCESS)
    2326                 :            :         {
    2327   [ -  -  -  +  :         55 :           switch (type_field (p->type))
             +  +  -  + ]
    2328                 :            :             {
    2329                 :            :             case ASN1_ETYPE_NULL:
    2330         [ #  # ]:          0 :               if (der[counter])
    2331                 :          0 :                 return ASN1_DER_ERROR;
    2332                 :          0 :               counter++;
    2333                 :          0 :               move = RIGHT;
    2334                 :          0 :               break;
    2335                 :            :             case ASN1_ETYPE_BOOLEAN:
    2336         [ #  # ]:          0 :               if (der[counter++] != 1)
    2337                 :          0 :                 return ASN1_DER_ERROR;
    2338                 :          0 :               counter++;
    2339                 :          0 :               move = RIGHT;
    2340                 :          0 :               break;
    2341                 :            :             case ASN1_ETYPE_OCTET_STRING:
    2342                 :          0 :               len3 = len - counter;
    2343                 :          0 :               ris = _asn1_get_octet_string (der + counter, NULL, &len3);
    2344         [ #  # ]:          0 :               if (ris != ASN1_SUCCESS)
    2345                 :          0 :                 return ris;
    2346                 :          0 :               counter += len3;
    2347                 :          0 :               move = RIGHT;
    2348                 :          0 :               break;
    2349                 :            :             case ASN1_ETYPE_UTC_TIME:
    2350                 :            :             case ASN1_ETYPE_GENERALIZED_TIME:
    2351                 :            :             case ASN1_ETYPE_OBJECT_ID:
    2352                 :            :             case ASN1_ETYPE_INTEGER:
    2353                 :            :             case ASN1_ETYPE_ENUMERATED:
    2354                 :            :             case ASN1_ETYPE_GENERALSTRING:
    2355                 :            :             case ASN1_ETYPE_NUMERIC_STRING:
    2356                 :            :             case ASN1_ETYPE_IA5_STRING:
    2357                 :            :             case ASN1_ETYPE_TELETEX_STRING:
    2358                 :            :             case ASN1_ETYPE_PRINTABLE_STRING:
    2359                 :            :             case ASN1_ETYPE_UNIVERSAL_STRING:
    2360                 :            :             case ASN1_ETYPE_BMP_STRING:
    2361                 :            :             case ASN1_ETYPE_UTF8_STRING:
    2362                 :            :             case ASN1_ETYPE_VISIBLE_STRING:
    2363                 :            :             case ASN1_ETYPE_BIT_STRING:
    2364                 :         19 :               len2 =
    2365                 :         19 :                 asn1_get_length_der (der + counter, len - counter, &len3);
    2366         [ -  + ]:         19 :               if (len2 < 0)
    2367                 :          0 :                 return ASN1_DER_ERROR;
    2368                 :         19 :               counter += len3 + len2;
    2369                 :         19 :               move = RIGHT;
    2370                 :         19 :               break;
    2371                 :            :             case ASN1_ETYPE_SEQUENCE:
    2372                 :            :             case ASN1_ETYPE_SET:
    2373         [ +  + ]:         24 :               if (move != UP)
    2374                 :            :                 {
    2375                 :         20 :                   len3 =
    2376                 :         20 :                     asn1_get_length_der (der + counter, len - counter, &len2);
    2377         [ -  + ]:         20 :                   if (len3 < -1)
    2378                 :          0 :                     return ASN1_DER_ERROR;
    2379                 :         20 :                   counter += len2;
    2380         [ +  + ]:         20 :                   if (len3 == 0)
    2381                 :          4 :                     move = RIGHT;
    2382                 :            :                   else
    2383                 :         16 :                     move = DOWN;
    2384                 :            :                 }
    2385                 :            :               else
    2386                 :            :                 {
    2387 [ +  - ][ +  - ]:          4 :                   if (!der[counter] && !der[counter + 1])       /* indefinite length method */
    2388                 :          4 :                     counter += 2;
    2389                 :          4 :                   move = RIGHT;
    2390                 :            :                 }
    2391                 :         24 :               break;
    2392                 :            :             case ASN1_ETYPE_SEQUENCE_OF:
    2393                 :            :             case ASN1_ETYPE_SET_OF:
    2394         [ +  + ]:          8 :               if (move != UP)
    2395                 :            :                 {
    2396                 :          6 :                   len3 =
    2397                 :          6 :                     asn1_get_length_der (der + counter, len - counter, &len2);
    2398         [ -  + ]:          6 :                   if (len3 < -1)
    2399                 :          0 :                     return ASN1_DER_ERROR;
    2400                 :          6 :                   counter += len2;
    2401 [ +  + ][ -  + ]:          6 :                   if ((len3 == -1) && !der[counter] && !der[counter + 1])
                 [ #  # ]
    2402                 :          0 :                     counter += 2;
    2403         [ +  + ]:          6 :                   else if (len3)
    2404                 :            :                     {
    2405                 :          3 :                       p2 = p->down;
    2406   [ -  +  -  + ]:          6 :                       while ((type_field (p2->type) == ASN1_ETYPE_TAG) ||
    2407                 :          3 :                              (type_field (p2->type) == ASN1_ETYPE_SIZE))
    2408                 :          0 :                         p2 = p2->right;
    2409                 :          6 :                       p = p2;
    2410                 :            :                     }
    2411                 :            :                 }
    2412                 :            :               else
    2413                 :            :                 {
    2414 [ +  - ][ +  - ]:          2 :                   if (!der[counter] && !der[counter + 1])       /* indefinite length method */
    2415                 :          2 :                     counter += 2;
    2416                 :            :                 }
    2417                 :          8 :               move = RIGHT;
    2418                 :          8 :               break;
    2419                 :            :             case ASN1_ETYPE_ANY:
    2420         [ #  # ]:          0 :               if (asn1_get_tag_der
    2421                 :          0 :                   (der + counter, len - counter, &class, &len2,
    2422                 :            :                    &tag) != ASN1_SUCCESS)
    2423                 :          0 :                 return ASN1_DER_ERROR;
    2424         [ #  # ]:          0 :               if (counter + len2 > len)
    2425                 :          0 :                 return ASN1_DER_ERROR;
    2426                 :            : 
    2427                 :          0 :               len4 =
    2428                 :          0 :                 asn1_get_length_der (der + counter + len2,
    2429                 :          0 :                                      len - counter - len2, &len3);
    2430         [ #  # ]:          0 :               if (len4 < -1)
    2431                 :          0 :                 return ASN1_DER_ERROR;
    2432                 :            : 
    2433         [ #  # ]:          0 :               if (len4 != -1)
    2434                 :            :                 {
    2435                 :          0 :                   counter += len2 + len4 + len3;
    2436                 :            :                 }
    2437                 :            :               else
    2438                 :            :                 {               /* indefinite length */
    2439                 :            :                   /* Check indefinite lenth method in an EXPLICIT TAG */
    2440 [ #  # ][ #  # ]:          0 :                   if ((p->type & CONST_TAG) && (der[counter - 1] == 0x80))
    2441                 :          0 :                     indefinite = 1;
    2442                 :            :                   else
    2443                 :          0 :                     indefinite = 0;
    2444                 :            : 
    2445                 :          0 :                   len2 = len - counter;
    2446                 :          0 :                   ris =
    2447                 :          0 :                     _asn1_get_indefinite_length_string (der + counter, &len2);
    2448         [ #  # ]:          0 :                   if (ris != ASN1_SUCCESS)
    2449                 :          0 :                     return ris;
    2450                 :          0 :                   counter += len2;
    2451                 :            : 
    2452                 :            :                   /* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
    2453                 :            :                      an indefinite length method. */
    2454         [ #  # ]:          0 :                   if (indefinite)
    2455                 :            :                     {
    2456 [ #  # ][ #  # ]:          0 :                       if (!der[counter] && !der[counter + 1])
    2457                 :          0 :                         counter += 2;
    2458                 :            :                       else
    2459                 :          0 :                         return ASN1_DER_ERROR;
    2460                 :            :                     }
    2461                 :            :                 }
    2462                 :          0 :               move = RIGHT;
    2463                 :          0 :               break;
    2464                 :            :             default:
    2465         [ -  + ]:          4 :               move = (move == UP) ? RIGHT : DOWN;
    2466                 :          4 :               break;
    2467                 :            :             }
    2468                 :            :         }
    2469                 :            : 
    2470 [ +  + ][ +  + ]:         59 :       if ((p == node_to_find) && (move == RIGHT))
    2471                 :            :         {
    2472                 :         12 :           *end = counter - 1;
    2473                 :         12 :           return ASN1_SUCCESS;
    2474                 :            :         }
    2475                 :            : 
    2476 [ +  + ][ -  + ]:         47 :       if (p == node && move != DOWN)
    2477                 :          0 :         break;
    2478                 :            : 
    2479         [ +  + ]:         47 :       if (move == DOWN)
    2480                 :            :         {
    2481         [ +  + ]:         20 :           if (p->down)
    2482                 :         16 :             p = p->down;
    2483                 :            :           else
    2484                 :          4 :             move = RIGHT;
    2485                 :            :         }
    2486 [ +  + ][ +  - ]:         47 :       if ((move == RIGHT) && !(p->type & CONST_SET))
    2487                 :            :         {
    2488         [ +  + ]:         31 :           if (p->right)
    2489                 :         25 :             p = p->right;
    2490                 :            :           else
    2491                 :          6 :             move = UP;
    2492                 :            :         }
    2493         [ +  + ]:         47 :       if (move == UP)
    2494                 :          6 :         p = _asn1_find_up (p);
    2495                 :         47 :     }
    2496                 :            : 
    2497                 :         14 :   return ASN1_ELEMENT_NOT_FOUND;
    2498                 :            : }
    2499                 :            : 
    2500                 :            : /**
    2501                 :            :  * asn1_expand_any_defined_by:
    2502                 :            :  * @definitions: ASN1 definitions
    2503                 :            :  * @element: pointer to an ASN1 structure
    2504                 :            :  *
    2505                 :            :  * Expands every "ANY DEFINED BY" element of a structure created from
    2506                 :            :  * a DER decoding process (asn1_der_decoding function). The element
    2507                 :            :  * ANY must be defined by an OBJECT IDENTIFIER. The type used to
    2508                 :            :  * expand the element ANY is the first one following the definition of
    2509                 :            :  * the actual value of the OBJECT IDENTIFIER.
    2510                 :            :  *
    2511                 :            :  * Returns: %ASN1_SUCCESS if Substitution OK, %ASN1_ERROR_TYPE_ANY if
    2512                 :            :  *   some "ANY DEFINED BY" element couldn't be expanded due to a
    2513                 :            :  *   problem in OBJECT_ID -> TYPE association, or other error codes
    2514                 :            :  *   depending on DER decoding.
    2515                 :            :  **/
    2516                 :            : int
    2517                 :          1 : asn1_expand_any_defined_by (asn1_node definitions, asn1_node * element)
    2518                 :            : {
    2519                 :            :   char definitionsName[ASN1_MAX_NAME_SIZE], name[2 * ASN1_MAX_NAME_SIZE + 1],
    2520                 :            :     value[ASN1_MAX_NAME_SIZE];
    2521                 :          1 :   int retCode = ASN1_SUCCESS, result;
    2522                 :            :   int len, len2, len3;
    2523                 :          1 :   asn1_node p, p2, p3, aux = NULL;
    2524                 :            :   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
    2525                 :            : 
    2526 [ +  - ][ -  + ]:          1 :   if ((definitions == NULL) || (*element == NULL))
    2527                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    2528                 :            : 
    2529                 :          1 :   strcpy (definitionsName, definitions->name);
    2530                 :          1 :   strcat (definitionsName, ".");
    2531                 :            : 
    2532                 :          1 :   p = *element;
    2533         [ +  + ]:         14 :   while (p)
    2534                 :            :     {
    2535                 :            : 
    2536         [ +  + ]:         13 :       switch (type_field (p->type))
    2537                 :            :         {
    2538                 :            :         case ASN1_ETYPE_ANY:
    2539 [ +  - ][ +  - ]:          1 :           if ((p->type & CONST_DEFINED_BY) && (p->value))
    2540                 :            :             {
    2541                 :            :               /* search the "DEF_BY" element */
    2542                 :          1 :               p2 = p->down;
    2543 [ +  - ][ -  + ]:          1 :               while ((p2) && (type_field (p2->type) != ASN1_ETYPE_CONSTANT))
    2544                 :          0 :                 p2 = p2->right;
    2545                 :            : 
    2546         [ -  + ]:          1 :               if (!p2)
    2547                 :            :                 {
    2548                 :          0 :                   retCode = ASN1_ERROR_TYPE_ANY;
    2549                 :          0 :                   break;
    2550                 :            :                 }
    2551                 :            : 
    2552                 :          1 :               p3 = _asn1_find_up (p);
    2553                 :            : 
    2554         [ -  + ]:          1 :               if (!p3)
    2555                 :            :                 {
    2556                 :          0 :                   retCode = ASN1_ERROR_TYPE_ANY;
    2557                 :          0 :                   break;
    2558                 :            :                 }
    2559                 :            : 
    2560                 :          1 :               p3 = p3->down;
    2561         [ +  - ]:          4 :               while (p3)
    2562                 :            :                 {
    2563         [ +  + ]:          4 :                   if (!(strcmp (p3->name, p2->name)))
    2564                 :          1 :                     break;
    2565                 :          3 :                   p3 = p3->right;
    2566                 :            :                 }
    2567                 :            : 
    2568 [ +  - ][ +  - ]:          1 :               if ((!p3) || (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID) ||
                 [ -  + ]
    2569                 :          1 :                   (p3->value == NULL))
    2570                 :            :                 {
    2571                 :            : 
    2572                 :          0 :                   p3 = _asn1_find_up (p);
    2573                 :          0 :                   p3 = _asn1_find_up (p3);
    2574                 :            : 
    2575         [ #  # ]:          0 :                   if (!p3)
    2576                 :            :                     {
    2577                 :          0 :                       retCode = ASN1_ERROR_TYPE_ANY;
    2578                 :          0 :                       break;
    2579                 :            :                     }
    2580                 :            : 
    2581                 :          0 :                   p3 = p3->down;
    2582                 :            : 
    2583         [ #  # ]:          0 :                   while (p3)
    2584                 :            :                     {
    2585         [ #  # ]:          0 :                       if (!(strcmp (p3->name, p2->name)))
    2586                 :          0 :                         break;
    2587                 :          0 :                       p3 = p3->right;
    2588                 :            :                     }
    2589                 :            : 
    2590 [ #  # ][ #  # ]:          0 :                   if ((!p3) || (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID)
    2591         [ #  # ]:          0 :                       || (p3->value == NULL))
    2592                 :            :                     {
    2593                 :          0 :                       retCode = ASN1_ERROR_TYPE_ANY;
    2594                 :          0 :                       break;
    2595                 :            :                     }
    2596                 :            :                 }
    2597                 :            : 
    2598                 :            :               /* search the OBJECT_ID into definitions */
    2599                 :          1 :               p2 = definitions->down;
    2600         [ +  - ]:         23 :               while (p2)
    2601                 :            :                 {
    2602 [ +  + ][ +  + ]:         23 :                   if ((type_field (p2->type) == ASN1_ETYPE_OBJECT_ID) &&
    2603                 :          6 :                       (p2->type & CONST_ASSIGN))
    2604                 :            :                     {
    2605                 :          4 :                       strcpy (name, definitionsName);
    2606                 :          4 :                       strcat (name, p2->name);
    2607                 :            : 
    2608                 :          4 :                       len = ASN1_MAX_NAME_SIZE;
    2609                 :          4 :                       result =
    2610                 :            :                         asn1_read_value (definitions, name, value, &len);
    2611                 :            : 
    2612         [ +  - ]:          4 :                       if ((result == ASN1_SUCCESS)
    2613         [ +  + ]:          4 :                           && (!_asn1_strcmp (p3->value, value)))
    2614                 :            :                         {
    2615                 :          1 :                           p2 = p2->right;    /* pointer to the structure to
    2616                 :            :                                                    use for expansion */
    2617 [ +  - ][ -  + ]:          1 :                           while ((p2) && (p2->type & CONST_ASSIGN))
    2618                 :          0 :                             p2 = p2->right;
    2619                 :            : 
    2620         [ +  - ]:          1 :                           if (p2)
    2621                 :            :                             {
    2622                 :          1 :                               strcpy (name, definitionsName);
    2623                 :          1 :                               strcat (name, p2->name);
    2624                 :            : 
    2625                 :          1 :                               result =
    2626                 :            :                                 asn1_create_element (definitions, name, &aux);
    2627         [ +  - ]:          1 :                               if (result == ASN1_SUCCESS)
    2628                 :            :                                 {
    2629                 :          1 :                                   _asn1_cpy_name (aux, p);
    2630                 :          1 :                                   len2 =
    2631                 :          1 :                                     asn1_get_length_der (p->value,
    2632                 :          1 :                                                          p->value_len, &len3);
    2633         [ -  + ]:          1 :                                   if (len2 < 0)
    2634                 :          0 :                                     return ASN1_DER_ERROR;
    2635                 :            : 
    2636                 :          1 :                                   result =
    2637                 :          1 :                                     asn1_der_decoding (&aux, p->value + len3,
    2638                 :            :                                                        len2,
    2639                 :            :                                                        errorDescription);
    2640         [ +  - ]:          1 :                                   if (result == ASN1_SUCCESS)
    2641                 :            :                                     {
    2642                 :            : 
    2643                 :          1 :                                       _asn1_set_right (aux, p->right);
    2644                 :          1 :                                       _asn1_set_right (p, aux);
    2645                 :            : 
    2646                 :          1 :                                       result = asn1_delete_structure (&p);
    2647         [ +  - ]:          1 :                                       if (result == ASN1_SUCCESS)
    2648                 :            :                                         {
    2649                 :          1 :                                           p = aux;
    2650                 :          1 :                                           aux = NULL;
    2651                 :          1 :                                           break;
    2652                 :            :                                         }
    2653                 :            :                                       else
    2654                 :            :                                         {       /* error with asn1_delete_structure */
    2655                 :          0 :                                           asn1_delete_structure (&aux);
    2656                 :          0 :                                           retCode = result;
    2657                 :          0 :                                           break;
    2658                 :            :                                         }
    2659                 :            :                                     }
    2660                 :            :                                   else
    2661                 :            :                                     {   /* error with asn1_der_decoding */
    2662                 :          0 :                                       retCode = result;
    2663                 :          0 :                                       break;
    2664                 :            :                                     }
    2665                 :            :                                 }
    2666                 :            :                               else
    2667                 :            :                                 {       /* error with asn1_create_element */
    2668                 :          0 :                                   retCode = result;
    2669                 :          0 :                                   break;
    2670                 :            :                                 }
    2671                 :            :                             }
    2672                 :            :                           else
    2673                 :            :                             {   /* error with the pointer to the structure to exapand */
    2674                 :          0 :                               retCode = ASN1_ERROR_TYPE_ANY;
    2675                 :          0 :                               break;
    2676                 :            :                             }
    2677                 :            :                         }
    2678                 :            :                     }
    2679                 :         22 :                   p2 = p2->right;
    2680                 :            :                 }               /* end while */
    2681                 :            : 
    2682         [ -  + ]:          1 :               if (!p2)
    2683                 :            :                 {
    2684                 :          0 :                   retCode = ASN1_ERROR_TYPE_ANY;
    2685                 :          0 :                   break;
    2686                 :            :                 }
    2687                 :            : 
    2688                 :            :             }
    2689                 :          1 :           break;
    2690                 :            :         default:
    2691                 :         12 :           break;
    2692                 :            :         }
    2693                 :            : 
    2694                 :            : 
    2695         [ +  + ]:         13 :       if (p->down)
    2696                 :            :         {
    2697                 :          3 :           p = p->down;
    2698                 :            :         }
    2699         [ -  + ]:         10 :       else if (p == *element)
    2700                 :            :         {
    2701                 :          0 :           p = NULL;
    2702                 :          0 :           break;
    2703                 :            :         }
    2704         [ +  + ]:         10 :       else if (p->right)
    2705                 :          7 :         p = p->right;
    2706                 :            :       else
    2707                 :            :         {
    2708                 :            :           while (1)
    2709                 :            :             {
    2710                 :          3 :               p = _asn1_find_up (p);
    2711         [ +  + ]:          3 :               if (p == *element)
    2712                 :            :                 {
    2713                 :          1 :                   p = NULL;
    2714                 :          1 :                   break;
    2715                 :            :                 }
    2716         [ +  - ]:          2 :               if (p->right)
    2717                 :            :                 {
    2718                 :          2 :                   p = p->right;
    2719                 :          2 :                   break;
    2720                 :            :                 }
    2721                 :          0 :             }
    2722                 :            :         }
    2723                 :            :     }
    2724                 :            : 
    2725                 :          1 :   return retCode;
    2726                 :            : }
    2727                 :            : 
    2728                 :            : /**
    2729                 :            :  * asn1_expand_octet_string:
    2730                 :            :  * @definitions: ASN1 definitions
    2731                 :            :  * @element: pointer to an ASN1 structure
    2732                 :            :  * @octetName: name of the OCTECT STRING field to expand.
    2733                 :            :  * @objectName: name of the OBJECT IDENTIFIER field to use to define
    2734                 :            :  *    the type for expansion.
    2735                 :            :  *
    2736                 :            :  * Expands an "OCTET STRING" element of a structure created from a DER
    2737                 :            :  * decoding process (the asn1_der_decoding() function).  The type used
    2738                 :            :  * for expansion is the first one following the definition of the
    2739                 :            :  * actual value of the OBJECT IDENTIFIER indicated by OBJECTNAME.
    2740                 :            :  *
    2741                 :            :  * Returns: %ASN1_SUCCESS if substitution OK, %ASN1_ELEMENT_NOT_FOUND
    2742                 :            :  *   if @objectName or @octetName are not correct,
    2743                 :            :  *   %ASN1_VALUE_NOT_VALID if it wasn't possible to find the type to
    2744                 :            :  *   use for expansion, or other errors depending on DER decoding.
    2745                 :            :  **/
    2746                 :            : int
    2747                 :          2 : asn1_expand_octet_string (asn1_node definitions, asn1_node * element,
    2748                 :            :                           const char *octetName, const char *objectName)
    2749                 :            : {
    2750                 :            :   char name[2 * ASN1_MAX_NAME_SIZE + 1], value[ASN1_MAX_NAME_SIZE];
    2751                 :          2 :   int retCode = ASN1_SUCCESS, result;
    2752                 :            :   int len, len2, len3;
    2753                 :          2 :   asn1_node p2, aux = NULL;
    2754                 :          2 :   asn1_node octetNode = NULL, objectNode = NULL;
    2755                 :            :   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
    2756                 :            : 
    2757 [ +  - ][ -  + ]:          2 :   if ((definitions == NULL) || (*element == NULL))
    2758                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    2759                 :            : 
    2760                 :          2 :   octetNode = asn1_find_node (*element, octetName);
    2761         [ -  + ]:          2 :   if (octetNode == NULL)
    2762                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    2763         [ -  + ]:          2 :   if (type_field (octetNode->type) != ASN1_ETYPE_OCTET_STRING)
    2764                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    2765         [ -  + ]:          2 :   if (octetNode->value == NULL)
    2766                 :          0 :     return ASN1_VALUE_NOT_FOUND;
    2767                 :            : 
    2768                 :          2 :   objectNode = asn1_find_node (*element, objectName);
    2769         [ -  + ]:          2 :   if (objectNode == NULL)
    2770                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    2771                 :            : 
    2772         [ -  + ]:          2 :   if (type_field (objectNode->type) != ASN1_ETYPE_OBJECT_ID)
    2773                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    2774                 :            : 
    2775         [ -  + ]:          2 :   if (objectNode->value == NULL)
    2776                 :          0 :     return ASN1_VALUE_NOT_FOUND;
    2777                 :            : 
    2778                 :            : 
    2779                 :            :   /* search the OBJECT_ID into definitions */
    2780                 :          2 :   p2 = definitions->down;
    2781         [ +  - ]:         41 :   while (p2)
    2782                 :            :     {
    2783 [ +  + ][ +  + ]:         41 :       if ((type_field (p2->type) == ASN1_ETYPE_OBJECT_ID) &&
    2784                 :          9 :           (p2->type & CONST_ASSIGN))
    2785                 :            :         {
    2786                 :          5 :           strcpy (name, definitions->name);
    2787                 :          5 :           strcat (name, ".");
    2788                 :          5 :           strcat (name, p2->name);
    2789                 :            : 
    2790                 :          5 :           len = sizeof (value);
    2791                 :          5 :           result = asn1_read_value (definitions, name, value, &len);
    2792                 :            : 
    2793         [ +  - ]:          5 :           if ((result == ASN1_SUCCESS)
    2794         [ +  + ]:          5 :               && (!_asn1_strcmp (objectNode->value, value)))
    2795                 :            :             {
    2796                 :            : 
    2797                 :          2 :               p2 = p2->right;        /* pointer to the structure to
    2798                 :            :                                    use for expansion */
    2799 [ +  - ][ -  + ]:          2 :               while ((p2) && (p2->type & CONST_ASSIGN))
    2800                 :          0 :                 p2 = p2->right;
    2801                 :            : 
    2802         [ +  - ]:          2 :               if (p2)
    2803                 :            :                 {
    2804                 :          2 :                   strcpy (name, definitions->name);
    2805                 :          2 :                   strcat (name, ".");
    2806                 :          2 :                   strcat (name, p2->name);
    2807                 :            : 
    2808                 :          2 :                   result = asn1_create_element (definitions, name, &aux);
    2809         [ +  - ]:          2 :                   if (result == ASN1_SUCCESS)
    2810                 :            :                     {
    2811                 :          2 :                       _asn1_cpy_name (aux, octetNode);
    2812                 :          2 :                       len2 =
    2813                 :          2 :                         asn1_get_length_der (octetNode->value,
    2814                 :          2 :                                              octetNode->value_len, &len3);
    2815         [ -  + ]:          2 :                       if (len2 < 0)
    2816                 :          0 :                         return ASN1_DER_ERROR;
    2817                 :            : 
    2818                 :          2 :                       result =
    2819                 :          2 :                         asn1_der_decoding (&aux, octetNode->value + len3,
    2820                 :            :                                            len2, errorDescription);
    2821         [ +  - ]:          2 :                       if (result == ASN1_SUCCESS)
    2822                 :            :                         {
    2823                 :            : 
    2824                 :          2 :                           _asn1_set_right (aux, octetNode->right);
    2825                 :          2 :                           _asn1_set_right (octetNode, aux);
    2826                 :            : 
    2827                 :          2 :                           result = asn1_delete_structure (&octetNode);
    2828         [ +  - ]:          2 :                           if (result == ASN1_SUCCESS)
    2829                 :            :                             {
    2830                 :          2 :                               aux = NULL;
    2831                 :          2 :                               break;
    2832                 :            :                             }
    2833                 :            :                           else
    2834                 :            :                             {   /* error with asn1_delete_structure */
    2835                 :          0 :                               asn1_delete_structure (&aux);
    2836                 :          0 :                               retCode = result;
    2837                 :          0 :                               break;
    2838                 :            :                             }
    2839                 :            :                         }
    2840                 :            :                       else
    2841                 :            :                         {       /* error with asn1_der_decoding */
    2842                 :          0 :                           retCode = result;
    2843                 :          0 :                           break;
    2844                 :            :                         }
    2845                 :            :                     }
    2846                 :            :                   else
    2847                 :            :                     {           /* error with asn1_create_element */
    2848                 :          0 :                       retCode = result;
    2849                 :          0 :                       break;
    2850                 :            :                     }
    2851                 :            :                 }
    2852                 :            :               else
    2853                 :            :                 {               /* error with the pointer to the structure to exapand */
    2854                 :          0 :                   retCode = ASN1_VALUE_NOT_VALID;
    2855                 :          0 :                   break;
    2856                 :            :                 }
    2857                 :            :             }
    2858                 :            :         }
    2859                 :            : 
    2860                 :         39 :       p2 = p2->right;
    2861                 :            : 
    2862                 :            :     }
    2863                 :            : 
    2864         [ -  + ]:          2 :   if (!p2)
    2865                 :          0 :     retCode = ASN1_VALUE_NOT_VALID;
    2866                 :            : 
    2867                 :          2 :   return retCode;
    2868                 :            : }
    2869                 :            : 
    2870                 :            : /**
    2871                 :            :  * asn1_decode_simple_der:
    2872                 :            :  * @etype: The type of the string to be encoded (ASN1_ETYPE_)
    2873                 :            :  * @der: the encoded string
    2874                 :            :  * @der_len: the bytes of the encoded string
    2875                 :            :  * @str: a pointer to the data
    2876                 :            :  * @str_len: the length of the data
    2877                 :            :  *
    2878                 :            :  * Decodes a simple DER encoded type (e.g. a string, which is not constructed).
    2879                 :            :  * The output is a pointer inside the @der.
    2880                 :            :  *
    2881                 :            :  * Returns: %ASN1_SUCCESS if successful or an error value.
    2882                 :            :  **/
    2883                 :            : int
    2884                 :          5 : asn1_decode_simple_der (unsigned int etype, const unsigned char *der,
    2885                 :            :                         unsigned int der_len, const unsigned char **str,
    2886                 :            :                         unsigned int *str_len)
    2887                 :            : {
    2888                 :            :   int tag_len, len_len;
    2889                 :            :   const unsigned char *p;
    2890                 :            :   unsigned char class;
    2891                 :            :   unsigned long tag;
    2892                 :            :   long ret;
    2893                 :            : 
    2894 [ +  - ][ -  + ]:          5 :   if (der == NULL || der_len == 0)
    2895                 :          0 :     return ASN1_VALUE_NOT_VALID;
    2896                 :            : 
    2897 [ +  - ][ +  - ]:          5 :   if (ETYPE_OK (etype) == 0)
         [ +  - ][ -  + ]
    2898                 :          0 :     return ASN1_VALUE_NOT_VALID;
    2899                 :            : 
    2900                 :            :   /* doesn't handle constructed classes */
    2901         [ -  + ]:          5 :   if (ETYPE_CLASS (etype) != ASN1_CLASS_UNIVERSAL)
    2902                 :          0 :     return ASN1_VALUE_NOT_VALID;
    2903                 :            : 
    2904                 :          5 :   p = der;
    2905                 :          5 :   ret = asn1_get_tag_der (p, der_len, &class, &tag_len, &tag);
    2906         [ -  + ]:          5 :   if (ret != ASN1_SUCCESS)
    2907                 :          0 :     return ret;
    2908                 :            : 
    2909 [ +  - ][ -  + ]:          5 :   if (class != ETYPE_CLASS (etype) || tag != ETYPE_TAG (etype))
    2910                 :          0 :     return ASN1_DER_ERROR;
    2911                 :            : 
    2912                 :          5 :   p += tag_len;
    2913                 :          5 :   der_len -= tag_len;
    2914                 :            : 
    2915                 :          5 :   ret = asn1_get_length_der (p, der_len, &len_len);
    2916         [ -  + ]:          5 :   if (ret < 0)
    2917                 :          0 :     return ASN1_DER_ERROR;
    2918                 :            : 
    2919                 :          5 :   p += len_len;
    2920                 :          5 :   der_len -= len_len;
    2921                 :            : 
    2922                 :          5 :   *str_len = ret;
    2923                 :          5 :   *str = p;
    2924                 :            : 
    2925                 :          5 :   return ASN1_SUCCESS;
    2926                 :            : }

Generated by: LCOV version 1.9