tests/Test_tree.c

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