LCOV - code coverage report
Current view: top level - lib - parser_aux.c (source / functions) Hit Total Coverage
Test: GNU Libtasn1 Lines: 370 438 84.5 %
Date: 2013-03-24 Functions: 19 20 95.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 245 322 76.1 %

           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                 :            : #include <int.h>
      23                 :            : #include <hash-pjw-bare.h>
      24                 :            : #include "parser_aux.h"
      25                 :            : #include "gstr.h"
      26                 :            : #include "structure.h"
      27                 :            : #include "element.h"
      28                 :            : 
      29                 :            : char _asn1_identifierMissing[ASN1_MAX_NAME_SIZE + 1];   /* identifier name not found */
      30                 :            : 
      31                 :            : /***********************************************/
      32                 :            : /* Type: list_type                             */
      33                 :            : /* Description: type used in the list during   */
      34                 :            : /* the structure creation.                     */
      35                 :            : /***********************************************/
      36                 :            : typedef struct list_struct
      37                 :            : {
      38                 :            :   asn1_node node;
      39                 :            :   struct list_struct *next;
      40                 :            : } list_type;
      41                 :            : 
      42                 :            : 
      43                 :            : /* Pointer to the first element of the list */
      44                 :            : list_type *firstElement = NULL;
      45                 :            : 
      46                 :            : /******************************************************/
      47                 :            : /* Function : _asn1_add_static_node                   */
      48                 :            : /* Description: creates a new NODE_ASN element and    */
      49                 :            : /* puts it in the list pointed by firstElement.       */
      50                 :            : /* Parameters:                                        */
      51                 :            : /*   type: type of the new element (see ASN1_ETYPE_   */
      52                 :            : /*         and CONST_ constants).                     */
      53                 :            : /* Return: pointer to the new element.                */
      54                 :            : /******************************************************/
      55                 :            : asn1_node
      56                 :       2867 : _asn1_add_static_node (unsigned int type)
      57                 :            : {
      58                 :            :   list_type *listElement;
      59                 :            :   asn1_node punt;
      60                 :            : 
      61                 :       2867 :   punt = calloc (1, sizeof (struct asn1_node_st));
      62         [ -  + ]:       2867 :   if (punt == NULL)
      63                 :          0 :     return NULL;
      64                 :            : 
      65                 :       2867 :   listElement = malloc (sizeof (list_type));
      66         [ -  + ]:       2867 :   if (listElement == NULL)
      67                 :            :     {
      68                 :          0 :       free (punt);
      69                 :          0 :       return NULL;
      70                 :            :     }
      71                 :            : 
      72                 :       2867 :   listElement->node = punt;
      73                 :       2867 :   listElement->next = firstElement;
      74                 :       2867 :   firstElement = listElement;
      75                 :            : 
      76                 :       2867 :   punt->type = type;
      77                 :            : 
      78                 :       2867 :   return punt;
      79                 :            : }
      80                 :            : 
      81                 :            : /**
      82                 :            :  * asn1_find_node:
      83                 :            :  * @pointer: NODE_ASN element pointer.
      84                 :            :  * @name: null terminated string with the element's name to find.
      85                 :            :  *
      86                 :            :  * Searches for an element called @name starting from @pointer.  The
      87                 :            :  * name is composed by differents identifiers separated by dots.  When
      88                 :            :  * *@pointer has a name, the first identifier must be the name of
      89                 :            :  * *@pointer, otherwise it must be the name of one child of *@pointer.
      90                 :            :  *
      91                 :            :  * Returns: the search result, or %NULL if not found.
      92                 :            :  **/
      93                 :            : asn1_node
      94                 :        974 : asn1_find_node (asn1_node pointer, const char *name)
      95                 :            : {
      96                 :            :   asn1_node p;
      97                 :            :   char *n_end, n[ASN1_MAX_NAME_SIZE + 1];
      98                 :            :   const char *n_start;
      99                 :            :   unsigned int nsize;
     100                 :            :   unsigned int nhash;
     101                 :            : 
     102         [ -  + ]:        974 :   if (pointer == NULL)
     103                 :          0 :     return NULL;
     104                 :            : 
     105         [ -  + ]:        974 :   if (name == NULL)
     106                 :          0 :     return NULL;
     107                 :            : 
     108                 :        974 :   p = pointer;
     109                 :        974 :   n_start = name;
     110                 :            : 
     111         [ +  + ]:        974 :   if (p->name[0] != 0)
     112                 :            :     {                           /* has *pointer got a name ? */
     113                 :        780 :       n_end = strchr (n_start, '.');    /* search the first dot */
     114         [ +  - ]:        780 :       if (n_end)
     115                 :            :         {
     116                 :        780 :           nsize = n_end - n_start;
     117                 :        780 :           memcpy (n, n_start, nsize);
     118                 :        780 :           n[nsize] = 0;
     119                 :        780 :           n_start = n_end;
     120                 :        780 :           n_start++;
     121                 :            : 
     122                 :        780 :           nhash = hash_pjw_bare (n, nsize);
     123                 :            :         }
     124                 :            :       else
     125                 :            :         {
     126                 :          0 :           nsize = _asn1_str_cpy (n, sizeof (n), n_start);
     127                 :          0 :           nhash = hash_pjw_bare (n, nsize);
     128                 :            : 
     129                 :          0 :           n_start = NULL;
     130                 :            :         }
     131                 :            : 
     132         [ +  - ]:        780 :       while (p)
     133                 :            :         {
     134 [ +  - ][ +  - ]:        780 :           if ((p->name) && nhash == p->name_hash && (!strcmp (p->name, n)))
                 [ -  + ]
     135                 :            :             break;
     136                 :            :           else
     137                 :          0 :             p = p->right;
     138                 :            :         }                       /* while */
     139                 :            : 
     140         [ -  + ]:        780 :       if (p == NULL)
     141                 :          0 :         return NULL;
     142                 :            :     }
     143                 :            :   else
     144                 :            :     {                           /* *pointer doesn't have a name */
     145         [ +  + ]:        194 :       if (n_start[0] == 0)
     146                 :         49 :         return p;
     147                 :            :     }
     148                 :            : 
     149         [ +  + ]:       1913 :   while (n_start)
     150                 :            :     {                           /* Has the end of NAME been reached? */
     151                 :        996 :       n_end = strchr (n_start, '.');    /* search the next dot */
     152         [ +  + ]:        996 :       if (n_end)
     153                 :            :         {
     154                 :         71 :           nsize = n_end - n_start;
     155                 :         71 :           memcpy (n, n_start, nsize);
     156                 :         71 :           n[nsize] = 0;
     157                 :         71 :           n_start = n_end;
     158                 :         71 :           n_start++;
     159                 :            : 
     160                 :         71 :           nhash = hash_pjw_bare (n, nsize);
     161                 :            :         }
     162                 :            :       else
     163                 :            :         {
     164                 :        925 :           nsize = _asn1_str_cpy (n, sizeof (n), n_start);
     165                 :        925 :           nhash = hash_pjw_bare (n, nsize);
     166                 :        925 :           n_start = NULL;
     167                 :            :         }
     168                 :            : 
     169         [ -  + ]:        996 :       if (p->down == NULL)
     170                 :          0 :         return NULL;
     171                 :            : 
     172                 :        996 :       p = p->down;
     173                 :            : 
     174                 :            :       /* The identifier "?LAST" indicates the last element
     175                 :            :          in the right chain. */
     176         [ +  + ]:        996 :       if (!strcmp (n, "?LAST"))
     177                 :            :         {
     178         [ -  + ]:         21 :           if (p == NULL)
     179                 :          0 :             return NULL;
     180         [ +  + ]:        115 :           while (p->right)
     181                 :         94 :             p = p->right;
     182                 :            :         }
     183                 :            :       else
     184                 :            :         {                       /* no "?LAST" */
     185         [ +  + ]:      78979 :           while (p)
     186                 :            :             {
     187 [ +  + ][ +  + ]:      78971 :               if (p->name_hash == nhash && !strcmp (p->name, n))
     188                 :            :                 break;
     189                 :            :               else
     190                 :      78004 :                 p = p->right;
     191                 :            :             }
     192         [ +  + ]:        975 :           if (p == NULL)
     193                 :          8 :             return NULL;
     194                 :            :         }
     195                 :            :     }                           /* while */
     196                 :            : 
     197                 :        974 :   return p;
     198                 :            : }
     199                 :            : 
     200                 :            : 
     201                 :            : /******************************************************************/
     202                 :            : /* Function : _asn1_set_value                                     */
     203                 :            : /* Description: sets the field VALUE in a NODE_ASN element. The   */
     204                 :            : /*              previous value (if exist) will be lost            */
     205                 :            : /* Parameters:                                                    */
     206                 :            : /*   node: element pointer.                                       */
     207                 :            : /*   value: pointer to the value that you want to set.            */
     208                 :            : /*   len: character number of value.                              */
     209                 :            : /* Return: pointer to the NODE_ASN element.                       */
     210                 :            : /******************************************************************/
     211                 :            : asn1_node
     212                 :       3459 : _asn1_set_value (asn1_node node, const void *value, unsigned int len)
     213                 :            : {
     214         [ -  + ]:       3459 :   if (node == NULL)
     215                 :          0 :     return node;
     216         [ +  + ]:       3459 :   if (node->value)
     217                 :            :     {
     218         [ +  + ]:        274 :       if (node->value != node->small_value)
     219                 :          4 :         free (node->value);
     220                 :        274 :       node->value = NULL;
     221                 :        274 :       node->value_len = 0;
     222                 :            :     }
     223                 :            : 
     224         [ +  + ]:       3459 :   if (!len)
     225                 :        139 :     return node;
     226                 :            : 
     227         [ +  + ]:       3320 :   if (len < sizeof (node->small_value))
     228                 :            :     {
     229                 :       3105 :       node->value = node->small_value;
     230                 :            :     }
     231                 :            :   else
     232                 :            :     {
     233                 :        215 :       node->value = malloc (len);
     234         [ -  + ]:        215 :       if (node->value == NULL)
     235                 :          0 :         return NULL;
     236                 :            :     }
     237                 :       3320 :   node->value_len = len;
     238                 :            : 
     239                 :       3320 :   memcpy (node->value, value, len);
     240                 :       3459 :   return node;
     241                 :            : }
     242                 :            : 
     243                 :            : /******************************************************************/
     244                 :            : /* Function : _asn1_set_value_lv                                  */
     245                 :            : /* Description: sets the field VALUE in a NODE_ASN element. The   */
     246                 :            : /*              previous value (if exist) will be lost. The value */
     247                 :            : /*              given is stored as an length-value format (LV     */
     248                 :            : /* Parameters:                                                    */
     249                 :            : /*   node: element pointer.                                       */
     250                 :            : /*   value: pointer to the value that you want to set.            */
     251                 :            : /*   len: character number of value.                              */
     252                 :            : /* Return: pointer to the NODE_ASN element.                       */
     253                 :            : /******************************************************************/
     254                 :            : asn1_node
     255                 :         62 : _asn1_set_value_lv (asn1_node node, const void *value, unsigned int len)
     256                 :            : {
     257                 :            :   int len2;
     258                 :            :   void *temp;
     259                 :            : 
     260         [ -  + ]:         62 :   if (node == NULL)
     261                 :          0 :     return node;
     262                 :            : 
     263                 :         62 :   asn1_length_der (len, NULL, &len2);
     264                 :         62 :   temp = malloc (len + len2);
     265         [ -  + ]:         62 :   if (temp == NULL)
     266                 :          0 :     return NULL;
     267                 :            : 
     268                 :         62 :   asn1_octet_der (value, len, temp, &len2);
     269                 :         62 :   return _asn1_set_value_m (node, temp, len2);
     270                 :            : }
     271                 :            : 
     272                 :            : /* the same as _asn1_set_value except that it sets an already malloc'ed
     273                 :            :  * value.
     274                 :            :  */
     275                 :            : asn1_node
     276                 :         63 : _asn1_set_value_m (asn1_node node, void *value, unsigned int len)
     277                 :            : {
     278         [ -  + ]:         63 :   if (node == NULL)
     279                 :          0 :     return node;
     280                 :            : 
     281         [ +  + ]:         63 :   if (node->value)
     282                 :            :     {
     283         [ +  - ]:          7 :       if (node->value != node->small_value)
     284                 :          7 :         free (node->value);
     285                 :          7 :       node->value = NULL;
     286                 :          7 :       node->value_len = 0;
     287                 :            :     }
     288                 :            : 
     289         [ -  + ]:         63 :   if (!len)
     290                 :          0 :     return node;
     291                 :            : 
     292                 :         63 :   node->value = value;
     293                 :         63 :   node->value_len = len;
     294                 :            : 
     295                 :         63 :   return node;
     296                 :            : }
     297                 :            : 
     298                 :            : /******************************************************************/
     299                 :            : /* Function : _asn1_append_value                                  */
     300                 :            : /* Description: appends to the field VALUE in a NODE_ASN element. */
     301                 :            : /*                                                                */
     302                 :            : /* Parameters:                                                    */
     303                 :            : /*   node: element pointer.                                       */
     304                 :            : /*   value: pointer to the value that you want to be appended.    */
     305                 :            : /*   len: character number of value.                              */
     306                 :            : /* Return: pointer to the NODE_ASN element.                       */
     307                 :            : /******************************************************************/
     308                 :            : asn1_node
     309                 :          0 : _asn1_append_value (asn1_node node, const void *value, unsigned int len)
     310                 :            : {
     311         [ #  # ]:          0 :   if (node == NULL)
     312                 :          0 :     return node;
     313 [ #  # ][ #  # ]:          0 :   if (node->value != NULL && node->value != node->small_value)
     314                 :            :     {
     315                 :            :       /* value is allocated */
     316                 :          0 :       int prev_len = node->value_len;
     317                 :          0 :       node->value_len += len;
     318                 :          0 :       node->value = realloc (node->value, node->value_len);
     319         [ #  # ]:          0 :       if (node->value == NULL)
     320                 :            :         {
     321                 :          0 :           node->value_len = 0;
     322                 :          0 :           return NULL;
     323                 :            :         }
     324                 :          0 :       memcpy (&node->value[prev_len], value, len);
     325                 :            : 
     326                 :          0 :       return node;
     327                 :            :     }
     328         [ #  # ]:          0 :   else if (node->value == node->small_value)
     329                 :            :     {
     330                 :            :       /* value is in node */
     331                 :          0 :       int prev_len = node->value_len;
     332                 :          0 :       node->value_len += len;
     333                 :          0 :       node->value = malloc (node->value_len);
     334         [ #  # ]:          0 :       if (node->value == NULL)
     335                 :            :         {
     336                 :          0 :           node->value_len = 0;
     337                 :          0 :           return NULL;
     338                 :            :         }
     339                 :          0 :       memcpy (node->value, node->small_value, prev_len);
     340                 :          0 :       memcpy (&node->value[prev_len], value, len);
     341                 :            : 
     342                 :          0 :       return node;
     343                 :            :     }
     344                 :            :   else                          /* node->value == NULL */
     345                 :          0 :     return _asn1_set_value (node, value, len);
     346                 :            : }
     347                 :            : 
     348                 :            : /******************************************************************/
     349                 :            : /* Function : _asn1_set_name                                      */
     350                 :            : /* Description: sets the field NAME in a NODE_ASN element. The    */
     351                 :            : /*              previous value (if exist) will be lost            */
     352                 :            : /* Parameters:                                                    */
     353                 :            : /*   node: element pointer.                                       */
     354                 :            : /*   name: a null terminated string with the name that you want   */
     355                 :            : /*         to set.                                                */
     356                 :            : /* Return: pointer to the NODE_ASN element.                       */
     357                 :            : /******************************************************************/
     358                 :            : asn1_node
     359                 :       2927 : _asn1_set_name (asn1_node node, const char *name)
     360                 :            : {
     361                 :            :   unsigned int nsize;
     362                 :            : 
     363         [ -  + ]:       2927 :   if (node == NULL)
     364                 :          0 :     return node;
     365                 :            : 
     366         [ +  + ]:       2927 :   if (name == NULL)
     367                 :            :     {
     368                 :          9 :       node->name[0] = 0;
     369                 :          9 :       node->name_hash = hash_pjw_bare (node->name, 0);
     370                 :          9 :       return node;
     371                 :            :     }
     372                 :            : 
     373                 :       2918 :   nsize = _asn1_str_cpy (node->name, sizeof (node->name), name);
     374                 :       2918 :   node->name_hash = hash_pjw_bare (node->name, nsize);
     375                 :            : 
     376                 :       2927 :   return node;
     377                 :            : }
     378                 :            : 
     379                 :            : /******************************************************************/
     380                 :            : /* Function : _asn1_cpy_name                                      */
     381                 :            : /* Description: copies the field NAME in a NODE_ASN element.      */
     382                 :            : /* Parameters:                                                    */
     383                 :            : /*   dst: a dest element pointer.                                 */
     384                 :            : /*   src: a source element pointer.                               */
     385                 :            : /* Return: pointer to the NODE_ASN element.                       */
     386                 :            : /******************************************************************/
     387                 :            : asn1_node
     388                 :        653 : _asn1_cpy_name (asn1_node dst, asn1_node src)
     389                 :            : {
     390         [ -  + ]:        653 :   if (dst == NULL)
     391                 :          0 :     return dst;
     392                 :            : 
     393         [ -  + ]:        653 :   if (src == NULL)
     394                 :            :     {
     395                 :          0 :       dst->name[0] = 0;
     396                 :          0 :       dst->name_hash = hash_pjw_bare (dst->name, 0);
     397                 :          0 :       return dst;
     398                 :            :     }
     399                 :            : 
     400                 :        653 :   _asn1_str_cpy (dst->name, sizeof (dst->name), src->name);
     401                 :        653 :   dst->name_hash = src->name_hash;
     402                 :            : 
     403                 :        653 :   return dst;
     404                 :            : }
     405                 :            : 
     406                 :            : /******************************************************************/
     407                 :            : /* Function : _asn1_set_right                                     */
     408                 :            : /* Description: sets the field RIGHT in a NODE_ASN element.       */
     409                 :            : /* Parameters:                                                    */
     410                 :            : /*   node: element pointer.                                       */
     411                 :            : /*   right: pointer to a NODE_ASN element that you want be pointed*/
     412                 :            : /*          by NODE.                                              */
     413                 :            : /* Return: pointer to *NODE.                                      */
     414                 :            : /******************************************************************/
     415                 :            : asn1_node
     416                 :       3965 : _asn1_set_right (asn1_node node, asn1_node right)
     417                 :            : {
     418         [ -  + ]:       3965 :   if (node == NULL)
     419                 :          0 :     return node;
     420                 :       3965 :   node->right = right;
     421         [ +  + ]:       3965 :   if (right)
     422                 :       3765 :     right->left = node;
     423                 :       3965 :   return node;
     424                 :            : }
     425                 :            : 
     426                 :            : 
     427                 :            : /******************************************************************/
     428                 :            : /* Function : _asn1_get_last_right                                */
     429                 :            : /* Description: return the last element along the right chain.    */
     430                 :            : /* Parameters:                                                    */
     431                 :            : /*   node: starting element pointer.                              */
     432                 :            : /* Return: pointer to the last element along the right chain.     */
     433                 :            : /******************************************************************/
     434                 :            : asn1_node
     435                 :       1734 : _asn1_get_last_right (asn1_node node)
     436                 :            : {
     437                 :            :   asn1_node p;
     438                 :            : 
     439         [ -  + ]:       1734 :   if (node == NULL)
     440                 :          0 :     return NULL;
     441                 :       1734 :   p = node;
     442         [ +  + ]:     103760 :   while (p->right)
     443                 :     102026 :     p = p->right;
     444                 :       1734 :   return p;
     445                 :            : }
     446                 :            : 
     447                 :            : /******************************************************************/
     448                 :            : /* Function : _asn1_remove_node                                   */
     449                 :            : /* Description: gets free the memory allocated for an NODE_ASN    */
     450                 :            : /*              element (not the elements pointed by it).         */
     451                 :            : /* Parameters:                                                    */
     452                 :            : /*   node: NODE_ASN element pointer.                              */
     453                 :            : /******************************************************************/
     454                 :            : void
     455                 :       4425 : _asn1_remove_node (asn1_node node)
     456                 :            : {
     457         [ -  + ]:       4425 :   if (node == NULL)
     458                 :       4425 :     return;
     459                 :            : 
     460 [ +  + ][ +  + ]:       4425 :   if (node->value != NULL && node->value != node->small_value)
     461                 :        262 :     free (node->value);
     462                 :       4425 :   free (node);
     463                 :            : }
     464                 :            : 
     465                 :            : /******************************************************************/
     466                 :            : /* Function : _asn1_find_up                                       */
     467                 :            : /* Description: return the father of the NODE_ASN element.        */
     468                 :            : /* Parameters:                                                    */
     469                 :            : /*   node: NODE_ASN element pointer.                              */
     470                 :            : /* Return: Null if not found.                                     */
     471                 :            : /******************************************************************/
     472                 :            : asn1_node
     473                 :      10255 : _asn1_find_up (asn1_node node)
     474                 :            : {
     475                 :            :   asn1_node p;
     476                 :            : 
     477         [ -  + ]:      10255 :   if (node == NULL)
     478                 :          0 :     return NULL;
     479                 :            : 
     480                 :      10255 :   p = node;
     481                 :            : 
     482 [ +  + ][ +  + ]:      23662 :   while ((p->left != NULL) && (p->left->right == p))
     483                 :      13407 :     p = p->left;
     484                 :            : 
     485                 :      10255 :   return p->left;
     486                 :            : }
     487                 :            : 
     488                 :            : /******************************************************************/
     489                 :            : /* Function : _asn1_delete_list                                   */
     490                 :            : /* Description: deletes the list elements (not the elements       */
     491                 :            : /*  pointed by them).                                             */
     492                 :            : /******************************************************************/
     493                 :            : void
     494                 :         20 : _asn1_delete_list (void)
     495                 :            : {
     496                 :            :   list_type *listElement;
     497                 :            : 
     498         [ +  + ]:       2630 :   while (firstElement)
     499                 :            :     {
     500                 :       2610 :       listElement = firstElement;
     501                 :       2610 :       firstElement = firstElement->next;
     502                 :       2610 :       free (listElement);
     503                 :            :     }
     504                 :         20 : }
     505                 :            : 
     506                 :            : /******************************************************************/
     507                 :            : /* Function : _asn1_delete_list_and nodes                         */
     508                 :            : /* Description: deletes the list elements and the elements        */
     509                 :            : /*  pointed by them.                                              */
     510                 :            : /******************************************************************/
     511                 :            : void
     512                 :         11 : _asn1_delete_list_and_nodes (void)
     513                 :            : {
     514                 :            :   list_type *listElement;
     515                 :            : 
     516         [ +  + ]:        268 :   while (firstElement)
     517                 :            :     {
     518                 :        257 :       listElement = firstElement;
     519                 :        257 :       firstElement = firstElement->next;
     520                 :        257 :       _asn1_remove_node (listElement->node);
     521                 :        257 :       free (listElement);
     522                 :            :     }
     523                 :         11 : }
     524                 :            : 
     525                 :            : 
     526                 :            : char *
     527                 :        281 : _asn1_ltostr (long v, char *str)
     528                 :            : {
     529                 :            :   long d, r;
     530                 :            :   char temp[20];
     531                 :            :   int count, k, start;
     532                 :            : 
     533         [ -  + ]:        281 :   if (v < 0)
     534                 :            :     {
     535                 :          0 :       str[0] = '-';
     536                 :          0 :       start = 1;
     537                 :          0 :       v = -v;
     538                 :            :     }
     539                 :            :   else
     540                 :        281 :     start = 0;
     541                 :            : 
     542                 :        281 :   count = 0;
     543                 :            :   do
     544                 :            :     {
     545                 :        419 :       d = v / 10;
     546                 :        419 :       r = v - d * 10;
     547                 :        419 :       temp[start + count] = '0' + (char) r;
     548                 :        419 :       count++;
     549                 :        419 :       v = d;
     550                 :            :     }
     551         [ +  + ]:        419 :   while (v);
     552                 :            : 
     553         [ +  + ]:        700 :   for (k = 0; k < count; k++)
     554                 :        419 :     str[k + start] = temp[start + count - k - 1];
     555                 :        281 :   str[count + start] = 0;
     556                 :        281 :   return str;
     557                 :            : }
     558                 :            : 
     559                 :            : 
     560                 :            : /******************************************************************/
     561                 :            : /* Function : _asn1_change_integer_value                          */
     562                 :            : /* Description: converts into DER coding the value assign to an   */
     563                 :            : /*   INTEGER constant.                                            */
     564                 :            : /* Parameters:                                                    */
     565                 :            : /*   node: root of an ASN1element.                                */
     566                 :            : /* Return:                                                        */
     567                 :            : /*   ASN1_ELEMENT_NOT_FOUND if NODE is NULL,                       */
     568                 :            : /*   otherwise ASN1_SUCCESS                                             */
     569                 :            : /******************************************************************/
     570                 :            : int
     571                 :         20 : _asn1_change_integer_value (asn1_node node)
     572                 :            : {
     573                 :            :   asn1_node p;
     574                 :            :   unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
     575                 :            :   unsigned char val2[SIZEOF_UNSIGNED_LONG_INT + 1];
     576                 :            :   int len;
     577                 :            : 
     578         [ -  + ]:         20 :   if (node == NULL)
     579                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
     580                 :            : 
     581                 :         20 :   p = node;
     582         [ +  + ]:       2569 :   while (p)
     583                 :            :     {
     584         [ +  + ]:       2549 :       if ((type_field (p->type) == ASN1_ETYPE_INTEGER)
     585         [ +  + ]:        222 :           && (p->type & CONST_ASSIGN))
     586                 :            :         {
     587         [ +  - ]:        119 :           if (p->value)
     588                 :            :             {
     589                 :        119 :               _asn1_convert_integer (p->value, val, sizeof (val), &len);
     590                 :        119 :               asn1_octet_der (val, len, val2, &len);
     591                 :        119 :               _asn1_set_value (p, val2, len);
     592                 :            :             }
     593                 :            :         }
     594                 :            : 
     595         [ +  + ]:       2549 :       if (p->down)
     596                 :            :         {
     597                 :        839 :           p = p->down;
     598                 :            :         }
     599                 :            :       else
     600                 :            :         {
     601         [ -  + ]:       1710 :           if (p == node)
     602                 :          0 :             p = NULL;
     603         [ +  + ]:       1710 :           else if (p->right)
     604                 :        995 :             p = p->right;
     605                 :            :           else
     606                 :            :             {
     607                 :            :               while (1)
     608                 :            :                 {
     609                 :        839 :                   p = _asn1_find_up (p);
     610         [ +  + ]:        839 :                   if (p == node)
     611                 :            :                     {
     612                 :         20 :                       p = NULL;
     613                 :         20 :                       break;
     614                 :            :                     }
     615         [ +  + ]:        819 :                   if (p->right)
     616                 :            :                     {
     617                 :        695 :                       p = p->right;
     618                 :        695 :                       break;
     619                 :            :                     }
     620                 :        124 :                 }
     621                 :            :             }
     622                 :            :         }
     623                 :            :     }
     624                 :            : 
     625                 :         20 :   return ASN1_SUCCESS;
     626                 :            : }
     627                 :            : 
     628                 :            : 
     629                 :            : /******************************************************************/
     630                 :            : /* Function : _asn1_expand_object_id                              */
     631                 :            : /* Description: expand the IDs of an OBJECT IDENTIFIER constant.  */
     632                 :            : /* Parameters:                                                    */
     633                 :            : /*   node: root of an ASN1 element.                               */
     634                 :            : /* Return:                                                        */
     635                 :            : /*   ASN1_ELEMENT_NOT_FOUND if NODE is NULL,                       */
     636                 :            : /*   otherwise ASN1_SUCCESS                                             */
     637                 :            : /******************************************************************/
     638                 :            : int
     639                 :         20 : _asn1_expand_object_id (asn1_node node)
     640                 :            : {
     641                 :            :   asn1_node p, p2, p3, p4, p5;
     642                 :            :   char name_root[ASN1_MAX_NAME_SIZE], name2[2 * ASN1_MAX_NAME_SIZE + 1];
     643                 :            :   int move, tlen;
     644                 :            : 
     645         [ -  + ]:         20 :   if (node == NULL)
     646                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
     647                 :            : 
     648                 :         20 :   _asn1_str_cpy (name_root, sizeof (name_root), node->name);
     649                 :            : 
     650                 :         20 :   p = node;
     651                 :         20 :   move = DOWN;
     652                 :            : 
     653 [ +  + ][ +  + ]:       4183 :   while (!((p == node) && (move == UP)))
     654                 :            :     {
     655         [ +  + ]:       4163 :       if (move != UP)
     656                 :            :         {
     657         [ +  + ]:       3344 :           if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID)
     658         [ +  + ]:        442 :               && (p->type & CONST_ASSIGN))
     659                 :            :             {
     660                 :        374 :               p2 = p->down;
     661 [ +  - ][ +  - ]:        374 :               if (p2 && (type_field (p2->type) == ASN1_ETYPE_CONSTANT))
     662                 :            :                 {
     663 [ +  - ][ +  + ]:        374 :                   if (p2->value && !isdigit (p2->value[0]))
     664                 :            :                     {
     665                 :        175 :                       _asn1_str_cpy (name2, sizeof (name2), name_root);
     666                 :        175 :                       _asn1_str_cat (name2, sizeof (name2), ".");
     667                 :        175 :                       _asn1_str_cat (name2, sizeof (name2),
     668                 :        175 :                                      (char *) p2->value);
     669                 :        175 :                       p3 = asn1_find_node (node, name2);
     670         [ +  - ]:        175 :                       if (!p3
     671         [ +  - ]:        175 :                           || (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID)
     672         [ -  + ]:        175 :                           || !(p3->type & CONST_ASSIGN))
     673                 :          0 :                         return ASN1_ELEMENT_NOT_FOUND;
     674                 :        175 :                       _asn1_set_down (p, p2->right);
     675                 :        175 :                       _asn1_remove_node (p2);
     676                 :        175 :                       p2 = p;
     677                 :        175 :                       p4 = p3->down;
     678         [ +  + ]:        970 :                       while (p4)
     679                 :            :                         {
     680         [ +  - ]:        795 :                           if (type_field (p4->type) == ASN1_ETYPE_CONSTANT)
     681                 :            :                             {
     682                 :        795 :                               p5 =
     683                 :            :                                 _asn1_add_single_node (ASN1_ETYPE_CONSTANT);
     684                 :        795 :                               _asn1_set_name (p5, p4->name);
     685                 :        795 :                               tlen = _asn1_strlen (p4->value);
     686         [ +  - ]:        795 :                               if (tlen > 0)
     687                 :        795 :                                 _asn1_set_value (p5, p4->value, tlen + 1);
     688         [ +  + ]:        795 :                               if (p2 == p)
     689                 :            :                                 {
     690                 :        175 :                                   _asn1_set_right (p5, p->down);
     691                 :        175 :                                   _asn1_set_down (p, p5);
     692                 :            :                                 }
     693                 :            :                               else
     694                 :            :                                 {
     695                 :        620 :                                   _asn1_set_right (p5, p2->right);
     696                 :        620 :                                   _asn1_set_right (p2, p5);
     697                 :            :                                 }
     698                 :        795 :                               p2 = p5;
     699                 :            :                             }
     700                 :        795 :                           p4 = p4->right;
     701                 :            :                         }
     702                 :        175 :                       move = DOWN;
     703                 :        175 :                       continue;
     704                 :            :                     }
     705                 :            :                 }
     706                 :            :             }
     707                 :       3169 :           move = DOWN;
     708                 :            :         }
     709                 :            :       else
     710                 :        819 :         move = RIGHT;
     711                 :            : 
     712         [ +  + ]:       3988 :       if (move == DOWN)
     713                 :            :         {
     714         [ +  + ]:       3169 :           if (p->down)
     715                 :        839 :             p = p->down;
     716                 :            :           else
     717                 :       2330 :             move = RIGHT;
     718                 :            :         }
     719                 :            : 
     720         [ -  + ]:       3988 :       if (p == node)
     721                 :            :         {
     722                 :          0 :           move = UP;
     723                 :          0 :           continue;
     724                 :            :         }
     725                 :            : 
     726         [ +  + ]:       3988 :       if (move == RIGHT)
     727                 :            :         {
     728         [ +  + ]:       3149 :           if (p->right)
     729                 :       2310 :             p = p->right;
     730                 :            :           else
     731                 :        839 :             move = UP;
     732                 :            :         }
     733         [ +  + ]:       3988 :       if (move == UP)
     734                 :        839 :         p = _asn1_find_up (p);
     735                 :            :     }
     736                 :            : 
     737                 :            : 
     738                 :            :   /*******************************/
     739                 :            :   /*       expand DEFAULT        */
     740                 :            :   /*******************************/
     741                 :         20 :   p = node;
     742                 :         20 :   move = DOWN;
     743                 :            : 
     744 [ +  + ][ +  + ]:       4008 :   while (!((p == node) && (move == UP)))
     745                 :            :     {
     746         [ +  + ]:       3988 :       if (move != UP)
     747                 :            :         {
     748 [ +  + ][ +  + ]:       3169 :           if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) &&
     749                 :        267 :               (p->type & CONST_DEFAULT))
     750                 :            :             {
     751                 :         19 :               p2 = p->down;
     752 [ +  - ][ +  - ]:         19 :               if (p2 && (type_field (p2->type) == ASN1_ETYPE_DEFAULT))
     753                 :            :                 {
     754                 :         19 :                   _asn1_str_cpy (name2, sizeof (name2), name_root);
     755                 :         19 :                   _asn1_str_cat (name2, sizeof (name2), ".");
     756                 :         19 :                   _asn1_str_cat (name2, sizeof (name2), (char *) p2->value);
     757                 :         19 :                   p3 = asn1_find_node (node, name2);
     758 [ +  - ][ +  - ]:         19 :                   if (!p3 || (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID)
     759         [ -  + ]:         19 :                       || !(p3->type & CONST_ASSIGN))
     760                 :          0 :                     return ASN1_ELEMENT_NOT_FOUND;
     761                 :         19 :                   p4 = p3->down;
     762                 :         19 :                   name2[0] = 0;
     763         [ +  + ]:         95 :                   while (p4)
     764                 :            :                     {
     765         [ +  - ]:         76 :                       if (type_field (p4->type) == ASN1_ETYPE_CONSTANT)
     766                 :            :                         {
     767         [ +  + ]:         76 :                           if (name2[0])
     768                 :         57 :                             _asn1_str_cat (name2, sizeof (name2), ".");
     769                 :         76 :                           _asn1_str_cat (name2, sizeof (name2),
     770                 :         76 :                                          (char *) p4->value);
     771                 :            :                         }
     772                 :         76 :                       p4 = p4->right;
     773                 :            :                     }
     774                 :         19 :                   tlen = strlen (name2);
     775         [ +  - ]:         19 :                   if (tlen > 0)
     776                 :         19 :                     _asn1_set_value (p2, name2, tlen + 1);
     777                 :            :                 }
     778                 :            :             }
     779                 :       3169 :           move = DOWN;
     780                 :            :         }
     781                 :            :       else
     782                 :        819 :         move = RIGHT;
     783                 :            : 
     784         [ +  + ]:       3988 :       if (move == DOWN)
     785                 :            :         {
     786         [ +  + ]:       3169 :           if (p->down)
     787                 :        839 :             p = p->down;
     788                 :            :           else
     789                 :       2330 :             move = RIGHT;
     790                 :            :         }
     791                 :            : 
     792         [ -  + ]:       3988 :       if (p == node)
     793                 :            :         {
     794                 :          0 :           move = UP;
     795                 :          0 :           continue;
     796                 :            :         }
     797                 :            : 
     798         [ +  + ]:       3988 :       if (move == RIGHT)
     799                 :            :         {
     800         [ +  + ]:       3149 :           if (p->right)
     801                 :       2310 :             p = p->right;
     802                 :            :           else
     803                 :        839 :             move = UP;
     804                 :            :         }
     805         [ +  + ]:       3988 :       if (move == UP)
     806                 :        839 :         p = _asn1_find_up (p);
     807                 :            :     }
     808                 :            : 
     809                 :         20 :   return ASN1_SUCCESS;
     810                 :            : }
     811                 :            : 
     812                 :            : 
     813                 :            : /******************************************************************/
     814                 :            : /* Function : _asn1_type_set_config                               */
     815                 :            : /* Description: sets the CONST_SET and CONST_NOT_USED properties  */
     816                 :            : /*   in the fields of the SET elements.                           */
     817                 :            : /* Parameters:                                                    */
     818                 :            : /*   node: root of an ASN1 element.                               */
     819                 :            : /* Return:                                                        */
     820                 :            : /*   ASN1_ELEMENT_NOT_FOUND if NODE is NULL,                       */
     821                 :            : /*   otherwise ASN1_SUCCESS                                             */
     822                 :            : /******************************************************************/
     823                 :            : int
     824                 :         25 : _asn1_type_set_config (asn1_node node)
     825                 :            : {
     826                 :            :   asn1_node p, p2;
     827                 :            :   int move;
     828                 :            : 
     829         [ -  + ]:         25 :   if (node == NULL)
     830                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
     831                 :            : 
     832                 :         25 :   p = node;
     833                 :         25 :   move = DOWN;
     834                 :            : 
     835 [ +  + ][ +  + ]:       3545 :   while (!((p == node) && (move == UP)))
     836                 :            :     {
     837         [ +  + ]:       3520 :       if (move != UP)
     838                 :            :         {
     839         [ +  + ]:       2675 :           if (type_field (p->type) == ASN1_ETYPE_SET)
     840                 :            :             {
     841                 :          8 :               p2 = p->down;
     842         [ +  + ]:         32 :               while (p2)
     843                 :            :                 {
     844         [ +  - ]:         24 :                   if (type_field (p2->type) != ASN1_ETYPE_TAG)
     845                 :         24 :                     p2->type |= CONST_SET | CONST_NOT_USED;
     846                 :         24 :                   p2 = p2->right;
     847                 :            :                 }
     848                 :            :             }
     849                 :       2675 :           move = DOWN;
     850                 :            :         }
     851                 :            :       else
     852                 :        845 :         move = RIGHT;
     853                 :            : 
     854         [ +  + ]:       3520 :       if (move == DOWN)
     855                 :            :         {
     856         [ +  + ]:       2675 :           if (p->down)
     857                 :        870 :             p = p->down;
     858                 :            :           else
     859                 :       1805 :             move = RIGHT;
     860                 :            :         }
     861                 :            : 
     862         [ -  + ]:       3520 :       if (p == node)
     863                 :            :         {
     864                 :          0 :           move = UP;
     865                 :          0 :           continue;
     866                 :            :         }
     867                 :            : 
     868         [ +  + ]:       3520 :       if (move == RIGHT)
     869                 :            :         {
     870         [ +  + ]:       2650 :           if (p->right)
     871                 :       1780 :             p = p->right;
     872                 :            :           else
     873                 :        870 :             move = UP;
     874                 :            :         }
     875         [ +  + ]:       3520 :       if (move == UP)
     876                 :        870 :         p = _asn1_find_up (p);
     877                 :            :     }
     878                 :            : 
     879                 :         25 :   return ASN1_SUCCESS;
     880                 :            : }
     881                 :            : 
     882                 :            : 
     883                 :            : /******************************************************************/
     884                 :            : /* Function : _asn1_check_identifier                              */
     885                 :            : /* Description: checks the definitions of all the identifiers     */
     886                 :            : /*   and the first element of an OBJECT_ID (e.g. {pkix 0 4}).     */
     887                 :            : /*   The _asn1_identifierMissing global variable is filled if     */
     888                 :            : /*   necessary.                                                   */
     889                 :            : /* Parameters:                                                    */
     890                 :            : /*   node: root of an ASN1 element.                               */
     891                 :            : /* Return:                                                        */
     892                 :            : /*   ASN1_ELEMENT_NOT_FOUND      if NODE is NULL,                 */
     893                 :            : /*   ASN1_IDENTIFIER_NOT_FOUND   if an identifier is not defined, */
     894                 :            : /*   otherwise ASN1_SUCCESS                                       */
     895                 :            : /******************************************************************/
     896                 :            : int
     897                 :         25 : _asn1_check_identifier (asn1_node node)
     898                 :            : {
     899                 :            :   asn1_node p, p2;
     900                 :            :   char name2[ASN1_MAX_NAME_SIZE * 2 + 2];
     901                 :            : 
     902         [ -  + ]:         25 :   if (node == NULL)
     903                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
     904                 :            : 
     905                 :         25 :   p = node;
     906         [ +  + ]:       2642 :   while (p)
     907                 :            :     {
     908         [ +  + ]:       2622 :       if (type_field (p->type) == ASN1_ETYPE_IDENTIFIER)
     909                 :            :         {
     910                 :        299 :           _asn1_str_cpy (name2, sizeof (name2), node->name);
     911                 :        299 :           _asn1_str_cat (name2, sizeof (name2), ".");
     912                 :        299 :           _asn1_str_cat (name2, sizeof (name2), (char *) p->value);
     913                 :        299 :           p2 = asn1_find_node (node, name2);
     914         [ +  + ]:        299 :           if (p2 == NULL)
     915                 :            :             {
     916         [ +  - ]:          2 :               if (p->value)
     917                 :          2 :                 _asn1_strcpy (_asn1_identifierMissing, p->value);
     918                 :            :               else
     919                 :          0 :                 _asn1_strcpy (_asn1_identifierMissing, "(null)");
     920                 :          2 :               return ASN1_IDENTIFIER_NOT_FOUND;
     921                 :            :             }
     922                 :            :         }
     923 [ +  + ][ +  + ]:       2323 :       else if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) &&
     924                 :        275 :                (p->type & CONST_DEFAULT))
     925                 :            :         {
     926                 :         21 :           p2 = p->down;
     927 [ +  - ][ +  - ]:         40 :           if (p2 && (type_field (p2->type) == ASN1_ETYPE_DEFAULT))
     928                 :            :             {
     929                 :         21 :               _asn1_str_cpy (name2, sizeof (name2), node->name);
     930                 :         21 :               _asn1_str_cat (name2, sizeof (name2), ".");
     931                 :         21 :               _asn1_str_cat (name2, sizeof (name2), (char *) p2->value);
     932                 :         21 :               _asn1_strcpy (_asn1_identifierMissing, p2->value);
     933                 :         21 :               p2 = asn1_find_node (node, name2);
     934 [ +  + ][ +  - ]:         21 :               if (!p2 || (type_field (p2->type) != ASN1_ETYPE_OBJECT_ID) ||
                 [ -  + ]
     935                 :         19 :                   !(p2->type & CONST_ASSIGN))
     936                 :          2 :                 return ASN1_IDENTIFIER_NOT_FOUND;
     937                 :            :               else
     938                 :         19 :                 _asn1_identifierMissing[0] = 0;
     939                 :            :             }
     940                 :            :         }
     941 [ +  + ][ +  + ]:       2302 :       else if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) &&
     942                 :        254 :                (p->type & CONST_ASSIGN))
     943                 :            :         {
     944                 :        200 :           p2 = p->down;
     945 [ +  - ][ +  - ]:        200 :           if (p2 && (type_field (p2->type) == ASN1_ETYPE_CONSTANT))
     946                 :            :             {
     947 [ +  - ][ +  + ]:        200 :               if (p2->value && !isdigit (p2->value[0]))
     948                 :            :                 {
     949                 :        158 :                   _asn1_str_cpy (name2, sizeof (name2), node->name);
     950                 :        158 :                   _asn1_str_cat (name2, sizeof (name2), ".");
     951                 :        158 :                   _asn1_str_cat (name2, sizeof (name2), (char *) p2->value);
     952                 :        158 :                   _asn1_strcpy (_asn1_identifierMissing, p2->value);
     953                 :        158 :                   p2 = asn1_find_node (node, name2);
     954 [ +  + ][ +  - ]:        158 :                   if (!p2 || (type_field (p2->type) != ASN1_ETYPE_OBJECT_ID)
     955         [ -  + ]:        157 :                       || !(p2->type & CONST_ASSIGN))
     956                 :          1 :                     return ASN1_IDENTIFIER_NOT_FOUND;
     957                 :            :                   else
     958                 :        157 :                     _asn1_identifierMissing[0] = 0;
     959                 :            :                 }
     960                 :            :             }
     961                 :            :         }
     962                 :            : 
     963         [ +  + ]:       2617 :       if (p->down)
     964                 :            :         {
     965                 :        854 :           p = p->down;
     966                 :            :         }
     967         [ +  + ]:       1763 :       else if (p->right)
     968                 :       1041 :         p = p->right;
     969                 :            :       else
     970                 :            :         {
     971                 :            :           while (1)
     972                 :            :             {
     973                 :        846 :               p = _asn1_find_up (p);
     974         [ +  + ]:        846 :               if (p == node)
     975                 :            :                 {
     976                 :         20 :                   p = NULL;
     977                 :         20 :                   break;
     978                 :            :                 }
     979         [ +  + ]:        826 :               if (p->right)
     980                 :            :                 {
     981                 :        702 :                   p = p->right;
     982                 :        702 :                   break;
     983                 :            :                 }
     984                 :        124 :             }
     985                 :            :         }
     986                 :            :     }
     987                 :            : 
     988                 :         25 :   return ASN1_SUCCESS;
     989                 :            : }
     990                 :            : 
     991                 :            : 
     992                 :            : /******************************************************************/
     993                 :            : /* Function : _asn1_set_default_tag                               */
     994                 :            : /* Description: sets the default IMPLICIT or EXPLICIT property in */
     995                 :            : /*   the tagged elements that don't have this declaration.        */
     996                 :            : /* Parameters:                                                    */
     997                 :            : /*   node: pointer to a DEFINITIONS element.                      */
     998                 :            : /* Return:                                                        */
     999                 :            : /*   ASN1_ELEMENT_NOT_FOUND if NODE is NULL or not a pointer to   */
    1000                 :            : /*     a DEFINITIONS element,                                     */
    1001                 :            : /*   otherwise ASN1_SUCCESS                                       */
    1002                 :            : /******************************************************************/
    1003                 :            : int
    1004                 :         25 : _asn1_set_default_tag (asn1_node node)
    1005                 :            : {
    1006                 :            :   asn1_node p;
    1007                 :            : 
    1008 [ +  - ][ -  + ]:         25 :   if ((node == NULL) || (type_field (node->type) != ASN1_ETYPE_DEFINITIONS))
    1009                 :          0 :     return ASN1_ELEMENT_NOT_FOUND;
    1010                 :            : 
    1011                 :         25 :   p = node;
    1012         [ +  + ]:       2700 :   while (p)
    1013                 :            :     {
    1014 [ +  + ][ +  + ]:       2675 :       if ((type_field (p->type) == ASN1_ETYPE_TAG) &&
    1015         [ +  + ]:        123 :           !(p->type & CONST_EXPLICIT) && !(p->type & CONST_IMPLICIT))
    1016                 :            :         {
    1017         [ -  + ]:         86 :           if (node->type & CONST_EXPLICIT)
    1018                 :          0 :             p->type |= CONST_EXPLICIT;
    1019                 :            :           else
    1020                 :         86 :             p->type |= CONST_IMPLICIT;
    1021                 :            :         }
    1022                 :            : 
    1023         [ +  + ]:       2675 :       if (p->down)
    1024                 :            :         {
    1025                 :        870 :           p = p->down;
    1026                 :            :         }
    1027         [ +  + ]:       1805 :       else if (p->right)
    1028                 :       1064 :         p = p->right;
    1029                 :            :       else
    1030                 :            :         {
    1031                 :            :           while (1)
    1032                 :            :             {
    1033                 :        870 :               p = _asn1_find_up (p);
    1034         [ +  + ]:        870 :               if (p == node)
    1035                 :            :                 {
    1036                 :         25 :                   p = NULL;
    1037                 :         25 :                   break;
    1038                 :            :                 }
    1039         [ +  + ]:        845 :               if (p->right)
    1040                 :            :                 {
    1041                 :        716 :                   p = p->right;
    1042                 :        716 :                   break;
    1043                 :            :                 }
    1044                 :        129 :             }
    1045                 :            :         }
    1046                 :            :     }
    1047                 :            : 
    1048                 :         25 :   return ASN1_SUCCESS;
    1049                 :            : }

Generated by: LCOV version 1.9