LCOV - code coverage report
Current view: top level - lib - element.c (source / functions) Hit Total Coverage
Test: GNU Libtasn1 Lines: 253 376 67.3 %
Date: 2013-03-24 Functions: 6 8 75.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 216 365 59.2 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (C) 2000-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                 :            : /* File: element.c                                   */
      24                 :            : /* Description: Functions with the read and write    */
      25                 :            : /*   functions.                                      */
      26                 :            : /*****************************************************/
      27                 :            : 
      28                 :            : 
      29                 :            : #include <int.h>
      30                 :            : #include "parser_aux.h"
      31                 :            : #include <gstr.h>
      32                 :            : #include "structure.h"
      33                 :            : 
      34                 :            : #include "element.h"
      35                 :            : 
      36                 :            : void
      37                 :          0 : _asn1_hierarchical_name (asn1_node node, char *name, int name_size)
      38                 :            : {
      39                 :            :   asn1_node p;
      40                 :            :   char tmp_name[64];
      41                 :            : 
      42                 :          0 :   p = node;
      43                 :            : 
      44                 :          0 :   name[0] = 0;
      45                 :            : 
      46         [ #  # ]:          0 :   while (p != NULL)
      47                 :            :     {
      48         [ #  # ]:          0 :       if (p->name[0] != 0)
      49                 :            :         {
      50                 :          0 :           _asn1_str_cpy (tmp_name, sizeof (tmp_name), name),
      51                 :          0 :             _asn1_str_cpy (name, name_size, p->name);
      52                 :          0 :           _asn1_str_cat (name, name_size, ".");
      53                 :          0 :           _asn1_str_cat (name, name_size, tmp_name);
      54                 :            :         }
      55                 :          0 :       p = _asn1_find_up (p);
      56                 :            :     }
      57                 :            : 
      58         [ #  # ]:          0 :   if (name[0] == 0)
      59                 :          0 :     _asn1_str_cpy (name, name_size, "ROOT");
      60                 :          0 : }
      61                 :            : 
      62                 :            : 
      63                 :            : /******************************************************************/
      64                 :            : /* Function : _asn1_convert_integer                               */
      65                 :            : /* Description: converts an integer from a null terminated string */
      66                 :            : /*              to der decoding. The convertion from a null       */
      67                 :            : /*              terminated string to an integer is made with      */
      68                 :            : /*              the 'strtol' function.                            */
      69                 :            : /* Parameters:                                                    */
      70                 :            : /*   value: null terminated string to convert.                    */
      71                 :            : /*   value_out: convertion result (memory must be already         */
      72                 :            : /*              allocated).                                       */
      73                 :            : /*   value_out_size: number of bytes of value_out.                */
      74                 :            : /*   len: number of significant byte of value_out.                */
      75                 :            : /* Return: ASN1_MEM_ERROR or ASN1_SUCCESS                         */
      76                 :            : /******************************************************************/
      77                 :            : int
      78                 :        145 : _asn1_convert_integer (const unsigned char *value, unsigned char *value_out,
      79                 :            :                        int value_out_size, int *len)
      80                 :            : {
      81                 :            :   char negative;
      82                 :            :   unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
      83                 :            :   long valtmp;
      84                 :            :   int k, k2;
      85                 :            : 
      86                 :        145 :   valtmp = _asn1_strtol (value, NULL, 10);
      87                 :            : 
      88         [ +  + ]:       1305 :   for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
      89                 :            :     {
      90                 :       1160 :       val[SIZEOF_UNSIGNED_LONG_INT - k - 1] = (valtmp >> (8 * k)) & 0xFF;
      91                 :            :     }
      92                 :            : 
      93         [ +  + ]:        145 :   if (val[0] & 0x80)
      94                 :          4 :     negative = 1;
      95                 :            :   else
      96                 :        141 :     negative = 0;
      97                 :            : 
      98         [ +  + ]:       1138 :   for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT - 1; k++)
      99                 :            :     {
     100 [ +  + ][ +  + ]:       1005 :       if (negative && (val[k] != 0xFF))
     101                 :            :         break;
     102 [ +  + ][ +  + ]:       1003 :       else if (!negative && val[k])
     103                 :         10 :         break;
     104                 :            :     }
     105                 :            : 
     106 [ +  + ][ +  - ]:        145 :   if ((negative && !(val[k] & 0x80)) || (!negative && (val[k] & 0x80)))
         [ +  + ][ +  + ]
     107                 :         15 :     k--;
     108                 :            : 
     109                 :        145 :   *len = SIZEOF_UNSIGNED_LONG_INT - k;
     110                 :            : 
     111         [ -  + ]:        145 :   if (SIZEOF_UNSIGNED_LONG_INT - k > value_out_size)
     112                 :            :     /* VALUE_OUT is too short to contain the value conversion */
     113                 :          0 :     return ASN1_MEM_ERROR;
     114                 :            : 
     115         [ +  + ]:        327 :   for (k2 = k; k2 < SIZEOF_UNSIGNED_LONG_INT; k2++)
     116                 :        182 :     value_out[k2 - k] = val[k2];
     117                 :            : 
     118                 :            : #if 0
     119                 :            :   printf ("_asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
     120                 :            :   for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
     121                 :            :     printf (", vOut[%d]=%d", k, value_out[k]);
     122                 :            :   printf ("\n");
     123                 :            : #endif
     124                 :            : 
     125                 :        145 :   return ASN1_SUCCESS;
     126                 :            : }
     127                 :            : 
     128                 :            : 
     129                 :            : int
     130                 :         41 : _asn1_append_sequence_set (asn1_node node)
     131                 :            : {
     132                 :            :   asn1_node p, p2;
     133                 :            :   char temp[10];
     134                 :            :   long n;
     135                 :            : 
     136 [ +  - ][ -  + ]:         41 :   if (!node || !(node->down))
     137                 :          0 :     return ASN1_GENERIC_ERROR;
     138                 :            : 
     139                 :         41 :   p = node->down;
     140         [ +  + ]:         79 :   while ((type_field (p->type) == ASN1_ETYPE_TAG)
     141         [ +  + ]:         63 :          || (type_field (p->type) == ASN1_ETYPE_SIZE))
     142                 :         38 :     p = p->right;
     143                 :         41 :   p2 = _asn1_copy_structure3 (p);
     144         [ +  + ]:         96 :   while (p->right)
     145                 :         55 :     p = p->right;
     146                 :         41 :   _asn1_set_right (p, p2);
     147                 :            : 
     148         [ +  + ]:         41 :   if (p->name[0] == 0)
     149                 :         18 :     _asn1_str_cpy (temp, sizeof (temp), "?1");
     150                 :            :   else
     151                 :            :     {
     152                 :         23 :       n = strtol (p->name + 1, NULL, 0);
     153                 :         23 :       n++;
     154                 :         23 :       temp[0] = '?';
     155                 :         23 :       _asn1_ltostr (n, temp + 1);
     156                 :            :     }
     157                 :         41 :   _asn1_set_name (p2, temp);
     158                 :            :   /*  p2->type |= CONST_OPTION; */
     159                 :            : 
     160                 :         41 :   return ASN1_SUCCESS;
     161                 :            : }
     162                 :            : 
     163                 :            : 
     164                 :            : /**
     165                 :            :  * asn1_write_value:
     166                 :            :  * @node_root: pointer to a structure
     167                 :            :  * @name: the name of the element inside the structure that you want to set.
     168                 :            :  * @ivalue: vector used to specify the value to set. If len is >0,
     169                 :            :  *   VALUE must be a two's complement form integer.  if len=0 *VALUE
     170                 :            :  *   must be a null terminated string with an integer value.
     171                 :            :  * @len: number of bytes of *value to use to set the value:
     172                 :            :  *   value[0]..value[len-1] or 0 if value is a null terminated string
     173                 :            :  *
     174                 :            :  * Set the value of one element inside a structure.
     175                 :            :  *
     176                 :            :  * If an element is OPTIONAL and you want to delete it, you must use
     177                 :            :  * the value=NULL and len=0.  Using "pkix.asn":
     178                 :            :  *
     179                 :            :  * result=asn1_write_value(cert, "tbsCertificate.issuerUniqueID",
     180                 :            :  * NULL, 0);
     181                 :            :  *
     182                 :            :  * Description for each type:
     183                 :            :  *
     184                 :            :  * INTEGER: VALUE must contain a two's complement form integer.
     185                 :            :  *
     186                 :            :  *            value[0]=0xFF ,               len=1 -> integer=-1.
     187                 :            :  *            value[0]=0xFF value[1]=0xFF , len=2 -> integer=-1.
     188                 :            :  *            value[0]=0x01 ,               len=1 -> integer= 1.
     189                 :            :  *            value[0]=0x00 value[1]=0x01 , len=2 -> integer= 1.
     190                 :            :  *            value="123"                 , len=0 -> integer= 123.
     191                 :            :  *
     192                 :            :  * ENUMERATED: As INTEGER (but only with not negative numbers).
     193                 :            :  *
     194                 :            :  * BOOLEAN: VALUE must be the null terminated string "TRUE" or
     195                 :            :  *   "FALSE" and LEN != 0.
     196                 :            :  *
     197                 :            :  *            value="TRUE" , len=1 -> boolean=TRUE.
     198                 :            :  *            value="FALSE" , len=1 -> boolean=FALSE.
     199                 :            :  *
     200                 :            :  * OBJECT IDENTIFIER: VALUE must be a null terminated string with
     201                 :            :  *   each number separated by a dot (e.g. "1.2.3.543.1").  LEN != 0.
     202                 :            :  *
     203                 :            :  *            value="1 2 840 10040 4 3" , len=1 -> OID=dsa-with-sha.
     204                 :            :  *
     205                 :            :  * UTCTime: VALUE must be a null terminated string in one of these
     206                 :            :  *   formats: "YYMMDDhhmmssZ", "YYMMDDhhmmssZ",
     207                 :            :  *   "YYMMDDhhmmss+hh'mm'", "YYMMDDhhmmss-hh'mm'",
     208                 :            :  *   "YYMMDDhhmm+hh'mm'", or "YYMMDDhhmm-hh'mm'".  LEN != 0.
     209                 :            :  *
     210                 :            :  *            value="9801011200Z" , len=1 -> time=Jannuary 1st, 1998
     211                 :            :  *            at 12h 00m Greenwich Mean Time
     212                 :            :  *
     213                 :            :  * GeneralizedTime: VALUE must be in one of this format:
     214                 :            :  *   "YYYYMMDDhhmmss.sZ", "YYYYMMDDhhmmss.sZ",
     215                 :            :  *   "YYYYMMDDhhmmss.s+hh'mm'", "YYYYMMDDhhmmss.s-hh'mm'",
     216                 :            :  *   "YYYYMMDDhhmm+hh'mm'", or "YYYYMMDDhhmm-hh'mm'" where ss.s
     217                 :            :  *   indicates the seconds with any precision like "10.1" or "01.02".
     218                 :            :  *   LEN != 0
     219                 :            :  *
     220                 :            :  *            value="2001010112001.12-0700" , len=1 -> time=Jannuary
     221                 :            :  *            1st, 2001 at 12h 00m 01.12s Pacific Daylight Time
     222                 :            :  *
     223                 :            :  * OCTET STRING: VALUE contains the octet string and LEN is the
     224                 :            :  *   number of octets.
     225                 :            :  *
     226                 :            :  *            value="$\backslash$x01$\backslash$x02$\backslash$x03" ,
     227                 :            :  *            len=3 -> three bytes octet string
     228                 :            :  *
     229                 :            :  * GeneralString: VALUE contains the generalstring and LEN is the
     230                 :            :  *   number of octets.
     231                 :            :  *
     232                 :            :  *            value="$\backslash$x01$\backslash$x02$\backslash$x03" ,
     233                 :            :  *            len=3 -> three bytes generalstring
     234                 :            :  *
     235                 :            :  * BIT STRING: VALUE contains the bit string organized by bytes and
     236                 :            :  *   LEN is the number of bits.
     237                 :            :  *
     238                 :            :  *   value="$\backslash$xCF" , len=6 -> bit string="110011" (six
     239                 :            :  *   bits)
     240                 :            :  *
     241                 :            :  * CHOICE: if NAME indicates a choice type, VALUE must specify one of
     242                 :            :  *   the alternatives with a null terminated string. LEN != 0. Using
     243                 :            :  *   "pkix.asn"\:
     244                 :            :  *
     245                 :            :  *           result=asn1_write_value(cert,
     246                 :            :  *           "certificate1.tbsCertificate.subject", "rdnSequence",
     247                 :            :  *           1);
     248                 :            :  *
     249                 :            :  * ANY: VALUE indicates the der encoding of a structure.  LEN != 0.
     250                 :            :  *
     251                 :            :  * SEQUENCE OF: VALUE must be the null terminated string "NEW" and
     252                 :            :  *   LEN != 0. With this instruction another element is appended in
     253                 :            :  *   the sequence. The name of this element will be "?1" if it's the
     254                 :            :  *   first one, "?2" for the second and so on.
     255                 :            :  *
     256                 :            :  *   Using "pkix.asn"\:
     257                 :            :  *
     258                 :            :  *   result=asn1_write_value(cert,
     259                 :            :  *   "certificate1.tbsCertificate.subject.rdnSequence", "NEW", 1);
     260                 :            :  *
     261                 :            :  * SET OF: the same as SEQUENCE OF.  Using "pkix.asn":
     262                 :            :  *
     263                 :            :  *           result=asn1_write_value(cert,
     264                 :            :  *           "tbsCertificate.subject.rdnSequence.?LAST", "NEW", 1);
     265                 :            :  *
     266                 :            :  * Returns: %ASN1_SUCCESS if the value was set,
     267                 :            :  *   %ASN1_ELEMENT_NOT_FOUND if @name is not a valid element, and
     268                 :            :  *   %ASN1_VALUE_NOT_VALID if @ivalue has a wrong format.
     269                 :            :  **/
     270                 :            : int
     271                 :         85 : asn1_write_value (asn1_node node_root, const char *name,
     272                 :            :                   const void *ivalue, int len)
     273                 :            : {
     274                 :            :   asn1_node node, p, p2;
     275                 :         85 :   unsigned char *temp, *value_temp = NULL, *default_temp = NULL;
     276                 :            :   int len2, k, k2, negative;
     277                 :            :   size_t i;
     278                 :         85 :   const unsigned char *value = ivalue;
     279                 :            :   unsigned int type;
     280                 :            : 
     281                 :         85 :   node = asn1_find_node (node_root, name);
     282         [ -  + ]:         85 :   if (node == NULL)
     283                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
     284                 :            : 
     285 [ +  + ][ +  + ]:         85 :   if ((node->type & CONST_OPTION) && (value == NULL) && (len == 0))
                 [ +  - ]
     286                 :            :     {
     287                 :          5 :       asn1_delete_structure (&node);
     288                 :          5 :       return ASN1_SUCCESS;
     289                 :            :     }
     290                 :            : 
     291                 :         80 :   type = type_field (node->type);
     292                 :            : 
     293 [ +  + ][ -  + ]:         80 :   if ((type == ASN1_ETYPE_SEQUENCE_OF) && (value == NULL) && (len == 0))
                 [ #  # ]
     294                 :            :     {
     295                 :          0 :       p = node->down;
     296         [ #  # ]:          0 :       while ((type_field (p->type) == ASN1_ETYPE_TAG)
     297         [ #  # ]:          0 :              || (type_field (p->type) == ASN1_ETYPE_SIZE))
     298                 :          0 :         p = p->right;
     299                 :            : 
     300         [ #  # ]:          0 :       while (p->right)
     301                 :          0 :         asn1_delete_structure (&p->right);
     302                 :            : 
     303                 :          0 :       return ASN1_SUCCESS;
     304                 :            :     }
     305                 :            : 
     306   [ +  +  +  +  :         80 :   switch (type)
          +  +  +  +  +  
                   +  - ]
     307                 :            :     {
     308                 :            :     case ASN1_ETYPE_BOOLEAN:
     309         [ +  - ]:          1 :       if (!_asn1_strcmp (value, "TRUE"))
     310                 :            :         {
     311         [ -  + ]:          1 :           if (node->type & CONST_DEFAULT)
     312                 :            :             {
     313                 :          0 :               p = node->down;
     314         [ #  # ]:          0 :               while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
     315                 :          0 :                 p = p->right;
     316         [ #  # ]:          0 :               if (p->type & CONST_TRUE)
     317                 :          0 :                 _asn1_set_value (node, NULL, 0);
     318                 :            :               else
     319                 :          0 :                 _asn1_set_value (node, "T", 1);
     320                 :            :             }
     321                 :            :           else
     322                 :          1 :             _asn1_set_value (node, "T", 1);
     323                 :            :         }
     324         [ #  # ]:          0 :       else if (!_asn1_strcmp (value, "FALSE"))
     325                 :            :         {
     326         [ #  # ]:          0 :           if (node->type & CONST_DEFAULT)
     327                 :            :             {
     328                 :          0 :               p = node->down;
     329         [ #  # ]:          0 :               while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
     330                 :          0 :                 p = p->right;
     331         [ #  # ]:          0 :               if (p->type & CONST_FALSE)
     332                 :          0 :                 _asn1_set_value (node, NULL, 0);
     333                 :            :               else
     334                 :          0 :                 _asn1_set_value (node, "F", 1);
     335                 :            :             }
     336                 :            :           else
     337                 :          0 :             _asn1_set_value (node, "F", 1);
     338                 :            :         }
     339                 :            :       else
     340                 :          0 :         return ASN1_VALUE_NOT_VALID;
     341                 :          1 :       break;
     342                 :            :     case ASN1_ETYPE_INTEGER:
     343                 :            :     case ASN1_ETYPE_ENUMERATED:
     344         [ +  + ]:         24 :       if (len == 0)
     345                 :            :         {
     346 [ +  + ][ +  + ]:         23 :           if ((isdigit (value[0])) || (value[0] == '-'))
     347                 :            :             {
     348                 :         22 :               value_temp = malloc (SIZEOF_UNSIGNED_LONG_INT);
     349         [ -  + ]:         22 :               if (value_temp == NULL)
     350                 :          0 :                 return ASN1_MEM_ALLOC_ERROR;
     351                 :            : 
     352                 :         22 :               _asn1_convert_integer (value, value_temp,
     353                 :            :                                      SIZEOF_UNSIGNED_LONG_INT, &len);
     354                 :            :             }
     355                 :            :           else
     356                 :            :             {                   /* is an identifier like v1 */
     357         [ -  + ]:          1 :               if (!(node->type & CONST_LIST))
     358                 :          0 :                 return ASN1_VALUE_NOT_VALID;
     359                 :          1 :               p = node->down;
     360         [ +  - ]:          4 :               while (p)
     361                 :            :                 {
     362         [ +  + ]:          4 :                   if (type_field (p->type) == ASN1_ETYPE_CONSTANT)
     363                 :            :                     {
     364         [ +  + ]:          2 :                       if (!_asn1_strcmp (p->name, value))
     365                 :            :                         {
     366                 :          1 :                           value_temp = malloc (SIZEOF_UNSIGNED_LONG_INT);
     367         [ -  + ]:          1 :                           if (value_temp == NULL)
     368                 :          0 :                             return ASN1_MEM_ALLOC_ERROR;
     369                 :            : 
     370                 :          1 :                           _asn1_convert_integer (p->value,
     371                 :            :                                                  value_temp,
     372                 :            :                                                  SIZEOF_UNSIGNED_LONG_INT,
     373                 :            :                                                  &len);
     374                 :          1 :                           break;
     375                 :            :                         }
     376                 :            :                     }
     377                 :          3 :                   p = p->right;
     378                 :            :                 }
     379         [ -  + ]:          1 :               if (p == NULL)
     380                 :         23 :                 return ASN1_VALUE_NOT_VALID;
     381                 :            :             }
     382                 :            :         }
     383                 :            :       else
     384                 :            :         {                       /* len != 0 */
     385                 :          1 :           value_temp = malloc (len);
     386         [ -  + ]:          1 :           if (value_temp == NULL)
     387                 :          0 :             return ASN1_MEM_ALLOC_ERROR;
     388                 :          1 :           memcpy (value_temp, value, len);
     389                 :            :         }
     390                 :            : 
     391         [ +  + ]:         24 :       if (value_temp[0] & 0x80)
     392                 :          3 :         negative = 1;
     393                 :            :       else
     394                 :         21 :         negative = 0;
     395                 :            : 
     396 [ +  + ][ -  + ]:         24 :       if (negative && (type_field (node->type) == ASN1_ETYPE_ENUMERATED))
     397                 :            :         {
     398                 :          0 :           free (value_temp);
     399                 :          0 :           return ASN1_VALUE_NOT_VALID;
     400                 :            :         }
     401                 :            : 
     402         [ +  + ]:         24 :       for (k = 0; k < len - 1; k++)
     403 [ +  + ][ -  + ]:          7 :         if (negative && (value_temp[k] != 0xFF))
     404                 :            :           break;
     405 [ +  - ][ +  - ]:          5 :         else if (!negative && value_temp[k])
     406                 :          5 :           break;
     407                 :            : 
     408 [ +  + ][ +  - ]:         24 :       if ((negative && !(value_temp[k] & 0x80)) ||
                 [ +  + ]
     409         [ -  + ]:         21 :           (!negative && (value_temp[k] & 0x80)))
     410                 :          0 :         k--;
     411                 :            : 
     412                 :         24 :       _asn1_set_value_lv (node, value_temp + k, len - k);
     413                 :            : 
     414         [ +  + ]:         24 :       if (node->type & CONST_DEFAULT)
     415                 :            :         {
     416                 :          2 :           p = node->down;
     417         [ -  + ]:          2 :           while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
     418                 :          0 :             p = p->right;
     419 [ +  - ][ -  + ]:          2 :           if ((isdigit (p->value[0])) || (p->value[0] == '-'))
     420                 :            :             {
     421                 :          0 :               default_temp = malloc (SIZEOF_UNSIGNED_LONG_INT);
     422         [ #  # ]:          0 :               if (default_temp == NULL)
     423                 :            :                 {
     424                 :          0 :                   free (value_temp);
     425                 :          0 :                   return ASN1_MEM_ALLOC_ERROR;
     426                 :            :                 }
     427                 :            : 
     428                 :          0 :               _asn1_convert_integer (p->value, default_temp,
     429                 :            :                                      SIZEOF_UNSIGNED_LONG_INT, &len2);
     430                 :            :             }
     431                 :            :           else
     432                 :            :             {                   /* is an identifier like v1 */
     433         [ -  + ]:          2 :               if (!(node->type & CONST_LIST))
     434                 :            :                 {
     435                 :          0 :                   free (value_temp);
     436                 :          0 :                   return ASN1_VALUE_NOT_VALID;
     437                 :            :                 }
     438                 :          2 :               p2 = node->down;
     439         [ +  - ]:          6 :               while (p2)
     440                 :            :                 {
     441         [ +  + ]:          6 :                   if (type_field (p2->type) == ASN1_ETYPE_CONSTANT)
     442                 :            :                     {
     443         [ +  + ]:          3 :                       if (!_asn1_strcmp (p2->name, p->value))
     444                 :            :                         {
     445                 :          2 :                           default_temp = malloc (SIZEOF_UNSIGNED_LONG_INT);
     446         [ -  + ]:          2 :                           if (default_temp == NULL)
     447                 :            :                             {
     448                 :          0 :                               free (value_temp);
     449                 :          0 :                               return ASN1_MEM_ALLOC_ERROR;
     450                 :            :                             }
     451                 :            : 
     452                 :          2 :                           _asn1_convert_integer (p2->value,
     453                 :            :                                                  default_temp,
     454                 :            :                                                  SIZEOF_UNSIGNED_LONG_INT,
     455                 :            :                                                  &len2);
     456                 :          2 :                           break;
     457                 :            :                         }
     458                 :            :                     }
     459                 :          4 :                   p2 = p2->right;
     460                 :            :                 }
     461         [ -  + ]:          2 :               if (p2 == NULL)
     462                 :            :                 {
     463                 :          0 :                   free (value_temp);
     464                 :          0 :                   return ASN1_VALUE_NOT_VALID;
     465                 :            :                 }
     466                 :            :             }
     467                 :            : 
     468                 :            : 
     469         [ +  - ]:          2 :           if ((len - k) == len2)
     470                 :            :             {
     471         [ +  + ]:          3 :               for (k2 = 0; k2 < len2; k2++)
     472         [ +  + ]:          2 :                 if (value_temp[k + k2] != default_temp[k2])
     473                 :            :                   {
     474                 :          1 :                     break;
     475                 :            :                   }
     476         [ +  + ]:          2 :               if (k2 == len2)
     477                 :          1 :                 _asn1_set_value (node, NULL, 0);
     478                 :            :             }
     479                 :          2 :           free (default_temp);
     480                 :            :         }
     481                 :         24 :       free (value_temp);
     482                 :         24 :       break;
     483                 :            :     case ASN1_ETYPE_OBJECT_ID:
     484         [ +  + ]:        148 :       for (i = 0; i < _asn1_strlen (value); i++)
     485 [ +  + ][ +  + ]:        132 :         if ((!isdigit (value[i])) && (value[i] != '.') && (value[i] != '+'))
                 [ +  - ]
     486                 :          1 :           return ASN1_VALUE_NOT_VALID;
     487         [ +  + ]:         16 :       if (node->type & CONST_DEFAULT)
     488                 :            :         {
     489                 :          4 :           p = node->down;
     490         [ -  + ]:          4 :           while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
     491                 :          0 :             p = p->right;
     492         [ +  + ]:          4 :           if (!_asn1_strcmp (value, p->value))
     493                 :            :             {
     494                 :          2 :               _asn1_set_value (node, NULL, 0);
     495                 :          2 :               break;
     496                 :            :             }
     497                 :            :         }
     498                 :         14 :       _asn1_set_value (node, value, _asn1_strlen (value) + 1);
     499                 :         14 :       break;
     500                 :            :     case ASN1_ETYPE_UTC_TIME:
     501                 :            :       {
     502                 :          1 :         len = _asn1_strlen (value);
     503         [ -  + ]:          1 :         if (len < 11)
     504                 :          0 :           return ASN1_VALUE_NOT_VALID;
     505         [ +  + ]:         11 :         for (k = 0; k < 10; k++)
     506         [ -  + ]:         10 :           if (!isdigit (value[k]))
     507                 :          0 :             return ASN1_VALUE_NOT_VALID;
     508   [ +  -  -  -  :          1 :         switch (len)
                      - ]
     509                 :            :           {
     510                 :            :           case 11:
     511         [ -  + ]:          1 :             if (value[10] != 'Z')
     512                 :          0 :               return ASN1_VALUE_NOT_VALID;
     513                 :          1 :             break;
     514                 :            :           case 13:
     515 [ #  # ][ #  # ]:          0 :             if ((!isdigit (value[10])) || (!isdigit (value[11])) ||
                 [ #  # ]
     516                 :          0 :                 (value[12] != 'Z'))
     517                 :          0 :               return ASN1_VALUE_NOT_VALID;
     518                 :          0 :             break;
     519                 :            :           case 15:
     520 [ #  # ][ #  # ]:          0 :             if ((value[10] != '+') && (value[10] != '-'))
     521                 :          0 :               return ASN1_VALUE_NOT_VALID;
     522         [ #  # ]:          0 :             for (k = 11; k < 15; k++)
     523         [ #  # ]:          0 :               if (!isdigit (value[k]))
     524                 :          0 :                 return ASN1_VALUE_NOT_VALID;
     525                 :          0 :             break;
     526                 :            :           case 17:
     527 [ #  # ][ #  # ]:          0 :             if ((!isdigit (value[10])) || (!isdigit (value[11])))
     528                 :          0 :               return ASN1_VALUE_NOT_VALID;
     529 [ #  # ][ #  # ]:          0 :             if ((value[12] != '+') && (value[12] != '-'))
     530                 :          0 :               return ASN1_VALUE_NOT_VALID;
     531         [ #  # ]:          0 :             for (k = 13; k < 17; k++)
     532         [ #  # ]:          0 :               if (!isdigit (value[k]))
     533                 :          0 :                 return ASN1_VALUE_NOT_VALID;
     534                 :          0 :             break;
     535                 :            :           default:
     536                 :          0 :             return ASN1_VALUE_NOT_FOUND;
     537                 :            :           }
     538                 :          1 :         _asn1_set_value (node, value, len);
     539                 :            :       }
     540                 :          1 :       break;
     541                 :            :     case ASN1_ETYPE_GENERALIZED_TIME:
     542                 :          1 :       len = _asn1_strlen (value);
     543                 :          1 :       _asn1_set_value (node, value, len);
     544                 :          1 :       break;
     545                 :            :     case ASN1_ETYPE_OCTET_STRING:
     546                 :            :     case ASN1_ETYPE_GENERALSTRING:
     547                 :            :     case ASN1_ETYPE_NUMERIC_STRING:
     548                 :            :     case ASN1_ETYPE_IA5_STRING:
     549                 :            :     case ASN1_ETYPE_TELETEX_STRING:
     550                 :            :     case ASN1_ETYPE_PRINTABLE_STRING:
     551                 :            :     case ASN1_ETYPE_UNIVERSAL_STRING:
     552                 :            :     case ASN1_ETYPE_BMP_STRING:
     553                 :            :     case ASN1_ETYPE_UTF8_STRING:
     554                 :            :     case ASN1_ETYPE_VISIBLE_STRING:
     555         [ +  + ]:          9 :       if (len == 0)
     556                 :          2 :         len = _asn1_strlen (value);
     557                 :          9 :       _asn1_set_value_lv (node, value, len);
     558                 :          9 :       break;
     559                 :            :     case ASN1_ETYPE_BIT_STRING:
     560         [ -  + ]:          1 :       if (len == 0)
     561                 :          0 :         len = _asn1_strlen (value);
     562                 :          1 :       asn1_length_der ((len >> 3) + 2, NULL, &len2);
     563                 :          1 :       temp = malloc ((len >> 3) + 2 + len2);
     564         [ -  + ]:          1 :       if (temp == NULL)
     565                 :          0 :         return ASN1_MEM_ALLOC_ERROR;
     566                 :            : 
     567                 :          1 :       asn1_bit_der (value, len, temp, &len2);
     568                 :          1 :       _asn1_set_value_m (node, temp, len2);
     569                 :          1 :       temp = NULL;
     570                 :          1 :       break;
     571                 :            :     case ASN1_ETYPE_CHOICE:
     572                 :          3 :       p = node->down;
     573         [ +  - ]:          4 :       while (p)
     574                 :            :         {
     575         [ +  + ]:          4 :           if (!_asn1_strcmp (p->name, value))
     576                 :            :             {
     577                 :          3 :               p2 = node->down;
     578         [ +  + ]:         15 :               while (p2)
     579                 :            :                 {
     580         [ +  + ]:         12 :                   if (p2 != p)
     581                 :            :                     {
     582                 :          5 :                       asn1_delete_structure (&p2);
     583                 :          5 :                       p2 = node->down;
     584                 :            :                     }
     585                 :            :                   else
     586                 :          7 :                     p2 = p2->right;
     587                 :            :                 }
     588                 :          3 :               break;
     589                 :            :             }
     590                 :          1 :           p = p->right;
     591                 :            :         }
     592         [ -  + ]:          3 :       if (!p)
     593                 :          0 :         return ASN1_ELEMENT_NOT_FOUND;
     594                 :          3 :       break;
     595                 :            :     case ASN1_ETYPE_ANY:
     596                 :          9 :       _asn1_set_value_lv (node, value, len);
     597                 :          9 :       break;
     598                 :            :     case ASN1_ETYPE_SEQUENCE_OF:
     599                 :            :     case ASN1_ETYPE_SET_OF:
     600         [ -  + ]:         14 :       if (_asn1_strcmp (value, "NEW"))
     601                 :          0 :         return ASN1_VALUE_NOT_VALID;
     602                 :         14 :       _asn1_append_sequence_set (node);
     603                 :         14 :       break;
     604                 :            :     default:
     605                 :          0 :       return ASN1_ELEMENT_NOT_FOUND;
     606                 :            :       break;
     607                 :            :     }
     608                 :            : 
     609                 :         85 :   return ASN1_SUCCESS;
     610                 :            : }
     611                 :            : 
     612                 :            : 
     613                 :            : #define PUT_VALUE( ptr, ptr_size, data, data_size) \
     614                 :            :         *len = data_size; \
     615                 :            :         if (ptr_size < data_size) { \
     616                 :            :                 return ASN1_MEM_ERROR; \
     617                 :            :         } else { \
     618                 :            :                 memcpy( ptr, data, data_size); \
     619                 :            :         }
     620                 :            : 
     621                 :            : #define PUT_STR_VALUE( ptr, ptr_size, data) \
     622                 :            :         *len = _asn1_strlen(data) + 1; \
     623                 :            :         if (ptr_size < *len) { \
     624                 :            :                 return ASN1_MEM_ERROR; \
     625                 :            :         } else { \
     626                 :            :                 /* this strcpy is checked */ \
     627                 :            :                 _asn1_strcpy(ptr, data); \
     628                 :            :         }
     629                 :            : 
     630                 :            : #define PUT_AS_STR_VALUE( ptr, ptr_size, data, data_size) \
     631                 :            :         *len = data_size + 1; \
     632                 :            :         if (ptr_size < *len) { \
     633                 :            :                 return ASN1_MEM_ERROR; \
     634                 :            :         } else { \
     635                 :            :                 /* this strcpy is checked */ \
     636                 :            :                 memcpy(ptr, data, data_size); \
     637                 :            :                 ptr[data_size] = 0; \
     638                 :            :         }
     639                 :            : 
     640                 :            : #define ADD_STR_VALUE( ptr, ptr_size, data) \
     641                 :            :         *len = (int) _asn1_strlen(data) + 1; \
     642                 :            :         if (ptr_size < (int) _asn1_strlen(ptr)+(*len)) { \
     643                 :            :                 return ASN1_MEM_ERROR; \
     644                 :            :         } else { \
     645                 :            :                 /* this strcat is checked */ \
     646                 :            :                 _asn1_strcat(ptr, data); \
     647                 :            :         }
     648                 :            : 
     649                 :            : /**
     650                 :            :  * asn1_read_value:
     651                 :            :  * @root: pointer to a structure.
     652                 :            :  * @name: the name of the element inside a structure that you want to read.
     653                 :            :  * @ivalue: vector that will contain the element's content, must be a
     654                 :            :  *   pointer to memory cells already allocated.
     655                 :            :  * @len: number of bytes of *value: value[0]..value[len-1]. Initialy
     656                 :            :  *   holds the sizeof value.
     657                 :            :  *
     658                 :            :  * Returns the value of one element inside a structure.
     659                 :            :  *
     660                 :            :  * If an element is OPTIONAL and the function "read_value" returns
     661                 :            :  * %ASN1_ELEMENT_NOT_FOUND, it means that this element wasn't present
     662                 :            :  * in the der encoding that created the structure.  The first element
     663                 :            :  * of a SEQUENCE_OF or SET_OF is named "?1". The second one "?2" and
     664                 :            :  * so on.
     665                 :            :  *
     666                 :            :  * INTEGER: VALUE will contain a two's complement form integer.
     667                 :            :  *
     668                 :            :  *            integer=-1  -> value[0]=0xFF , len=1.
     669                 :            :  *            integer=1   -> value[0]=0x01 , len=1.
     670                 :            :  *
     671                 :            :  * ENUMERATED: As INTEGER (but only with not negative numbers).
     672                 :            :  *
     673                 :            :  * BOOLEAN: VALUE will be the null terminated string "TRUE" or
     674                 :            :  *   "FALSE" and LEN=5 or LEN=6.
     675                 :            :  *
     676                 :            :  * OBJECT IDENTIFIER: VALUE will be a null terminated string with
     677                 :            :  *   each number separated by a dot (i.e. "1.2.3.543.1").
     678                 :            :  *
     679                 :            :  *                      LEN = strlen(VALUE)+1
     680                 :            :  *
     681                 :            :  * UTCTime: VALUE will be a null terminated string in one of these
     682                 :            :  *   formats: "YYMMDDhhmmss+hh'mm'" or "YYMMDDhhmmss-hh'mm'".
     683                 :            :  *   LEN=strlen(VALUE)+1.
     684                 :            :  *
     685                 :            :  * GeneralizedTime: VALUE will be a null terminated string in the
     686                 :            :  *   same format used to set the value.
     687                 :            :  *
     688                 :            :  * OCTET STRING: VALUE will contain the octet string and LEN will be
     689                 :            :  *   the number of octets.
     690                 :            :  *
     691                 :            :  * GeneralString: VALUE will contain the generalstring and LEN will
     692                 :            :  *   be the number of octets.
     693                 :            :  *
     694                 :            :  * BIT STRING: VALUE will contain the bit string organized by bytes
     695                 :            :  *   and LEN will be the number of bits.
     696                 :            :  *
     697                 :            :  * CHOICE: If NAME indicates a choice type, VALUE will specify the
     698                 :            :  *   alternative selected.
     699                 :            :  *
     700                 :            :  * ANY: If NAME indicates an any type, VALUE will indicate the DER
     701                 :            :  *   encoding of the structure actually used.
     702                 :            :  *
     703                 :            :  * Returns: %ASN1_SUCCESS if value is returned,
     704                 :            :  *   %ASN1_ELEMENT_NOT_FOUND if @name is not a valid element,
     705                 :            :  *   %ASN1_VALUE_NOT_FOUND if there isn't any value for the element
     706                 :            :  *   selected, and %ASN1_MEM_ERROR if The value vector isn't big enough
     707                 :            :  *   to store the result, and in this case @len will contain the number of
     708                 :            :  *   bytes needed.
     709                 :            :  **/
     710                 :            : int
     711                 :         48 : asn1_read_value (asn1_node root, const char *name, void *ivalue, int *len)
     712                 :            : {
     713                 :         48 :   return asn1_read_value_type (root, name, ivalue, len, NULL);
     714                 :            : }
     715                 :            : 
     716                 :            : /**
     717                 :            :  * asn1_read_value_type:
     718                 :            :  * @root: pointer to a structure.
     719                 :            :  * @name: the name of the element inside a structure that you want to read.
     720                 :            :  * @ivalue: vector that will contain the element's content, must be a
     721                 :            :  *   pointer to memory cells already allocated.
     722                 :            :  * @len: number of bytes of *value: value[0]..value[len-1]. Initialy
     723                 :            :  *   holds the sizeof value.
     724                 :            :  * @etype: The type of the value read (ASN1_ETYPE)
     725                 :            :  *
     726                 :            :  * Returns the value of one element inside a structure.
     727                 :            :  *
     728                 :            :  * If an element is OPTIONAL and the function "read_value" returns
     729                 :            :  * %ASN1_ELEMENT_NOT_FOUND, it means that this element wasn't present
     730                 :            :  * in the der encoding that created the structure.  The first element
     731                 :            :  * of a SEQUENCE_OF or SET_OF is named "?1". The second one "?2" and
     732                 :            :  * so on.
     733                 :            :  *
     734                 :            :  * INTEGER: VALUE will contain a two's complement form integer.
     735                 :            :  *
     736                 :            :  *            integer=-1  -> value[0]=0xFF , len=1.
     737                 :            :  *            integer=1   -> value[0]=0x01 , len=1.
     738                 :            :  *
     739                 :            :  * ENUMERATED: As INTEGER (but only with not negative numbers).
     740                 :            :  *
     741                 :            :  * BOOLEAN: VALUE will be the null terminated string "TRUE" or
     742                 :            :  *   "FALSE" and LEN=5 or LEN=6.
     743                 :            :  *
     744                 :            :  * OBJECT IDENTIFIER: VALUE will be a null terminated string with
     745                 :            :  *   each number separated by a dot (i.e. "1.2.3.543.1").
     746                 :            :  *
     747                 :            :  *                      LEN = strlen(VALUE)+1
     748                 :            :  *
     749                 :            :  * UTCTime: VALUE will be a null terminated string in one of these
     750                 :            :  *   formats: "YYMMDDhhmmss+hh'mm'" or "YYMMDDhhmmss-hh'mm'".
     751                 :            :  *   LEN=strlen(VALUE)+1.
     752                 :            :  *
     753                 :            :  * GeneralizedTime: VALUE will be a null terminated string in the
     754                 :            :  *   same format used to set the value.
     755                 :            :  *
     756                 :            :  * OCTET STRING: VALUE will contain the octet string and LEN will be
     757                 :            :  *   the number of octets.
     758                 :            :  *
     759                 :            :  * GeneralString: VALUE will contain the generalstring and LEN will
     760                 :            :  *   be the number of octets.
     761                 :            :  *
     762                 :            :  * BIT STRING: VALUE will contain the bit string organized by bytes
     763                 :            :  *   and LEN will be the number of bits.
     764                 :            :  *
     765                 :            :  * CHOICE: If NAME indicates a choice type, VALUE will specify the
     766                 :            :  *   alternative selected.
     767                 :            :  *
     768                 :            :  * ANY: If NAME indicates an any type, VALUE will indicate the DER
     769                 :            :  *   encoding of the structure actually used.
     770                 :            :  *
     771                 :            :  * Returns: %ASN1_SUCCESS if value is returned,
     772                 :            :  *   %ASN1_ELEMENT_NOT_FOUND if @name is not a valid element,
     773                 :            :  *   %ASN1_VALUE_NOT_FOUND if there isn't any value for the element
     774                 :            :  *   selected, and %ASN1_MEM_ERROR if The value vector isn't big enough
     775                 :            :  *   to store the result, and in this case @len will contain the number of
     776                 :            :  *   bytes needed.
     777                 :            :  **/
     778                 :            : int
     779                 :         48 : asn1_read_value_type (asn1_node root, const char *name, void *ivalue,
     780                 :            :                       int *len, unsigned int *etype)
     781                 :            : {
     782                 :            :   asn1_node node, p, p2;
     783                 :            :   int len2, len3;
     784                 :         48 :   int value_size = *len;
     785                 :         48 :   unsigned char *value = ivalue;
     786                 :            :   unsigned type;
     787                 :            : 
     788                 :         48 :   node = asn1_find_node (root, name);
     789         [ -  + ]:         48 :   if (node == NULL)
     790                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
     791                 :            : 
     792                 :         48 :   type = type_field (node->type);
     793                 :            : 
     794 [ +  - ][ +  - ]:         48 :   if ((type != ASN1_ETYPE_NULL) &&
     795         [ +  + ]:         48 :       (type != ASN1_ETYPE_CHOICE) &&
     796 [ +  + ][ -  + ]:         42 :       !(node->type & CONST_DEFAULT) && !(node->type & CONST_ASSIGN) &&
     797                 :         18 :       (node->value == NULL))
     798                 :          0 :     return ASN1_VALUE_NOT_FOUND;
     799                 :            : 
     800         [ -  + ]:         48 :   if (etype)
     801                 :          0 :     *etype = type;
     802   [ -  +  +  +  :         48 :   switch (type)
          +  +  +  -  +  
                      - ]
     803                 :            :     {
     804                 :            :     case ASN1_ETYPE_NULL:
     805         [ #  # ]:          0 :       PUT_STR_VALUE (value, value_size, "NULL");
     806                 :          0 :       break;
     807                 :            :     case ASN1_ETYPE_BOOLEAN:
     808 [ -  + ][ #  # ]:          1 :       if ((node->type & CONST_DEFAULT) && (node->value == NULL))
     809                 :            :         {
     810                 :          0 :           p = node->down;
     811         [ #  # ]:          0 :           while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
     812                 :          0 :             p = p->right;
     813         [ #  # ]:          0 :           if (p->type & CONST_TRUE)
     814                 :            :             {
     815         [ #  # ]:          0 :               PUT_STR_VALUE (value, value_size, "TRUE");
     816                 :            :             }
     817                 :            :           else
     818                 :            :             {
     819         [ #  # ]:          0 :               PUT_STR_VALUE (value, value_size, "FALSE");
     820                 :            :             }
     821                 :            :         }
     822         [ +  - ]:          1 :       else if (node->value[0] == 'T')
     823                 :            :         {
     824         [ +  - ]:          1 :           PUT_STR_VALUE (value, value_size, "TRUE");
     825                 :            :         }
     826                 :            :       else
     827                 :            :         {
     828         [ #  # ]:          0 :           PUT_STR_VALUE (value, value_size, "FALSE");
     829                 :            :         }
     830                 :          0 :       break;
     831                 :            :     case ASN1_ETYPE_INTEGER:
     832                 :            :     case ASN1_ETYPE_ENUMERATED:
     833 [ +  + ][ +  + ]:          4 :       if ((node->type & CONST_DEFAULT) && (node->value == NULL))
     834                 :            :         {
     835                 :          1 :           p = node->down;
     836         [ -  + ]:          1 :           while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
     837                 :          0 :             p = p->right;
     838 [ +  - ][ +  - ]:          2 :           if ((isdigit (p->value[0])) || (p->value[0] == '-')
     839         [ -  + ]:          1 :               || (p->value[0] == '+'))
     840                 :            :             {
     841         [ #  # ]:          0 :               if (_asn1_convert_integer
     842                 :          0 :                   (p->value, value, value_size, len) != ASN1_SUCCESS)
     843                 :          0 :                 return ASN1_MEM_ERROR;
     844                 :            :             }
     845                 :            :           else
     846                 :            :             {                   /* is an identifier like v1 */
     847                 :          1 :               p2 = node->down;
     848         [ +  - ]:          4 :               while (p2)
     849                 :            :                 {
     850         [ +  + ]:          4 :                   if (type_field (p2->type) == ASN1_ETYPE_CONSTANT)
     851                 :            :                     {
     852         [ +  + ]:          2 :                       if (!_asn1_strcmp (p2->name, p->value))
     853                 :            :                         {
     854         [ -  + ]:          1 :                           if (_asn1_convert_integer
     855                 :          1 :                               (p2->value, value, value_size,
     856                 :            :                                len) != ASN1_SUCCESS)
     857                 :          0 :                             return ASN1_MEM_ERROR;
     858                 :          1 :                           break;
     859                 :            :                         }
     860                 :            :                     }
     861                 :          3 :                   p2 = p2->right;
     862                 :            :                 }
     863                 :            :             }
     864                 :            :         }
     865                 :            :       else
     866                 :            :         {
     867                 :          3 :           len2 = -1;
     868         [ +  + ]:          3 :           if (asn1_get_octet_der
     869                 :          3 :               (node->value, node->value_len, &len2, value, value_size,
     870                 :            :                len) != ASN1_SUCCESS)
     871                 :          2 :             return ASN1_MEM_ERROR;
     872                 :            :         }
     873                 :          2 :       break;
     874                 :            :     case ASN1_ETYPE_OBJECT_ID:
     875         [ +  + ]:         32 :       if (node->type & CONST_ASSIGN)
     876                 :            :         {
     877                 :         24 :           value[0] = 0;
     878                 :         24 :           p = node->down;
     879         [ +  + ]:        110 :           while (p)
     880                 :            :             {
     881         [ +  - ]:         86 :               if (type_field (p->type) == ASN1_ETYPE_CONSTANT)
     882                 :            :                 {
     883         [ -  + ]:         86 :                   ADD_STR_VALUE (value, value_size, p->value);
     884         [ +  + ]:         86 :                   if (p->right)
     885                 :            :                     {
     886         [ -  + ]:         62 :                       ADD_STR_VALUE (value, value_size, ".");
     887                 :            :                     }
     888                 :            :                 }
     889                 :         86 :               p = p->right;
     890                 :            :             }
     891                 :         24 :           *len = _asn1_strlen (value) + 1;
     892                 :            :         }
     893 [ +  + ][ +  - ]:          8 :       else if ((node->type & CONST_DEFAULT) && (node->value == NULL))
     894                 :            :         {
     895                 :          4 :           p = node->down;
     896         [ -  + ]:          4 :           while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
     897                 :          0 :             p = p->right;
     898         [ +  + ]:          4 :           PUT_STR_VALUE (value, value_size, p->value);
     899                 :            :         }
     900                 :            :       else
     901                 :            :         {
     902         [ +  + ]:          4 :           PUT_STR_VALUE (value, value_size, node->value);
     903                 :            :         }
     904                 :         29 :       break;
     905                 :            :     case ASN1_ETYPE_GENERALIZED_TIME:
     906                 :            :     case ASN1_ETYPE_UTC_TIME:
     907         [ +  - ]:          2 :       PUT_AS_STR_VALUE (value, value_size, node->value, node->value_len);
     908                 :          0 :       break;
     909                 :            :     case ASN1_ETYPE_OCTET_STRING:
     910                 :            :     case ASN1_ETYPE_GENERALSTRING:
     911                 :            :     case ASN1_ETYPE_NUMERIC_STRING:
     912                 :            :     case ASN1_ETYPE_IA5_STRING:
     913                 :            :     case ASN1_ETYPE_TELETEX_STRING:
     914                 :            :     case ASN1_ETYPE_PRINTABLE_STRING:
     915                 :            :     case ASN1_ETYPE_UNIVERSAL_STRING:
     916                 :            :     case ASN1_ETYPE_BMP_STRING:
     917                 :            :     case ASN1_ETYPE_UTF8_STRING:
     918                 :            :     case ASN1_ETYPE_VISIBLE_STRING:
     919                 :          6 :       len2 = -1;
     920         [ +  + ]:          6 :       if (asn1_get_octet_der
     921                 :          6 :           (node->value, node->value_len, &len2, value, value_size,
     922                 :            :            len) != ASN1_SUCCESS)
     923                 :          3 :         return ASN1_MEM_ERROR;
     924                 :          3 :       break;
     925                 :            :     case ASN1_ETYPE_BIT_STRING:
     926                 :          2 :       len2 = -1;
     927         [ +  + ]:          2 :       if (asn1_get_bit_der
     928                 :          2 :           (node->value, node->value_len, &len2, value, value_size,
     929                 :            :            len) != ASN1_SUCCESS)
     930                 :          1 :         return ASN1_MEM_ERROR;
     931                 :          1 :       break;
     932                 :            :     case ASN1_ETYPE_CHOICE:
     933         [ #  # ]:          0 :       PUT_STR_VALUE (value, value_size, node->down->name);
     934                 :          0 :       break;
     935                 :            :     case ASN1_ETYPE_ANY:
     936                 :          1 :       len3 = -1;
     937                 :          1 :       len2 = asn1_get_length_der (node->value, node->value_len, &len3);
     938         [ -  + ]:          1 :       if (len2 < 0)
     939                 :          0 :         return ASN1_DER_ERROR;
     940         [ +  - ]:          1 :       PUT_VALUE (value, value_size, node->value + len3, len2);
     941                 :          0 :       break;
     942                 :            :     default:
     943                 :          0 :       return ASN1_ELEMENT_NOT_FOUND;
     944                 :            :       break;
     945                 :            :     }
     946                 :         48 :   return ASN1_SUCCESS;
     947                 :            : }
     948                 :            : 
     949                 :            : 
     950                 :            : /**
     951                 :            :  * asn1_read_tag:
     952                 :            :  * @root: pointer to a structure
     953                 :            :  * @name: the name of the element inside a structure.
     954                 :            :  * @tagValue:  variable that will contain the TAG value.
     955                 :            :  * @classValue: variable that will specify the TAG type.
     956                 :            :  *
     957                 :            :  * Returns the TAG and the CLASS of one element inside a structure.
     958                 :            :  * CLASS can have one of these constants: %ASN1_CLASS_APPLICATION,
     959                 :            :  * %ASN1_CLASS_UNIVERSAL, %ASN1_CLASS_PRIVATE or
     960                 :            :  * %ASN1_CLASS_CONTEXT_SPECIFIC.
     961                 :            :  *
     962                 :            :  * Returns: %ASN1_SUCCESS if successful, %ASN1_ELEMENT_NOT_FOUND if
     963                 :            :  *   @name is not a valid element.
     964                 :            :  **/
     965                 :            : int
     966                 :         11 : asn1_read_tag (asn1_node root, const char *name, int *tagValue,
     967                 :            :                int *classValue)
     968                 :            : {
     969                 :            :   asn1_node node, p, pTag;
     970                 :            : 
     971                 :         11 :   node = asn1_find_node (root, name);
     972         [ +  + ]:         11 :   if (node == NULL)
     973                 :          1 :     return ASN1_ELEMENT_NOT_FOUND;
     974                 :            : 
     975                 :         10 :   p = node->down;
     976                 :            : 
     977                 :            :   /* pTag will points to the IMPLICIT TAG */
     978                 :         10 :   pTag = NULL;
     979         [ +  + ]:         10 :   if (node->type & CONST_TAG)
     980                 :            :     {
     981         [ +  + ]:         16 :       while (p)
     982                 :            :         {
     983         [ +  - ]:          8 :           if (type_field (p->type) == ASN1_ETYPE_TAG)
     984                 :            :             {
     985 [ +  + ][ +  - ]:          8 :               if ((p->type & CONST_IMPLICIT) && (pTag == NULL))
     986                 :          4 :                 pTag = p;
     987         [ +  - ]:          4 :               else if (p->type & CONST_EXPLICIT)
     988                 :          4 :                 pTag = NULL;
     989                 :            :             }
     990                 :          8 :           p = p->right;
     991                 :            :         }
     992                 :            :     }
     993                 :            : 
     994         [ +  + ]:         10 :   if (pTag)
     995                 :            :     {
     996                 :          4 :       *tagValue = _asn1_strtoul (pTag->value, NULL, 10);
     997                 :            : 
     998         [ -  + ]:          4 :       if (pTag->type & CONST_APPLICATION)
     999                 :          0 :         *classValue = ASN1_CLASS_APPLICATION;
    1000         [ -  + ]:          4 :       else if (pTag->type & CONST_UNIVERSAL)
    1001                 :          0 :         *classValue = ASN1_CLASS_UNIVERSAL;
    1002         [ -  + ]:          4 :       else if (pTag->type & CONST_PRIVATE)
    1003                 :          0 :         *classValue = ASN1_CLASS_PRIVATE;
    1004                 :            :       else
    1005                 :          4 :         *classValue = ASN1_CLASS_CONTEXT_SPECIFIC;
    1006                 :            :     }
    1007                 :            :   else
    1008                 :            :     {
    1009                 :          6 :       unsigned type = type_field (node->type);
    1010                 :          6 :       *classValue = ASN1_CLASS_UNIVERSAL;
    1011                 :            : 
    1012      [ +  -  - ]:          6 :       switch (type)
    1013                 :            :         {
    1014                 :            :         CASE_HANDLED_ETYPES:
    1015                 :          6 :           *tagValue = _asn1_tags[type].tag;
    1016                 :          6 :           break;
    1017                 :            :         case ASN1_ETYPE_TAG:
    1018                 :            :         case ASN1_ETYPE_CHOICE:
    1019                 :            :         case ASN1_ETYPE_ANY:
    1020                 :          0 :           *tagValue = -1;
    1021                 :          0 :           break;
    1022                 :            :         default:
    1023                 :          0 :           break;
    1024                 :            :         }
    1025                 :            :     }
    1026                 :            : 
    1027                 :         11 :   return ASN1_SUCCESS;
    1028                 :            : }
    1029                 :            : 
    1030                 :            : /**
    1031                 :            :  * asn1_read_node_value:
    1032                 :            :  * @node: pointer to a node.
    1033                 :            :  * @data: a point to a asn1_data_node_st
    1034                 :            :  *
    1035                 :            :  * Returns the value a data node inside a asn1_node structure.
    1036                 :            :  * The data returned should be handled as constant values.
    1037                 :            :  *
    1038                 :            :  * Returns: %ASN1_SUCCESS if the node exists.
    1039                 :            :  **/
    1040                 :            : int
    1041                 :          0 : asn1_read_node_value (asn1_node node, asn1_data_node_st * data)
    1042                 :            : {
    1043                 :          0 :   data->name = node->name;
    1044                 :          0 :   data->value = node->value;
    1045                 :          0 :   data->value_len = node->value_len;
    1046                 :          0 :   data->type = type_field (node->type);
    1047                 :            : 
    1048                 :          0 :   return ASN1_SUCCESS;
    1049                 :            : }

Generated by: LCOV version 1.9