tests/Test_tree.c

   1 /*
   2  *      Copyright (C) 2002 Fabio Fiorina
   3  *
   4  * This file is part of LIBTASN1.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program 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  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19  * 02110-1301, USA
  20  */
  21
  22
  23 /*****************************************************/
  24 /* File: Test_tree.c                                 */
  25 /* Description: Test sequences for these functions:  */
  26 /*     asn1_visit_tree,                              */
  27 /*     asn1_create_structure,                        */
  28 /*     asn1_delete_structure,                        */
  29 /*     asn1_write_value,                             */
  30 /*     asn1_read_value,                              */
  31 /*****************************************************/
  32
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <stdlib.h>
  36 #include "libtasn1.h"
  37
  38 #include "Test_tree_asn1_tab.c"
  39
  40 #define ACT_NULL       0
  41 #define ACT_CREATE     1
  42 #define ACT_DELETE     2
  43 #define ACT_WRITE      3
  44 #define ACT_READ       4
  45 #define ACT_VISIT      5
  46 #define ACT_ENCODING   6
  47 #define ACT_DECODING   7
  48 #define ACT_PRINT_DER  8
  49 #define ACT_EXPAND_ANY 9
  50 #define ACT_DECODING_ELEMENT   10
  51 #define ACT_EXPAND_OCTET       11
  52 #define ACT_NUMBER_OF_ELEMENTS 12
  53 #define ACT_DECODING_START_END 13
  54 #define ACT_READ_DEFINITIONS   14
  55 #define ACT_READ_TAG_CLASS     15
  56 #define ACT_OID_2_STRUCTURE    16
  57 #define ACT_READ_LENGTH        17
  58 #define ACT_ENCODING_LENGTH    18
  59 #define ACT_READ_BIT           19
  60 #define ACT_SET_DER            20
  61 #define ACT_DELETE_ELEMENT     21
  62
  63
  64 typedef struct{
  65   int action;
  66   char *par1;
  67   unsigned char *par2;
  68   int par3;
  69   int  errorNumber;
  70 } test_type;
  71
  72
  73 test_type test_array[]={
  74
  75   {ACT_DELETE,"","",0,ASN1_ELEMENT_NOT_FOUND},
  76
  77   /* Test: APPLICATION 30 */
  78   {ACT_CREATE,"TEST_TREE.KrbError",0,0,ASN1_SUCCESS},
  79   {ACT_WRITE,"pvno","5",0,ASN1_SUCCESS},
  80   {ACT_ENCODING_LENGTH,"",0,5,ASN1_MEM_ERROR},
  81   {ACT_ENCODING,"",0,4,ASN1_MEM_ERROR},
  82   {ACT_ENCODING,"",0,5,ASN1_SUCCESS},
  83   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
  84   {ACT_CREATE,"TEST_TREE.KrbError",0,0,ASN1_SUCCESS},
  85   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
  86   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
  87   {ACT_DELETE_ELEMENT,"pvno","",0,ASN1_SUCCESS},
  88   {ACT_DELETE_ELEMENT,"pvno","",0,ASN1_ELEMENT_NOT_FOUND},
  89   {ACT_DELETE,"","",0,ASN1_SUCCESS},
  90
  91   /* Test: CHOICE */
  92   {ACT_CREATE,"TEST_TREE.CertTemplate",0,0,ASN1_SUCCESS},
  93   {ACT_WRITE,"version",0,0,ASN1_SUCCESS},
  94   {ACT_WRITE,"validity",0,0,ASN1_SUCCESS},
  95   {ACT_WRITE,"issuer","rdnSequence",0,ASN1_SUCCESS},
  96   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
  97   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.3",0,ASN1_SUCCESS},
  98   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x18\x71\x75\x61\x73\x61\x72\x2e\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",26,ASN1_SUCCESS},
  99   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
 100   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.7",0,ASN1_SUCCESS},
 101   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x08\x43\x61\x6d\x70\x69\x6e\x61\x73",10,ASN1_SUCCESS},
 102   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
 103   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.6",0,ASN1_SUCCESS},
 104   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x13\x06\x42\x72\x61\x73\x69\x6c",8,ASN1_SUCCESS},
 105   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
 106   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.10",0,ASN1_SUCCESS},
 107   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x02\x49\x43",4,ASN1_SUCCESS},
 108   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
 109   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.11",0,ASN1_SUCCESS},
 110   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x03\x4c\x41\x53",5,ASN1_SUCCESS},
 111   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
 112   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.8",0,ASN1_SUCCESS},
 113   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x09\x53\x61\x6f\x20\x50\x61\x75\x6c\x6f",11,ASN1_SUCCESS},
 114   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
 115   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","1.2.840.113549.1.9.1",0,ASN1_SUCCESS},
 116   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x16\x19\x65\x64\x75\x61\x72\x64\x6f\x40\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",27,ASN1_SUCCESS},
 117   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 118   {ACT_ENCODING_LENGTH,"",0,152,ASN1_MEM_ERROR},
 119   {ACT_ENCODING,"",0,151,ASN1_MEM_ERROR},
 120   {ACT_ENCODING,"",0,152,ASN1_SUCCESS},
 121   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 122   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 123   {ACT_CREATE,"TEST_TREE.CertTemplate",0,0,ASN1_SUCCESS},
 124   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 125   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 126   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?1","",0,ASN1_SUCCESS},
 127   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?1","",0,ASN1_ELEMENT_NOT_FOUND},
 128   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?3","",0,ASN1_SUCCESS},
 129   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?5","",0,ASN1_SUCCESS},
 130   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?7","",0,ASN1_SUCCESS},
 131   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 132   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 133
 134   /* Test: Empty sequnces */
 135   {ACT_CREATE,"TEST_TREE.sequenceEmpty",0,0,ASN1_SUCCESS},
 136   {ACT_WRITE,"int1","1",0,ASN1_SUCCESS},
 137   {ACT_WRITE,"seq1.int",NULL,0,ASN1_SUCCESS},
 138   {ACT_ENCODING_LENGTH,"",0,11,ASN1_MEM_ERROR},
 139   {ACT_ENCODING,"",0,10,ASN1_MEM_ERROR},
 140   {ACT_ENCODING,"",0,11,ASN1_SUCCESS},
 141   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 142   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 143   {ACT_CREATE,"TEST_TREE.sequenceEmpty",0,0,ASN1_SUCCESS},
 144   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 145   {ACT_DECODING_START_END,"seq1","START",5,ASN1_SUCCESS},
 146   {ACT_DECODING_START_END,"seq1","END",6,ASN1_SUCCESS},
 147   {ACT_DECODING_START_END,"set1","START",7,ASN1_SUCCESS},
 148   {ACT_DECODING_START_END,"set1","END",10,ASN1_SUCCESS},
 149   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 150   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 151
 152   /* Test: Indefinite Length */
 153   {ACT_CREATE,"TEST_TREE.IndefiniteLengthTest",0,0,ASN1_SUCCESS},
 154   {ACT_WRITE,"int1","1",0,ASN1_SUCCESS},
 155   {ACT_WRITE,"seq1.int","2",0,ASN1_SUCCESS},
 156   {ACT_WRITE,"set1","NEW",0,ASN1_SUCCESS},
 157   {ACT_WRITE,"set1.?LAST","1.2.3.4",0,ASN1_SUCCESS},
 158   {ACT_WRITE,"set1","NEW",0,ASN1_SUCCESS},
 159   {ACT_WRITE,"set1.?LAST","1.2.5.6",0,ASN1_SUCCESS},
 160   {ACT_ENCODING,"",0,255,ASN1_SUCCESS},
 161   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 162   {ACT_SET_DER,"\x30\x18\xa1\x80\x02\x01\x02\x00\x00\x31\x80\x06\x03\x2a\x03\x04\x06\x03\x2a\x05\x06\x00\x00\x02\x01\x01",
 163    0,26,ASN1_SUCCESS},
 164   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 165   {ACT_CREATE,"TEST_TREE.IndefiniteLengthTest",0,0,ASN1_SUCCESS},
 166   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 167   {ACT_DECODING_START_END,"seq1","START",2,ASN1_SUCCESS},
 168   {ACT_DECODING_START_END,"seq1","END",8,ASN1_SUCCESS},
 169   {ACT_DECODING_START_END,"set1","START",9,ASN1_SUCCESS},
 170   {ACT_DECODING_START_END,"set1","END",22,ASN1_SUCCESS},
 171   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 172   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 173
 174   /* Test: OID */
 175   {ACT_CREATE,"TEST_TREE.OidTest",0,0,ASN1_SUCCESS},
 176   {ACT_READ_LENGTH,"oid",NULL,9,ASN1_MEM_ERROR},
 177   {ACT_READ,"oid","2.5.29.2",9,ASN1_SUCCESS},
 178   {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
 179   {ACT_WRITE,"oid2","2.5.29.1",0,ASN1_SUCCESS},
 180   {ACT_WRITE,"oid3","1.2.29.2",0,ASN1_SUCCESS},
 181   {ACT_ENCODING_LENGTH,"",0,7,ASN1_MEM_ERROR},
 182   {ACT_ENCODING,"",0,6,ASN1_MEM_ERROR},
 183   {ACT_ENCODING,"",0,7,ASN1_SUCCESS},
 184   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 185   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 186   {ACT_CREATE,"TEST_TREE.OidTest",0,0,ASN1_SUCCESS},
 187   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 188   {ACT_DECODING_START_END,"oid","START",2,ASN1_SUCCESS},
 189   {ACT_DECODING_START_END,"oid","END",6,ASN1_SUCCESS},
 190   {ACT_DECODING_START_END,"","START",0,ASN1_SUCCESS},
 191   {ACT_DECODING_START_END,"","END",6,ASN1_SUCCESS},
 192   {ACT_READ,"oid2","2.5.29.1",9,ASN1_SUCCESS},
 193   {ACT_READ,"oid3","1.2.29.2",9,ASN1_SUCCESS},
 194   {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
 195   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 196   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 197
 198   /* Test: ENCODING_LENGTH and READ_LEN */
 199   {ACT_CREATE,"TEST_TREE.OidAndTimeTest",0,0,ASN1_SUCCESS},
 200   {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
 201   {ACT_WRITE,"time1","9801011200Z",1,ASN1_SUCCESS},
 202   {ACT_WRITE,"time2","2001010112001.12-0700",1,ASN1_SUCCESS},
 203   {ACT_WRITE,"oct","ABCD",4,ASN1_SUCCESS},
 204   {ACT_WRITE,"bol","TRUE",1,ASN1_SUCCESS},
 205   {ACT_WRITE,"enum","2",0,ASN1_SUCCESS},
 206   {ACT_WRITE,"bit","1\xC0",10,ASN1_SUCCESS},
 207   {ACT_WRITE,"any","\x30\x01\x01",3,ASN1_SUCCESS},
 208   {ACT_WRITE,"set","NEW",0,ASN1_SUCCESS},
 209   {ACT_WRITE,"set.?LAST","10",0,ASN1_SUCCESS},
 210   {ACT_WRITE,"set","NEW",0,ASN1_SUCCESS},
 211   {ACT_WRITE,"set.?LAST","1",0,ASN1_SUCCESS},
 212   {ACT_WRITE,"gen","Prova",5,ASN1_SUCCESS},
 213   {ACT_READ_LENGTH,"oid",NULL,8,ASN1_MEM_ERROR},
 214   {ACT_READ_LENGTH,"time1",NULL,12,ASN1_MEM_ERROR},
 215   {ACT_READ_LENGTH,"time2",NULL,22,ASN1_MEM_ERROR},
 216   {ACT_READ_LENGTH,"oct",NULL,4,ASN1_MEM_ERROR},
 217   {ACT_READ_LENGTH,"bol",NULL,5,ASN1_MEM_ERROR},
 218   {ACT_READ_LENGTH,"enum",NULL,1,ASN1_MEM_ERROR},
 219   {ACT_READ_LENGTH,"any",NULL,3,ASN1_MEM_ERROR},
 220   {ACT_READ_LENGTH,"gen",NULL,5,ASN1_MEM_ERROR},
 221   {ACT_READ_LENGTH,"bit",NULL,10,ASN1_MEM_ERROR},
 222   {ACT_READ_BIT,"bit","1\xC0",10,ASN1_SUCCESS},
 223   {ACT_ENCODING_LENGTH,"",0,79,ASN1_MEM_ERROR},
 224   {ACT_ENCODING,"",0,78,ASN1_MEM_ERROR},
 225   {ACT_ENCODING,"",0,79,ASN1_SUCCESS},
 226   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 227   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 228   {ACT_CREATE,"TEST_TREE.OidAndTimeTest",0,0,ASN1_SUCCESS},
 229   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 230   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 231   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 232
 233   /* Test: OID to STRUCTURE */
 234   {ACT_OID_2_STRUCTURE,"2.5.29.3","",0,ASN1_ELEMENT_NOT_FOUND},
 235   {ACT_OID_2_STRUCTURE,"1.2.29.2","",0,ASN1_ELEMENT_NOT_FOUND},
 236   {ACT_OID_2_STRUCTURE,"2.5.29.2","anyTest2",0,ASN1_SUCCESS},
 237
 238   /* Test: READ TAG and CLASS */
 239   {ACT_CREATE,"TEST_TREE.SequenceTestTag",0,0,ASN1_SUCCESS},
 240   {ACT_READ_TAG_CLASS,"int","",0,ASN1_ELEMENT_NOT_FOUND},
 241   {ACT_READ_TAG_CLASS,"int1","TAG",ASN1_TAG_INTEGER,ASN1_SUCCESS},
 242   {ACT_READ_TAG_CLASS,"int1","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
 243   {ACT_READ_TAG_CLASS,"int2","TAG",3,ASN1_SUCCESS},
 244   {ACT_READ_TAG_CLASS,"int2","CLASS",ASN1_CLASS_CONTEXT_SPECIFIC,ASN1_SUCCESS},
 245   {ACT_READ_TAG_CLASS,"str1","TAG",1,ASN1_SUCCESS},
 246   {ACT_READ_TAG_CLASS,"str1","CLASS",ASN1_CLASS_CONTEXT_SPECIFIC,ASN1_SUCCESS},
 247   {ACT_READ_TAG_CLASS,"str2","TAG",28,ASN1_SUCCESS},
 248   {ACT_READ_TAG_CLASS,"str2","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
 249   {ACT_READ_TAG_CLASS,"str3","TAG",28,ASN1_SUCCESS},
 250   {ACT_READ_TAG_CLASS,"str3","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
 251   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 252   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 253
 254   /* Test: OBJECT IDENTIFIER  elements */
 255   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
 256   {ACT_WRITE,"int1","v2",0,ASN1_SUCCESS},
 257   {ACT_READ,"int1","\x01",1,ASN1_SUCCESS},
 258   {ACT_WRITE,"int2","0",0,ASN1_SUCCESS},
 259   {ACT_WRITE,"oct","\x02\x01\x0a",3,ASN1_SUCCESS},
 260   {ACT_WRITE,"id","1 2 3 4 5",0,ASN1_VALUE_NOT_VALID},
 261   {ACT_WRITE,"id","2.5.29.2",0,ASN1_SUCCESS},
 262   {ACT_READ,"id","2.5.29.2",9,ASN1_SUCCESS},
 263   {ACT_READ_LENGTH,"id",NULL,9,ASN1_MEM_ERROR},
 264   {ACT_WRITE,"any1","\x02\x01\x05",3,ASN1_SUCCESS},
 265   {ACT_READ_DEFINITIONS,"TEST_TREE.id-anyTest","2.5.29.1",9,ASN1_SUCCESS},
 266   {ACT_ENCODING_LENGTH,"",0,20,ASN1_MEM_ERROR},
 267   {ACT_ENCODING,"",0,19,ASN1_MEM_ERROR},
 268   {ACT_ENCODING,"",0,200,ASN1_SUCCESS},
 269   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 270   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 271   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
 272   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 273   {ACT_DECODING_START_END,"id","START",7,ASN1_SUCCESS},
 274   {ACT_READ,"id","2.5.29.2",9,ASN1_SUCCESS},
 275   {ACT_EXPAND_ANY,"",NULL,0,ASN1_SUCCESS},
 276   {ACT_EXPAND_OCTET,"oct","id",0,ASN1_SUCCESS},
 277   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 278   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 279
 280   /* Test: CHOICE elements */
 281   {ACT_CREATE,"TEST_TREE.X520LocalityName",0,0,ASN1_SUCCESS},
 282   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 283   {ACT_WRITE,"","teletexString",0,ASN1_SUCCESS},
 284   {ACT_WRITE,"teletexString","PROVA",5,ASN1_SUCCESS},
 285   {ACT_ENCODING_LENGTH,"",0,7,ASN1_MEM_ERROR},
 286   {ACT_ENCODING,"",0,6,ASN1_MEM_ERROR},
 287   {ACT_ENCODING,"",0,7,ASN1_SUCCESS},
 288   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 289   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 290   {ACT_CREATE,"TEST_TREE.X520LocalityName",0,0,ASN1_SUCCESS},
 291   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 292   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 293   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 294
 295   /* Test: OPTIONAL elements */
 296   {ACT_CREATE,"TEST_TREE.DHParameter",0,0,ASN1_SUCCESS},
 297   {ACT_WRITE,"prime","1",0,ASN1_SUCCESS},
 298   {ACT_WRITE,"base","2",0,ASN1_SUCCESS},
 299   {ACT_WRITE,"privateValueLength",NULL,0,ASN1_SUCCESS},
 300   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 301   {ACT_ENCODING_LENGTH,"",0,8,ASN1_MEM_ERROR},
 302   {ACT_ENCODING,"",0,7,ASN1_MEM_ERROR},
 303   {ACT_ENCODING,"",0,8,ASN1_SUCCESS},
 304   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 305   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 306   {ACT_CREATE,"TEST_TREE.DHParameter",0,0,ASN1_SUCCESS},
 307   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 308   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 309   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 310
 311   /* Test: Integer */
 312   {ACT_CREATE,"TEST_TREE.AnyTest2",0,0,ASN1_SUCCESS},
 313   {ACT_WRITE,"","int",0,ASN1_SUCCESS},
 314   {ACT_WRITE,"int","0",0,ASN1_SUCCESS},
 315   {ACT_ENCODING_LENGTH,"",0,3,ASN1_MEM_ERROR},
 316   {ACT_ENCODING,"",0,2,ASN1_MEM_ERROR},
 317   {ACT_ENCODING,"",0,3,ASN1_SUCCESS},
 318   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 319   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 320   {ACT_WRITE,"int","-1",0,ASN1_SUCCESS},
 321   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
 322   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 323   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 324   {ACT_WRITE,"int","1",0,ASN1_SUCCESS},
 325   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
 326   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 327   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 328   {ACT_WRITE,"int","2000000000",0,ASN1_SUCCESS},
 329   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
 330   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 331   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 332   {ACT_WRITE,"int","-2000000000",0,ASN1_SUCCESS},
 333   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
 334   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 335   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 336   {ACT_WRITE,"int","-20000000000",0,ASN1_SUCCESS},
 337   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
 338   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 339   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 340   {ACT_WRITE,"int","20000000000",0,ASN1_SUCCESS},
 341   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
 342   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 343   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 344   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 345
 346   /* Test: elements without names */
 347   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
 348   {ACT_WRITE,"int2","10",0,ASN1_SUCCESS},
 349   {ACT_WRITE,"seq","NEW",1,ASN1_SUCCESS},
 350   {ACT_WRITE,"seq.?LAST","1",0,ASN1_SUCCESS},
 351   {ACT_WRITE,"seq","NEW",1,ASN1_SUCCESS},
 352   {ACT_WRITE,"seq.?LAST","2",0,ASN1_SUCCESS},
 353   {ACT_WRITE,"any1",NULL,0,ASN1_SUCCESS},
 354   {ACT_NUMBER_OF_ELEMENTS,"seq","",2,ASN1_SUCCESS},
 355   {ACT_WRITE,"id","1.2.3.4",0,ASN1_SUCCESS},
 356   {ACT_WRITE,"oct","\x30\x03\x02\x01\x15",5,ASN1_SUCCESS},
 357   {ACT_ENCODING,"int2",0,1024,ASN1_SUCCESS},
 358   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 359   {ACT_ENCODING,"seq.?2",0,2,ASN1_MEM_ERROR},
 360   {ACT_ENCODING,"seq.?2",0,3,ASN1_SUCCESS},
 361   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 362   {ACT_ENCODING_LENGTH,"",0,25,ASN1_MEM_ERROR},
 363   {ACT_ENCODING,"",0,24,ASN1_MEM_ERROR},
 364   {ACT_ENCODING,"",0,25,ASN1_SUCCESS},
 365   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 366   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
 367   {ACT_DECODING_ELEMENT,"int2",0,0,ASN1_SUCCESS},
 368   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 369   {ACT_READ,"int2","\x0a",1,ASN1_SUCCESS},
 370   {ACT_READ_LENGTH,"int2",NULL,1,ASN1_MEM_ERROR},
 371   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
 372   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 373   {ACT_DECODING_START_END,"seq.?2","START",10,ASN1_SUCCESS},
 374   {ACT_EXPAND_OCTET,"oct","id",0,ASN1_SUCCESS},
 375   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 376   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 377
 378   /* Test GeneralString */
 379   {ACT_CREATE,"TEST_TREE.Test3",0,0,ASN1_SUCCESS},
 380   {ACT_WRITE,"a","1234",0,ASN1_SUCCESS},
 381   {ACT_WRITE,"b","prova",5,ASN1_SUCCESS},
 382   {ACT_ENCODING_LENGTH,"",0,17,ASN1_MEM_ERROR},
 383   {ACT_ENCODING,"",0,16,ASN1_MEM_ERROR},
 384   {ACT_ENCODING,"",0,17,ASN1_SUCCESS},
 385   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 386   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 387   {ACT_CREATE,"TEST_TREE.Test3",0,0,ASN1_SUCCESS},
 388   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 389   {ACT_DECODING_ELEMENT,"b",0,0,ASN1_SUCCESS},
 390   {ACT_READ,"b","prova",5,ASN1_SUCCESS},
 391   {ACT_READ_LENGTH,"b",NULL,5,ASN1_MEM_ERROR},
 392   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 393   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 394
 395
 396
 397   /* end */
 398   {ACT_NULL}
 399
 400 };
 401
 402
 403 int
 404 main(int argc,char *argv[])
 405 {
 406   asn1_retCode result;
 407   ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
 408   ASN1_TYPE asn1_element=ASN1_TYPE_EMPTY;
 409   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
 410   FILE *out;
 411   test_type *test;
 412   int errorCounter=0,testCounter=0,der_len;
 413   unsigned char value[1024],der[1024];
 414   int valueLen,tag=0,class=0;
 415   int k;
 416   int start,end;
 417   const char *str_p=NULL;
 418
 419   printf("\n\n/****************************************/\n");
 420   printf(    "/*     Test sequence : Test_tree        */\n");
 421   printf(    "/****************************************/\n\n");
 422
 423   /* Check version */
 424   if(asn1_check_version("0.2.11")==NULL)
 425     printf("\nLibrary version check ERROR:\n actual version: %s\n\n",asn1_check_version(NULL));
 426
 427   if(1)
 428     result=asn1_parser2tree("Test_tree.asn",&definitions,errorDescription);
 429   else
 430     result=asn1_array2tree(Test_tree_asn1_tab,&definitions,errorDescription);
 431
 432   if(result!=ASN1_SUCCESS){
 433     libtasn1_perror(result);
 434     printf("ErrorDescription = %s\n\n",errorDescription);
 435     exit(1);
 436   }
 437
 438   if(1)
 439     out=stdout;
 440   else
 441     out=fopen("Test_tree.out","w");
 442
 443   if(out==NULL){
 444     printf("Output file ERROR\n");
 445     exit(1);
 446   }
 447
 448   if(0){
 449     asn1_print_structure(out,definitions,"TEST_TREE",ASN1_PRINT_ALL);
 450     fprintf(out,"\n");
 451   }
 452
 453   test=test_array;
 454
 455   while(test->action != ACT_NULL){
 456     testCounter++;
 457
 458     switch(test->action){
 459     case ACT_CREATE:
 460       result=asn1_create_element(definitions,test->par1,&asn1_element);
 461       break;
 462     case ACT_DELETE:
 463       result=asn1_delete_structure(&asn1_element);
 464       break;
 465     case ACT_DELETE_ELEMENT:
 466       result=asn1_delete_element(asn1_element,test->par1);
 467       break;
 468     case ACT_WRITE:
 469       if((test->par2) && (!strcmp("DER",test->par2)))
 470         result=asn1_write_value(asn1_element,test->par1,der,der_len);
 471       else
 472         result=asn1_write_value(asn1_element,test->par1,test->par2,test->par3);
 473       break;
 474     case ACT_READ:
 475     case ACT_READ_BIT:
 476       valueLen=test->par3;
 477       result=asn1_read_value(asn1_element,test->par1,value,&valueLen);
 478       break;
 479     case ACT_READ_LENGTH:
 480       valueLen=0;
 481       result=asn1_read_value(asn1_element,test->par1,NULL,&valueLen);
 482       break;
 483     case ACT_READ_DEFINITIONS:
 484       valueLen=1024;
 485       result=asn1_read_value(definitions,test->par1,value,&valueLen);
 486       break;
 487     case ACT_READ_TAG_CLASS:
 488       result=asn1_read_tag(asn1_element,test->par1,&tag,&class);
 489       break;
 490     case ACT_ENCODING:
 491       der_len=test->par3;
 492       result=asn1_der_coding(asn1_element,test->par1,der,&der_len,
 493                              errorDescription);
 494       break;
 495     case ACT_ENCODING_LENGTH:
 496       der_len=0;
 497       result=asn1_der_coding(asn1_element,test->par1,NULL,&der_len,
 498                              errorDescription);
 499       break;
 500     case ACT_DECODING:
 501       result=asn1_der_decoding(&asn1_element,der,der_len,
 502                              errorDescription);
 503       break;
 504     case ACT_DECODING_ELEMENT:
 505       result=asn1_der_decoding_element(&asn1_element,test->par1,der,der_len,
 506                              errorDescription);
 507       break;
 508     case ACT_DECODING_START_END:
 509       result=asn1_der_decoding_startEnd(asn1_element,der,der_len,test->par1,
 510                                         &start,&end);
 511       break;
 512     case ACT_EXPAND_ANY:
 513       result=asn1_expand_any_defined_by(definitions,&asn1_element);
 514       break;
 515     case ACT_EXPAND_OCTET:
 516       result=asn1_expand_octet_string(definitions,&asn1_element,test->par1,
 517                                       test->par2);
 518       break;
 519     case ACT_OID_2_STRUCTURE:
 520       str_p=asn1_find_structure_from_oid(definitions,test->par1);
 521       break;
 522     case ACT_VISIT:
 523       asn1_print_structure(out,asn1_element,test->par1,test->par3);
 524       fprintf(out,"\n");
 525       result=ASN1_SUCCESS;
 526       break;
 527     case ACT_PRINT_DER:
 528       printf("DER encoding len:%i\n",der_len);
 529       printf("DER encoding: ");
 530       for(k=0;k<der_len;k++)
 531         printf("%02x ",der[k]);
 532       printf("\n\n");
 533       result=ASN1_SUCCESS;
 534       break;
 535     case ACT_SET_DER:
 536       der_len=test->par3;
 537       memcpy(der,test->par1,der_len);
 538       result=ASN1_SUCCESS;
 539       break;
 540     case ACT_NUMBER_OF_ELEMENTS:
 541       result=asn1_number_of_elements(asn1_element,test->par1,&valueLen);
 542       break;
 543     default:
 544       break;
 545     }
 546
 547
 548     switch(test->action){
 549     case ACT_CREATE:
 550     case ACT_DELETE:
 551     case ACT_DELETE_ELEMENT:
 552     case ACT_WRITE:
 553     case ACT_VISIT:
 554     case ACT_ENCODING:
 555     case ACT_DECODING:
 556     case ACT_PRINT_DER:
 557     case ACT_EXPAND_ANY:
 558     case ACT_EXPAND_OCTET:
 559     case ACT_SET_DER:
 560       if(result != test->errorNumber){
 561         errorCounter++;
 562         printf("ERROR N. %d:\n",errorCounter);
 563         printf("  Action %d - %s - %s - %d\n",test->action,test->par1,
 564                test->par2,test->par3);
 565         printf("  Error expected: %s\n",libtasn1_strerror(test->errorNumber));
 566         printf("  Error detected: %s\n\n",libtasn1_strerror(result));
 567       }
 568       break;
 569     case ACT_DECODING_ELEMENT:
 570       if(result != test->errorNumber){
 571         errorCounter++;
 572         printf("ERROR N. %d:\n",errorCounter);
 573         printf("  Action %d - %s - %s - %d\n",test->action,test->par1,
 574                test->par2,test->par3);
 575         printf("  Error expected: %s\n",libtasn1_strerror(test->errorNumber));
 576         printf("  Error detected: %s\n",libtasn1_strerror(result));
 577         printf("  Error description : %s\n\n",errorDescription);
 578       }
 579       break;
 580     case ACT_NUMBER_OF_ELEMENTS:
 581     case ACT_READ_LENGTH:
 582       if((result != test->errorNumber) ||
 583          (valueLen != test->par3)){
 584         errorCounter++;
 585         printf("ERROR N. %d:\n",errorCounter);
 586         printf("  Action %d - %s\n",test->action,test->par1);
 587         printf("  Error expected: %s - %d\n",libtasn1_strerror(test->errorNumber),
 588                                              test->par3);
 589         printf("  Error detected: %s - %d\n\n",libtasn1_strerror(result),
 590                                           valueLen);
 591       }
 592       break;
 593     case ACT_ENCODING_LENGTH:
 594       if((result != test->errorNumber) ||
 595          (der_len != test->par3)){
 596         errorCounter++;
 597         printf("ERROR N. %d:\n",errorCounter);
 598         printf("  Action %d - %s\n",test->action,test->par1);
 599         printf("  Error expected: %s - %d\n",libtasn1_strerror(test->errorNumber),
 600                                              test->par3);
 601         printf("  Error detected: %s - %d\n\n",libtasn1_strerror(result),
 602                                           der_len);
 603       }
 604       break;
 605     case ACT_OID_2_STRUCTURE:
 606       if(((test->errorNumber!=ASN1_SUCCESS) && (str_p!=NULL)) ||
 607          ((test->errorNumber==ASN1_SUCCESS) && (str_p==NULL)) ||
 608          ((test->errorNumber==ASN1_SUCCESS) && (strcmp(str_p,test->par2)))){
 609         errorCounter++;
 610         printf("ERROR N. %d:\n",errorCounter);
 611         printf("  Action %d - %s\n",test->action,test->par1);
 612         printf("  Error expected: %s - %s\n",libtasn1_strerror(test->errorNumber),test->par2);
 613         printf("  Value detected: %s\n\n",str_p);
 614       }
 615       break;
 616     case ACT_DECODING_START_END:
 617       if((result != test->errorNumber) ||
 618          ((!strcmp(test->par2,"START")) && (start != test->par3)) ||
 619          ((!strcmp(test->par2,"END")) && (end != test->par3)) ){
 620         errorCounter++;
 621         printf("ERROR N. %d:\n",errorCounter);
 622         printf("  Action %d - %s - %d\n",test->action,test->par1,
 623                                          test->par3);
 624         printf("  Error expected: %s - %s - %d\n",libtasn1_strerror(test->errorNumber),
 625                                              test->par2,test->par3);
 626         printf("  Error detected: %s - %d - %d\n\n",libtasn1_strerror(result),
 627                                           start,end);
 628       }
 629       break;
 630
 631     case ACT_READ_TAG_CLASS:
 632       if((result != test->errorNumber) ||
 633          ((!strcmp(test->par2,"TAG")) && (tag != test->par3)) ||
 634          ((!strcmp(test->par2,"CLASS")) && (class != test->par3))){
 635         errorCounter++;
 636         printf("ERROR N. %d:\n",errorCounter);
 637         printf("  Action %d - %s - %d\n",test->action,test->par1,
 638                                          test->par3);
 639         printf("  Error expected: %s - %s - %d\n",libtasn1_strerror(test->errorNumber),
 640                                              test->par2,test->par3);
 641         printf("  Error detected: %s - %d - %d\n\n",libtasn1_strerror(result),
 642                                           tag,class);
 643       }
 644
 645       break;
 646
 647     case ACT_READ:
 648     case ACT_READ_DEFINITIONS:
 649     case ACT_READ_BIT:
 650       if(test->action==ACT_READ_BIT){
 651         if((valueLen-(valueLen/8.0))==0) tag=valueLen/8;
 652         else tag=(valueLen/8)+1;
 653         if((test->par3-(test->par3/8.0))==0) class=test->par3/8;
 654         else class=(test->par3/8)+1;
 655       }
 656
 657       for(k=0;k<class;k++)
 658         if(test->par2[k] != value[k]){
 659           k=-1;
 660           break;
 661         }
 662
 663       if((result != test->errorNumber) ||
 664          (valueLen != test->par3) ||
 665          (k == -1)){
 666         errorCounter++;
 667         printf("ERROR N. %d:\n",errorCounter);
 668         printf("  Action %d - %s\n",test->action,test->par1);
 669         printf("  Error expected: %s - %d - ",libtasn1_strerror(test->errorNumber),
 670                                              test->par3);
 671         for(k=0;k<test->par3;k++)
 672           printf("%02x",test->par2[k]);
 673         printf("\n  Error detected: %s - %d - ",libtasn1_strerror(result),
 674                                           valueLen);
 675         for(k=0;k<valueLen;k++)
 676           printf("%02x",value[k]);
 677         printf("\n\n");
 678
 679       }
 680
 681       break;
 682     default:
 683       break;
 684     }
 685
 686     test++;
 687   }
 688
 689
 690   printf("Total tests : %d\n",testCounter);
 691   printf("Total errors: %d\n",errorCounter);
 692
 693
 694   /* Clear the definition structures */
 695   asn1_delete_structure(&definitions);
 696
 697
 698   if(out != stdout) fclose(out);
 699
 700   if(errorCounter > 0)
 701     return 1;
 702
 703   exit(0);
 704 }
 705
 706
 707
 708
 709
 710
 711
 712
 713