tests/Test_tree.c

   1 /*
   2  *      Copyright (C) 2006, 2007 Free Software Foundation
   3  *      Copyright (C) 2002 Fabio Fiorina
   4  *
   5  * This file is part of LIBTASN1.
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU 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, see <http://www.gnu.org/licenses/>.
  19  *
  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   /* Bug regression test: Empty write on 64-bit platforms */
 396   {ACT_CREATE,"TEST_TREE.Checksum",0,0,ASN1_SUCCESS},
 397   {ACT_WRITE,"checksum","foo",0,ASN1_SUCCESS},
 398   {ACT_WRITE,"checksum","",0,ASN1_SUCCESS},
 399   {ACT_ENCODING_LENGTH,"",0,4,ASN1_MEM_ERROR},
 400   {ACT_ENCODING,"",0,3,ASN1_MEM_ERROR},
 401   {ACT_ENCODING,"",0,4,ASN1_SUCCESS},
 402   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
 403   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 404   {ACT_CREATE,"TEST_TREE.Checksum",0,0,ASN1_SUCCESS},
 405   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
 406   {ACT_DECODING_ELEMENT,"checksum",0,0,ASN1_SUCCESS},
 407   {ACT_READ,"checksum","",0,ASN1_SUCCESS},
 408   {ACT_READ_LENGTH,"checksum",NULL,0,ASN1_SUCCESS}, /* MEM_FAILURE? */
 409   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
 410   {ACT_DELETE,"","",0,ASN1_SUCCESS},
 411
 412   /* end */
 413   {ACT_NULL}
 414
 415 };
 416
 417
 418 int
 419 main(int argc,char *argv[])
 420 {
 421   asn1_retCode result;
 422   ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
 423   ASN1_TYPE asn1_element=ASN1_TYPE_EMPTY;
 424   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
 425   FILE *out;
 426   test_type *test;
 427   int errorCounter=0,testCounter=0,der_len;
 428   unsigned char value[1024],der[1024];
 429   int valueLen,tag=0,class=0;
 430   int k;
 431   int start,end;
 432   const char *str_p=NULL;
 433   const char *treefile = getenv ("ASN1TREE");
 434
 435   if (!treefile)
 436     treefile = "Test_tree.asn";
 437
 438   printf("\n\n/****************************************/\n");
 439   printf(    "/*     Test sequence : Test_tree        */\n");
 440   printf(    "/****************************************/\n\n");
 441   printf("ASN1TREE: %s\n", treefile);
 442
 443   /* Check version */
 444   if(asn1_check_version("0.2.11")==NULL)
 445     printf("\nLibrary version check ERROR:\n actual version: %s\n\n",asn1_check_version(NULL));
 446
 447   if(1)
 448     result=asn1_parser2tree(treefile,&definitions,errorDescription);
 449   else
 450     result=asn1_array2tree(Test_tree_asn1_tab,&definitions,errorDescription);
 451
 452   if(result!=ASN1_SUCCESS){
 453     libtasn1_perror(result);
 454     printf("ErrorDescription = %s\n\n",errorDescription);
 455     exit(1);
 456   }
 457
 458   if(1)
 459     out=stdout;
 460   else
 461     out=fopen("Test_tree.out","w");
 462
 463   if(out==NULL){
 464     printf("Output file ERROR\n");
 465     exit(1);
 466   }
 467
 468   if(0){
 469     asn1_print_structure(out,definitions,"TEST_TREE",ASN1_PRINT_ALL);
 470     fprintf(out,"\n");
 471   }
 472
 473   test=test_array;
 474
 475   while(test->action != ACT_NULL){
 476     testCounter++;
 477
 478     switch(test->action){
 479     case ACT_CREATE:
 480       result=asn1_create_element(definitions,test->par1,&asn1_element);
 481       break;
 482     case ACT_DELETE:
 483       result=asn1_delete_structure(&asn1_element);
 484       break;
 485     case ACT_DELETE_ELEMENT:
 486       result=asn1_delete_element(asn1_element,test->par1);
 487       break;
 488     case ACT_WRITE:
 489       if((test->par2) && (!strcmp("DER",test->par2)))
 490         result=asn1_write_value(asn1_element,test->par1,der,der_len);
 491       else
 492         result=asn1_write_value(asn1_element,test->par1,test->par2,test->par3);
 493       break;
 494     case ACT_READ:
 495     case ACT_READ_BIT:
 496       valueLen=test->par3;
 497       result=asn1_read_value(asn1_element,test->par1,value,&valueLen);
 498       break;
 499     case ACT_READ_LENGTH:
 500       valueLen=0;
 501       result=asn1_read_value(asn1_element,test->par1,NULL,&valueLen);
 502       break;
 503     case ACT_READ_DEFINITIONS:
 504       valueLen=1024;
 505       result=asn1_read_value(definitions,test->par1,value,&valueLen);
 506       break;
 507     case ACT_READ_TAG_CLASS:
 508       result=asn1_read_tag(asn1_element,test->par1,&tag,&class);
 509       break;
 510     case ACT_ENCODING:
 511       der_len=test->par3;
 512       result=asn1_der_coding(asn1_element,test->par1,der,&der_len,
 513                              errorDescription);
 514       break;
 515     case ACT_ENCODING_LENGTH:
 516       der_len=0;
 517       result=asn1_der_coding(asn1_element,test->par1,NULL,&der_len,
 518                              errorDescription);
 519       break;
 520     case ACT_DECODING:
 521       result=asn1_der_decoding(&asn1_element,der,der_len,
 522                              errorDescription);
 523       break;
 524     case ACT_DECODING_ELEMENT:
 525       result=asn1_der_decoding_element(&asn1_element,test->par1,der,der_len,
 526                              errorDescription);
 527       break;
 528     case ACT_DECODING_START_END:
 529       result=asn1_der_decoding_startEnd(asn1_element,der,der_len,test->par1,
 530                                         &start,&end);
 531       break;
 532     case ACT_EXPAND_ANY:
 533       result=asn1_expand_any_defined_by(definitions,&asn1_element);
 534       break;
 535     case ACT_EXPAND_OCTET:
 536       result=asn1_expand_octet_string(definitions,&asn1_element,test->par1,
 537                                       test->par2);
 538       break;
 539     case ACT_OID_2_STRUCTURE:
 540       str_p=asn1_find_structure_from_oid(definitions,test->par1);
 541       break;
 542     case ACT_VISIT:
 543       asn1_print_structure(out,asn1_element,test->par1,test->par3);
 544       fprintf(out,"\n");
 545       result=ASN1_SUCCESS;
 546       break;
 547     case ACT_PRINT_DER:
 548       printf("DER encoding len:%i\n",der_len);
 549       printf("DER encoding: ");
 550       for(k=0;k<der_len;k++)
 551         printf("%02x ",der[k]);
 552       printf("\n\n");
 553       result=ASN1_SUCCESS;
 554       break;
 555     case ACT_SET_DER:
 556       der_len=test->par3;
 557       memcpy(der,test->par1,der_len);
 558       result=ASN1_SUCCESS;
 559       break;
 560     case ACT_NUMBER_OF_ELEMENTS:
 561       result=asn1_number_of_elements(asn1_element,test->par1,&valueLen);
 562       break;
 563     default:
 564       break;
 565     }
 566
 567
 568     switch(test->action){
 569     case ACT_CREATE:
 570     case ACT_DELETE:
 571     case ACT_DELETE_ELEMENT:
 572     case ACT_WRITE:
 573     case ACT_VISIT:
 574     case ACT_ENCODING:
 575     case ACT_DECODING:
 576     case ACT_PRINT_DER:
 577     case ACT_EXPAND_ANY:
 578     case ACT_EXPAND_OCTET:
 579     case ACT_SET_DER:
 580       if(result != test->errorNumber){
 581         errorCounter++;
 582         printf("ERROR N. %d:\n",errorCounter);
 583         printf("  Action %d - %s - %s - %d\n",test->action,test->par1,
 584                test->par2,test->par3);
 585         printf("  Error expected: %s\n",libtasn1_strerror(test->errorNumber));
 586         printf("  Error detected: %s\n\n",libtasn1_strerror(result));
 587       }
 588       break;
 589     case ACT_DECODING_ELEMENT:
 590       if(result != test->errorNumber){
 591         errorCounter++;
 592         printf("ERROR N. %d:\n",errorCounter);
 593         printf("  Action %d - %s - %s - %d\n",test->action,test->par1,
 594                test->par2,test->par3);
 595         printf("  Error expected: %s\n",libtasn1_strerror(test->errorNumber));
 596         printf("  Error detected: %s\n",libtasn1_strerror(result));
 597         printf("  Error description : %s\n\n",errorDescription);
 598       }
 599       break;
 600     case ACT_NUMBER_OF_ELEMENTS:
 601     case ACT_READ_LENGTH:
 602       if((result != test->errorNumber) ||
 603          (valueLen != test->par3)){
 604         errorCounter++;
 605         printf("ERROR N. %d:\n",errorCounter);
 606         printf("  Action %d - %s\n",test->action,test->par1);
 607         printf("  Error expected: %s - %d\n",libtasn1_strerror(test->errorNumber),
 608                                              test->par3);
 609         printf("  Error detected: %s - %d\n\n",libtasn1_strerror(result),
 610                                           valueLen);
 611       }
 612       break;
 613     case ACT_ENCODING_LENGTH:
 614       if((result != test->errorNumber) ||
 615          (der_len != test->par3)){
 616         errorCounter++;
 617         printf("ERROR N. %d:\n",errorCounter);
 618         printf("  Action %d - %s\n",test->action,test->par1);
 619         printf("  Error expected: %s - %d\n",libtasn1_strerror(test->errorNumber),
 620                                              test->par3);
 621         printf("  Error detected: %s - %d\n\n",libtasn1_strerror(result),
 622                                           der_len);
 623       }
 624       break;
 625     case ACT_OID_2_STRUCTURE:
 626       if(((test->errorNumber!=ASN1_SUCCESS) && (str_p!=NULL)) ||
 627          ((test->errorNumber==ASN1_SUCCESS) && (str_p==NULL)) ||
 628          ((test->errorNumber==ASN1_SUCCESS) && (strcmp(str_p,test->par2)))){
 629         errorCounter++;
 630         printf("ERROR N. %d:\n",errorCounter);
 631         printf("  Action %d - %s\n",test->action,test->par1);
 632         printf("  Error expected: %s - %s\n",libtasn1_strerror(test->errorNumber),test->par2);
 633         printf("  Value detected: %s\n\n",str_p);
 634       }
 635       break;
 636     case ACT_DECODING_START_END:
 637       if((result != test->errorNumber) ||
 638          ((!strcmp(test->par2,"START")) && (start != test->par3)) ||
 639          ((!strcmp(test->par2,"END")) && (end != test->par3)) ){
 640         errorCounter++;
 641         printf("ERROR N. %d:\n",errorCounter);
 642         printf("  Action %d - %s - %d\n",test->action,test->par1,
 643                                          test->par3);
 644         printf("  Error expected: %s - %s - %d\n",libtasn1_strerror(test->errorNumber),
 645                                              test->par2,test->par3);
 646         printf("  Error detected: %s - %d - %d\n\n",libtasn1_strerror(result),
 647                                           start,end);
 648       }
 649       break;
 650
 651     case ACT_READ_TAG_CLASS:
 652       if((result != test->errorNumber) ||
 653          ((!strcmp(test->par2,"TAG")) && (tag != test->par3)) ||
 654          ((!strcmp(test->par2,"CLASS")) && (class != test->par3))){
 655         errorCounter++;
 656         printf("ERROR N. %d:\n",errorCounter);
 657         printf("  Action %d - %s - %d\n",test->action,test->par1,
 658                                          test->par3);
 659         printf("  Error expected: %s - %s - %d\n",libtasn1_strerror(test->errorNumber),
 660                                              test->par2,test->par3);
 661         printf("  Error detected: %s - %d - %d\n\n",libtasn1_strerror(result),
 662                                           tag,class);
 663       }
 664
 665       break;
 666
 667     case ACT_READ:
 668     case ACT_READ_DEFINITIONS:
 669     case ACT_READ_BIT:
 670       if(test->action==ACT_READ_BIT){
 671         if((valueLen-(valueLen/8.0))==0) tag=valueLen/8;
 672         else tag=(valueLen/8)+1;
 673         if((test->par3-(test->par3/8.0))==0) class=test->par3/8;
 674         else class=(test->par3/8)+1;
 675       }
 676
 677       for(k=0;k<class;k++)
 678         if(test->par2[k] != value[k]){
 679           k=-1;
 680           break;
 681         }
 682
 683       if((result != test->errorNumber) ||
 684          (valueLen != test->par3) ||
 685          (k == -1)){
 686         errorCounter++;
 687         printf("ERROR N. %d:\n",errorCounter);
 688         printf("  Action %d - %s\n",test->action,test->par1);
 689         printf("  Error expected: %s - %d - ",libtasn1_strerror(test->errorNumber),
 690                                              test->par3);
 691         for(k=0;k<test->par3;k++)
 692           printf("%02x",test->par2[k]);
 693         printf("\n  Error detected: %s - %d - ",libtasn1_strerror(result),
 694                                           valueLen);
 695         for(k=0;k<valueLen;k++)
 696           printf("%02x",value[k]);
 697         printf("\n\n");
 698
 699       }
 700
 701       break;
 702     default:
 703       break;
 704     }
 705
 706     test++;
 707   }
 708
 709
 710   printf("Total tests : %d\n",testCounter);
 711   printf("Total errors: %d\n",errorCounter);
 712
 713
 714   /* Clear the definition structures */
 715   asn1_delete_structure(&definitions);
 716
 717
 718   if(out != stdout) fclose(out);
 719
 720   if(errorCounter > 0)
 721     return 1;
 722
 723   exit(0);
 724 }
 725
 726
 727
 728
 729
 730
 731
 732
 733