lib/minitasn1/parser_aux.c

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