lib/element.c

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