2 * Copyright (C) 2004, 2006, 2008 Free Software Foundation
3 * Copyright (C) 2000, 2001, 2002, 2003 Fabio Fiorina
5 * This file is part of LIBTASN1.
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.
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.
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
23 /*****************************************************/
25 /* Description: Functions with the read and write */
27 /*****************************************************/
32 #include "parser_aux.h"
34 #include "structure.h"
37 _asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size)
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);
55 p = _asn1_find_up (p);
59 _asn1_str_cpy (name, name_size, "ROOT");
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. */
70 /* value: null terminated string to convert. */
71 /* value_out: convertion result (memory must be already */
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 /******************************************************************/
78 _asn1_convert_integer (const char *value, unsigned char *value_out,
79 int value_out_size, int *len)
82 unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
86 valtmp = strtol (value, NULL, 10);
88 for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
90 val[SIZEOF_UNSIGNED_LONG_INT - k - 1] = (valtmp >> (8 * k)) & 0xFF;
98 for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT - 1; k++)
100 if (negative && (val[k] != 0xFF))
102 else if (!negative && val[k])
106 if ((negative && !(val[k] & 0x80)) || (!negative && (val[k] & 0x80)))
109 *len = SIZEOF_UNSIGNED_LONG_INT - k;
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;
115 for (k2 = k; k2 < SIZEOF_UNSIGNED_LONG_INT; k2++)
116 value_out[k2 - k] = val[k2];
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");
132 _asn1_append_sequence_set (ASN1_TYPE node)
138 if (!node || !(node->down))
139 return ASN1_GENERIC_ERROR;
142 while ((type_field (p->type) == TYPE_TAG)
143 || (type_field (p->type) == TYPE_SIZE))
145 p2 = _asn1_copy_structure3 (p);
148 _asn1_set_right (p, p2);
151 _asn1_str_cpy (temp, sizeof (temp), "?1");
154 n = strtol (p->name + 1, NULL, 0);
157 _asn1_ltostr (n, temp + 1);
159 _asn1_set_name (p2, temp);
160 /* p2->type |= CONST_OPTION; */
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
176 * Set the value of one element inside a structure.
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":
181 * result=asn1_write_value(cert, "tbsCertificate.issuerUniqueID",
184 * Description for each type:
186 * INTEGER: VALUE must contain a two's complement form integer.
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.
194 * ENUMERATED: As INTEGER (but only with not negative numbers).
196 * BOOLEAN: VALUE must be the null terminated string "TRUE" or
197 * "FALSE" and LEN != 0.
199 * value="TRUE" , len=1 -> boolean=TRUE.
200 * value="FALSE" , len=1 -> boolean=FALSE.
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.
205 * value="1 2 840 10040 4 3" , len=1 -> OID=dsa-with-sha.
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.
212 * value="9801011200Z" , len=1 -> time=Jannuary 1st, 1998
213 * at 12h 00m Greenwich Mean Time
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".
222 * value="2001010112001.12-0700" , len=1 -> time=Jannuary
223 * 1st, 2001 at 12h 00m 01.12s Pacific Daylight Time
225 * OCTET STRING: VALUE contains the octet string and LEN is the
228 * value="$\backslash$x01$\backslash$x02$\backslash$x03" ,
229 * len=3 -> three bytes octet string
231 * GeneralString: VALUE contains the generalstring and LEN is the
234 * value="$\backslash$x01$\backslash$x02$\backslash$x03" ,
235 * len=3 -> three bytes generalstring
237 * BIT STRING: VALUE contains the bit string organized by bytes and
238 * LEN is the number of bits.
240 * value="$\backslash$xCF" , len=6 -> bit string="110011" (six
243 * CHOICE: if NAME indicates a choice type, VALUE must specify one of
244 * the alternatives with a null terminated string. LEN != 0. Using
247 * result=asn1_write_value(cert,
248 * "certificate1.tbsCertificate.subject", "rdnSequence",
251 * ANY: VALUE indicates the der encoding of a structure. LEN != 0.
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.
260 * result=asn1_write_value(cert,
261 * "certificate1.tbsCertificate.subject.rdnSequence", "NEW", 1);
263 * SET OF: the same as SEQUENCE OF. Using "pkix.asn":
265 * result=asn1_write_value(cert,
266 * "tbsCertificate.subject.rdnSequence.?LAST", "NEW", 1);
270 * ASN1_SUCCESS: Set value OK.
272 * ASN1_ELEMENT_NOT_FOUND: NAME is not a valid element.
274 * ASN1_VALUE_NOT_VALID: VALUE has a wrong format.
278 asn1_write_value (ASN1_TYPE node_root, const char *name,
279 const void *ivalue, int len)
281 ASN1_TYPE 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;
286 node = asn1_find_node (node_root, name);
288 return ASN1_ELEMENT_NOT_FOUND;
290 if ((node->type & CONST_OPTION) && (value == NULL) && (len == 0))
292 asn1_delete_structure (&node);
296 if ((type_field (node->type) == TYPE_SEQUENCE_OF) && (value == NULL)
300 while ((type_field (p->type) == TYPE_TAG)
301 || (type_field (p->type) == TYPE_SIZE))
305 asn1_delete_structure (&p->right);
310 switch (type_field (node->type))
313 if (!strcmp (value, "TRUE"))
315 if (node->type & CONST_DEFAULT)
318 while (type_field (p->type) != TYPE_DEFAULT)
320 if (p->type & CONST_TRUE)
321 _asn1_set_value (node, NULL, 0);
323 _asn1_set_value (node, "T", 1);
326 _asn1_set_value (node, "T", 1);
328 else if (!strcmp (value, "FALSE"))
330 if (node->type & CONST_DEFAULT)
333 while (type_field (p->type) != TYPE_DEFAULT)
335 if (p->type & CONST_FALSE)
336 _asn1_set_value (node, NULL, 0);
338 _asn1_set_value (node, "F", 1);
341 _asn1_set_value (node, "F", 1);
344 return ASN1_VALUE_NOT_VALID;
347 case TYPE_ENUMERATED:
350 if ((isdigit (value[0])) || (value[0] == '-'))
353 (unsigned char *) _asn1_malloc (SIZEOF_UNSIGNED_LONG_INT);
354 if (value_temp == NULL)
355 return ASN1_MEM_ALLOC_ERROR;
357 _asn1_convert_integer (value, value_temp,
358 SIZEOF_UNSIGNED_LONG_INT, &len);
361 { /* is an identifier like v1 */
362 if (!(node->type & CONST_LIST))
363 return ASN1_VALUE_NOT_VALID;
367 if (type_field (p->type) == TYPE_CONSTANT)
369 if ((p->name) && (!strcmp (p->name, value)))
373 _asn1_malloc (SIZEOF_UNSIGNED_LONG_INT);
374 if (value_temp == NULL)
375 return ASN1_MEM_ALLOC_ERROR;
377 _asn1_convert_integer (p->value,
379 SIZEOF_UNSIGNED_LONG_INT,
387 return ASN1_VALUE_NOT_VALID;
392 value_temp = (unsigned char *) _asn1_malloc (len);
393 if (value_temp == NULL)
394 return ASN1_MEM_ALLOC_ERROR;
395 memcpy (value_temp, value, len);
399 if (value_temp[0] & 0x80)
404 if (negative && (type_field (node->type) == TYPE_ENUMERATED))
406 _asn1_free (value_temp);
407 return ASN1_VALUE_NOT_VALID;
410 for (k = 0; k < len - 1; k++)
411 if (negative && (value_temp[k] != 0xFF))
413 else if (!negative && value_temp[k])
416 if ((negative && !(value_temp[k] & 0x80)) ||
417 (!negative && (value_temp[k] & 0x80)))
420 _asn1_set_value_octet (node, value_temp+k, len-k);
422 if (node->type & CONST_DEFAULT)
425 while (type_field (p->type) != TYPE_DEFAULT)
427 if ((isdigit (p->value[0])) || (p->value[0] == '-'))
430 (unsigned char *) _asn1_malloc (SIZEOF_UNSIGNED_LONG_INT);
431 if (default_temp == NULL)
433 _asn1_free (value_temp);
434 return ASN1_MEM_ALLOC_ERROR;
437 _asn1_convert_integer (p->value, default_temp,
438 SIZEOF_UNSIGNED_LONG_INT, &len2);
441 { /* is an identifier like v1 */
442 if (!(node->type & CONST_LIST))
444 _asn1_free (value_temp);
445 return ASN1_VALUE_NOT_VALID;
450 if (type_field (p2->type) == TYPE_CONSTANT)
452 if ((p2->name) && (!strcmp (p2->name, p->value)))
456 _asn1_malloc (SIZEOF_UNSIGNED_LONG_INT);
457 if (default_temp == NULL)
459 _asn1_free (value_temp);
460 return ASN1_MEM_ALLOC_ERROR;
463 _asn1_convert_integer (p2->value,
465 SIZEOF_UNSIGNED_LONG_INT,
474 _asn1_free (value_temp);
475 return ASN1_VALUE_NOT_VALID;
480 if ((len - k) == len2)
482 for (k2 = 0; k2 < len2; k2++)
483 if (value_temp[k + k2] != default_temp[k2])
488 _asn1_set_value (node, NULL, 0);
490 _asn1_free (default_temp);
492 _asn1_free (value_temp);
495 for (k = 0; k < strlen (value); k++)
496 if ((!isdigit (value[k])) && (value[k] != '.') && (value[k] != '+'))
497 return ASN1_VALUE_NOT_VALID;
498 if (node->type & CONST_DEFAULT)
501 while (type_field (p->type) != TYPE_DEFAULT)
503 if (!strcmp (value, p->value))
505 _asn1_set_value (node, NULL, 0);
509 _asn1_set_value (node, value, strlen (value) + 1);
512 if (node->type & CONST_UTC)
514 if (strlen (value) < 11)
515 return ASN1_VALUE_NOT_VALID;
516 for (k = 0; k < 10; k++)
517 if (!isdigit (value[k]))
518 return ASN1_VALUE_NOT_VALID;
519 switch (strlen (value))
522 if (value[10] != 'Z')
523 return ASN1_VALUE_NOT_VALID;
526 if ((!isdigit (value[10])) || (!isdigit (value[11])) ||
528 return ASN1_VALUE_NOT_VALID;
531 if ((value[10] != '+') && (value[10] != '-'))
532 return ASN1_VALUE_NOT_VALID;
533 for (k = 11; k < 15; k++)
534 if (!isdigit (value[k]))
535 return ASN1_VALUE_NOT_VALID;
538 if ((!isdigit (value[10])) || (!isdigit (value[11])))
539 return ASN1_VALUE_NOT_VALID;
540 if ((value[12] != '+') && (value[12] != '-'))
541 return ASN1_VALUE_NOT_VALID;
542 for (k = 13; k < 17; k++)
543 if (!isdigit (value[k]))
544 return ASN1_VALUE_NOT_VALID;
547 return ASN1_VALUE_NOT_FOUND;
549 _asn1_set_value (node, value, strlen (value) + 1);
552 { /* GENERALIZED TIME */
554 _asn1_set_value (node, value, strlen (value) + 1);
557 case TYPE_OCTET_STRING:
559 len = strlen (value);
560 _asn1_set_value_octet (node, value, len);
562 case TYPE_GENERALSTRING:
564 len = strlen (value);
565 _asn1_set_value_octet (node, value, len);
567 case TYPE_BIT_STRING:
569 len = strlen (value);
570 asn1_length_der ((len >> 3) + 2, NULL, &len2);
571 temp = (unsigned char *) _asn1_malloc ((len >> 3) + 2 + len2);
573 return ASN1_MEM_ALLOC_ERROR;
575 asn1_bit_der (value, len, temp, &len2);
576 _asn1_set_value_m (node, temp, len2);
583 if (!strcmp (p->name, value))
590 asn1_delete_structure (&p2);
601 return ASN1_ELEMENT_NOT_FOUND;
604 _asn1_set_value_octet (node, value, len);
606 case TYPE_SEQUENCE_OF:
608 if (strcmp (value, "NEW"))
609 return ASN1_VALUE_NOT_VALID;
610 _asn1_append_sequence_set (node);
613 return ASN1_ELEMENT_NOT_FOUND;
621 #define PUT_VALUE( ptr, ptr_size, data, data_size) \
623 if (ptr_size < data_size) { \
624 return ASN1_MEM_ERROR; \
626 memcpy( ptr, data, data_size); \
629 #define PUT_STR_VALUE( ptr, ptr_size, data) \
630 *len = strlen(data) + 1; \
631 if (ptr_size < *len) { \
632 return ASN1_MEM_ERROR; \
634 /* this strcpy is checked */ \
638 #define ADD_STR_VALUE( ptr, ptr_size, data) \
639 *len = strlen(data) + 1; \
640 if (ptr_size < strlen(ptr)+(*len)) { \
641 return ASN1_MEM_ERROR; \
643 /* this strcat is checked */ \
648 * asn1_read_value - Returns the value of one element inside a structure
649 * @root: pointer to a structure.
650 * @name: the name of the element inside a structure that you want to read.
651 * @ivalue: vector that will contain the element's content, must be a
652 * pointer to memory cells already allocated.
653 * @len: number of bytes of *value: value[0]..value[len-1]. Initialy
654 * holds the sizeof value.
656 * Returns the value of one element inside a structure.
658 * If an element is OPTIONAL and the function "read_value" returns
659 * %ASN1_ELEMENT_NOT_FOUND, it means that this element wasn't present
660 * in the der encoding that created the structure. The first element
661 * of a SEQUENCE_OF or SET_OF is named "?1". The second one "?2" and
664 * INTEGER: VALUE will contain a two's complement form integer.
666 * integer=-1 -> value[0]=0xFF , len=1.
667 * integer=1 -> value[0]=0x01 , len=1.
669 * ENUMERATED: As INTEGER (but only with not negative numbers).
671 * BOOLEAN: VALUE will be the null terminated string "TRUE" or
672 * "FALSE" and LEN=5 or LEN=6.
674 * OBJECT IDENTIFIER: VALUE will be a null terminated string with
675 * each number separated by a dot (i.e. "1.2.3.543.1").
677 * LEN = strlen(VALUE)+1
679 * UTCTime: VALUE will be a null terminated string in one of these
680 * formats: "YYMMDDhhmmss+hh'mm'" or "YYMMDDhhmmss-hh'mm'".
681 * LEN=strlen(VALUE)+1.
683 * GeneralizedTime: VALUE will be a null terminated string in the
684 * same format used to set the value.
686 * OCTET STRING: VALUE will contain the octet string and LEN will be
687 * the number of octets.
689 * GeneralString: VALUE will contain the generalstring and LEN will
690 * be the number of octets.
692 * BIT STRING: VALUE will contain the bit string organized by bytes
693 * and LEN will be the number of bits.
695 * CHOICE: If NAME indicates a choice type, VALUE will specify the
696 * alternative selected.
698 * ANY: If NAME indicates an any type, VALUE will indicate the DER
699 * encoding of the structure actually used.
703 * ASN1_SUCCESS: Set value OK.
705 * ASN1_ELEMENT_NOT_FOUND: NAME is not a valid element.
707 * ASN1_VALUE_NOT_FOUND: There isn't any value for the element selected.
709 * ASN1_MEM_ERROR: The value vector isn't big enough to store the result.
710 * In this case LEN will contain the number of bytes needed.
714 asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
716 ASN1_TYPE node, p, p2;
718 int value_size = *len;
719 unsigned char *value = ivalue;
721 node = asn1_find_node (root, name);
723 return ASN1_ELEMENT_NOT_FOUND;
725 if ((type_field (node->type) != TYPE_NULL) &&
726 (type_field (node->type) != TYPE_CHOICE) &&
727 !(node->type & CONST_DEFAULT) && !(node->type & CONST_ASSIGN) &&
728 (node->value == NULL))
729 return ASN1_VALUE_NOT_FOUND;
731 switch (type_field (node->type))
734 PUT_STR_VALUE (value, value_size, "NULL");
737 if ((node->type & CONST_DEFAULT) && (node->value == NULL))
740 while (type_field (p->type) != TYPE_DEFAULT)
742 if (p->type & CONST_TRUE)
744 PUT_STR_VALUE (value, value_size, "TRUE");
748 PUT_STR_VALUE (value, value_size, "FALSE");
751 else if (node->value[0] == 'T')
753 PUT_STR_VALUE (value, value_size, "TRUE");
757 PUT_STR_VALUE (value, value_size, "FALSE");
761 case TYPE_ENUMERATED:
762 if ((node->type & CONST_DEFAULT) && (node->value == NULL))
765 while (type_field (p->type) != TYPE_DEFAULT)
767 if ((isdigit (p->value[0])) || (p->value[0] == '-')
768 || (p->value[0] == '+'))
770 if (_asn1_convert_integer
771 (p->value, value, value_size, len) != ASN1_SUCCESS)
772 return ASN1_MEM_ERROR;
775 { /* is an identifier like v1 */
779 if (type_field (p2->type) == TYPE_CONSTANT)
781 if ((p2->name) && (!strcmp (p2->name, p->value)))
783 if (_asn1_convert_integer
784 (p2->value, value, value_size,
785 len) != ASN1_SUCCESS)
786 return ASN1_MEM_ERROR;
797 if (asn1_get_octet_der
798 (node->value, node->value_len, &len2, value, value_size,
799 len) != ASN1_SUCCESS)
800 return ASN1_MEM_ERROR;
804 if (node->type & CONST_ASSIGN)
810 if (type_field (p->type) == TYPE_CONSTANT)
812 ADD_STR_VALUE (value, value_size, p->value);
815 ADD_STR_VALUE (value, value_size, ".");
820 *len = strlen (value) + 1;
822 else if ((node->type & CONST_DEFAULT) && (node->value == NULL))
825 while (type_field (p->type) != TYPE_DEFAULT)
827 PUT_STR_VALUE (value, value_size, p->value);
831 PUT_STR_VALUE (value, value_size, node->value);
835 PUT_STR_VALUE (value, value_size, node->value);
837 case TYPE_OCTET_STRING:
839 if (asn1_get_octet_der
840 (node->value, node->value_len, &len2, value, value_size,
841 len) != ASN1_SUCCESS)
842 return ASN1_MEM_ERROR;
844 case TYPE_GENERALSTRING:
846 if (asn1_get_octet_der
847 (node->value, node->value_len, &len2, value, value_size,
848 len) != ASN1_SUCCESS)
849 return ASN1_MEM_ERROR;
851 case TYPE_BIT_STRING:
854 (node->value, node->value_len, &len2, value, value_size,
855 len) != ASN1_SUCCESS)
856 return ASN1_MEM_ERROR;
859 PUT_STR_VALUE (value, value_size, node->down->name);
863 len2 = asn1_get_length_der (node->value, node->value_len, &len3);
865 return ASN1_DER_ERROR;
866 PUT_VALUE (value, value_size, node->value + len3, len2);
869 return ASN1_ELEMENT_NOT_FOUND;
877 * asn1_read_tag - Returns the TAG of one element inside a structure
878 * @root: pointer to a structure
879 * @name: the name of the element inside a structure.
880 * @tagValue: variable that will contain the TAG value.
881 * @classValue: variable that will specify the TAG type.
883 * Returns the TAG and the CLASS of one element inside a structure.
884 * CLASS can have one of these constants: %ASN1_CLASS_APPLICATION,
885 * %ASN1_CLASS_UNIVERSAL, %ASN1_CLASS_PRIVATE or
886 * %ASN1_CLASS_CONTEXT_SPECIFIC.
890 * ASN1_SUCCESS: Set value OK.
892 * ASN1_ELEMENT_NOT_FOUND: NAME is not a valid element.
896 asn1_read_tag (ASN1_TYPE root, const char *name, int *tagValue,
899 ASN1_TYPE node, p, pTag;
901 node = asn1_find_node (root, name);
903 return ASN1_ELEMENT_NOT_FOUND;
907 /* pTag will points to the IMPLICIT TAG */
909 if (node->type & CONST_TAG)
913 if (type_field (p->type) == TYPE_TAG)
915 if ((p->type & CONST_IMPLICIT) && (pTag == NULL))
917 else if (p->type & CONST_EXPLICIT)
926 *tagValue = strtoul (pTag->value, NULL, 10);
928 if (pTag->type & CONST_APPLICATION)
929 *classValue = ASN1_CLASS_APPLICATION;
930 else if (pTag->type & CONST_UNIVERSAL)
931 *classValue = ASN1_CLASS_UNIVERSAL;
932 else if (pTag->type & CONST_PRIVATE)
933 *classValue = ASN1_CLASS_PRIVATE;
935 *classValue = ASN1_CLASS_CONTEXT_SPECIFIC;
939 *classValue = ASN1_CLASS_UNIVERSAL;
941 switch (type_field (node->type))
944 *tagValue = ASN1_TAG_NULL;
947 *tagValue = ASN1_TAG_BOOLEAN;
950 *tagValue = ASN1_TAG_INTEGER;
952 case TYPE_ENUMERATED:
953 *tagValue = ASN1_TAG_ENUMERATED;
956 *tagValue = ASN1_TAG_OBJECT_ID;
959 if (node->type & CONST_UTC)
961 *tagValue = ASN1_TAG_UTCTime;
964 *tagValue = ASN1_TAG_GENERALIZEDTime;
966 case TYPE_OCTET_STRING:
967 *tagValue = ASN1_TAG_OCTET_STRING;
969 case TYPE_GENERALSTRING:
970 *tagValue = ASN1_TAG_GENERALSTRING;
972 case TYPE_BIT_STRING:
973 *tagValue = ASN1_TAG_BIT_STRING;
976 case TYPE_SEQUENCE_OF:
977 *tagValue = ASN1_TAG_SEQUENCE;
981 *tagValue = ASN1_TAG_SET;