LCOV - code coverage report
Current view: top level - src - asn1Decoding.c (source / functions) Hit Total Coverage
Test: GNU Libtasn1 Lines: 53 108 49.1 %
Date: 2013-03-24 Functions: 3 4 75.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 14 39 35.9 %

           Branch data     Line data    Source code
       1                 :            : /* asn1Decoding.c ---  program to generate an ASN1 type from a DER coding.
       2                 :            :  * Copyright (C) 2002-2013 Free Software Foundation, Inc.
       3                 :            :  *
       4                 :            :  * This file is part of LIBTASN1.
       5                 :            :  *
       6                 :            :  * This program is free software: you can redistribute it and/or modify
       7                 :            :  * it under the terms of the GNU General Public License as published by
       8                 :            :  * the Free Software Foundation, either version 3 of the License, or
       9                 :            :  * (at your option) any later version.
      10                 :            :  *
      11                 :            :  * This program is distributed in the hope that it will be useful,
      12                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            :  * GNU 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, see <http://www.gnu.org/licenses/>.
      18                 :            :  *
      19                 :            :  */
      20                 :            : 
      21                 :            : #include <config.h>
      22                 :            : 
      23                 :            : #include <stdio.h>
      24                 :            : #include <string.h>
      25                 :            : #include <stdlib.h>
      26                 :            : #include <unistd.h>
      27                 :            : #include <getopt.h>
      28                 :            : 
      29                 :            : #include <libtasn1.h>
      30                 :            : 
      31                 :            : #include <progname.h>
      32                 :            : #include <version-etc.h>
      33                 :            : #include <read-file.h>
      34                 :            : #include "benchmark.h"
      35                 :            : 
      36                 :            : static int decode (asn1_node definitions, const char *typeName, void *der,
      37                 :            :                    int der_len, int benchmark);
      38                 :            : 
      39                 :            : /* This feature is available in gcc versions 2.5 and later.  */
      40                 :            : #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)
      41                 :            : #define ATTR_NO_RETRUN
      42                 :            : #else
      43                 :            : #define ATTR_NO_RETRUN __attribute__ ((__noreturn__))
      44                 :            : #endif
      45                 :            : 
      46                 :            : ATTR_NO_RETRUN static void
      47                 :          0 : usage (int status)
      48                 :            : {
      49         [ #  # ]:          0 :   if (status != EXIT_SUCCESS)
      50                 :          0 :     fprintf (stderr, "Try `%s --help' for more information.\n", program_name);
      51                 :            :   else
      52                 :            :     {
      53                 :          0 :       printf ("\
      54                 :            : Usage: %s [OPTION] DEFINITIONS ENCODED ASN1TYPE\n", program_name);
      55                 :          0 :       printf ("\
      56                 :            : Decodes DER data in ENCODED file, for the ASN1TYPE element\n\
      57                 :            : described in ASN.1 DEFINITIONS file, and print decoded structures.\n\
      58                 :            : \n");
      59                 :          0 :       printf ("\
      60                 :            :   -h, --help            display this help and exit\n\
      61                 :            :   -v, --version         output version information and exit\n");
      62                 :          0 :       emit_bug_reporting_address ();
      63                 :            :     }
      64                 :          0 :   exit (status);
      65                 :            : }
      66                 :            : 
      67                 :            : int
      68                 :          1 : main (int argc, char *argv[])
      69                 :            : {
      70                 :            :   static const struct option long_options[] = {
      71                 :            :     {"help", no_argument, 0, 'h'},
      72                 :            :     {"version", no_argument, 0, 'v'},
      73                 :            :     {0, 0, 0, 0}
      74                 :            :   };
      75                 :          1 :   int option_index = 0;
      76                 :            :   int option_result;
      77                 :          1 :   char *inputFileAsnName = NULL;
      78                 :          1 :   char *inputFileDerName = NULL;
      79                 :          1 :   char *typeName = NULL;
      80                 :          1 :   asn1_node definitions = NULL;
      81                 :            :   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
      82                 :          1 :   int asn1_result = ASN1_SUCCESS;
      83                 :            :   unsigned char *der;
      84                 :          1 :   int der_len = 0, benchmark = 0;
      85                 :            :   /* FILE *outputFile; */
      86                 :            : 
      87                 :          1 :   set_program_name (argv[0]);
      88                 :            : 
      89                 :          1 :   opterr = 0;                   /* disable error messages from getopt */
      90                 :            : 
      91                 :            :   while (1)
      92                 :            :     {
      93                 :            : 
      94                 :          1 :       option_result =
      95                 :            :         getopt_long (argc, argv, "hbvc", long_options, &option_index);
      96                 :            : 
      97         [ +  - ]:          1 :       if (option_result == -1)
      98                 :          1 :         break;
      99                 :            : 
     100   [ #  #  #  #  :          0 :       switch (option_result)
                      # ]
     101                 :            :         {
     102                 :            :         case 'h':               /* HELP */
     103                 :          0 :           usage (EXIT_SUCCESS);
     104                 :            :           break;
     105                 :            :         case 'b':
     106                 :          0 :           benchmark = 1;
     107                 :          0 :           break;
     108                 :            :         case 'v':               /* VERSION */
     109                 :          0 :           version_etc (stdout, program_name, PACKAGE, VERSION,
     110                 :            :                        "Fabio Fiorina", NULL);
     111                 :          0 :           exit (0);
     112                 :            :           break;
     113                 :            :         case '?':               /* UNKNOW OPTION */
     114                 :          0 :           fprintf (stderr,
     115                 :            :                    "asn1Decoding: option '%s' not recognized or without argument.\n\n",
     116                 :          0 :                    argv[optind - 1]);
     117                 :          0 :           usage (EXIT_FAILURE);
     118                 :            :           break;
     119                 :            :         default:
     120                 :          0 :           fprintf (stderr,
     121                 :            :                    "asn1Decoding: ?? getopt returned character code Ox%x ??\n",
     122                 :            :                    option_result);
     123                 :            :         }
     124                 :          0 :     }
     125                 :            : 
     126 [ +  - ][ +  - ]:          1 :   if (optind == argc || optind == argc - 1 || optind == argc - 2)
                 [ -  + ]
     127                 :            :     {
     128                 :          0 :       fprintf (stderr, "asn1Decoding: input files or ASN.1 type "
     129                 :            :                "name missing\n");
     130                 :          0 :       usage (EXIT_FAILURE);
     131                 :            :     }
     132                 :            : 
     133                 :          1 :   inputFileAsnName = (char *) malloc (strlen (argv[optind]) + 1);
     134                 :          1 :   strcpy (inputFileAsnName, argv[optind]);
     135                 :            : 
     136                 :          1 :   inputFileDerName = (char *) malloc (strlen (argv[optind + 1]) + 1);
     137                 :          1 :   strcpy (inputFileDerName, argv[optind + 1]);
     138                 :            : 
     139                 :          1 :   typeName = (char *) malloc (strlen (argv[optind + 2]) + 1);
     140                 :          1 :   strcpy (typeName, argv[optind + 2]);
     141                 :            : 
     142                 :          1 :   asn1_result =
     143                 :            :     asn1_parser2tree (inputFileAsnName, &definitions, errorDescription);
     144                 :            : 
     145   [ +  -  -  - ]:          1 :   switch (asn1_result)
     146                 :            :     {
     147                 :            :     case ASN1_SUCCESS:
     148                 :          1 :       fprintf (stderr, "Parse: done.\n");
     149                 :          1 :       break;
     150                 :            :     case ASN1_FILE_NOT_FOUND:
     151                 :          0 :       fprintf (stderr, "asn1Decoding: FILE %s NOT FOUND\n", inputFileAsnName);
     152                 :          0 :       break;
     153                 :            :     case ASN1_SYNTAX_ERROR:
     154                 :            :     case ASN1_IDENTIFIER_NOT_FOUND:
     155                 :            :     case ASN1_NAME_TOO_LONG:
     156                 :          0 :       fprintf (stderr, "asn1Decoding: %s\n", errorDescription);
     157                 :          0 :       break;
     158                 :            :     default:
     159                 :          0 :       fprintf (stderr, "libtasn1 ERROR: %s\n", asn1_strerror (asn1_result));
     160                 :            :     }
     161                 :            : 
     162         [ -  + ]:          1 :   if (asn1_result != ASN1_SUCCESS)
     163                 :            :     {
     164                 :          0 :       free (inputFileAsnName);
     165                 :          0 :       free (inputFileDerName);
     166                 :          0 :       free (typeName);
     167                 :          0 :       exit (1);
     168                 :            :     }
     169                 :            : 
     170                 :            : 
     171                 :            :   {
     172                 :            :     size_t tmplen;
     173                 :          1 :     der = (unsigned char *) read_binary_file (inputFileDerName, &tmplen);
     174                 :          1 :     der_len = tmplen;
     175                 :            :   }
     176                 :            : 
     177         [ -  + ]:          1 :   if (der == NULL)
     178                 :            :     {
     179                 :          0 :       fprintf (stderr, "asn1Decoding: could not read '%s'\n",
     180                 :            :                inputFileDerName);
     181                 :          0 :       asn1_delete_structure (&definitions);
     182                 :            : 
     183                 :          0 :       free (inputFileAsnName);
     184                 :          0 :       free (inputFileDerName);
     185                 :          0 :       free (typeName);
     186                 :          0 :       exit (1);
     187                 :            :     }
     188                 :            : 
     189                 :            : 
     190                 :            :  /*****************************************/
     191                 :            :   /* ONLY FOR TEST                         */
     192                 :            :  /*****************************************/
     193                 :            :   /*
     194                 :            :      der_len=0;
     195                 :            :      outputFile=fopen("data.p12","w");
     196                 :            :      while(fscanf(inputFile,"%c",der+der_len) != EOF){
     197                 :            :      if((der_len>=0x11) && (der_len<=(0xe70)))
     198                 :            :      fprintf(outputFile,"%c",der[der_len]);
     199                 :            :      der_len++;
     200                 :            :      }
     201                 :            :      fclose(outputFile);
     202                 :            :      fclose(inputFile);
     203                 :            :    */
     204                 :            : 
     205         [ -  + ]:          1 :   if (decode (definitions, typeName, der, der_len, benchmark) != ASN1_SUCCESS)
     206                 :            :     {
     207                 :          0 :       asn1_delete_structure (&definitions);
     208                 :          0 :       free (inputFileAsnName);
     209                 :          0 :       free (inputFileDerName);
     210                 :          0 :       free (typeName);
     211                 :          0 :       free (der);
     212                 :          0 :       exit (1);
     213                 :            :     }
     214                 :            : 
     215                 :          1 :   asn1_delete_structure (&definitions);
     216                 :            : 
     217                 :          1 :   free (der);
     218                 :            : 
     219                 :          1 :   free (inputFileAsnName);
     220                 :          1 :   free (inputFileDerName);
     221                 :          1 :   free (typeName);
     222                 :            : 
     223         [ -  + ]:          1 :   if (asn1_result != ASN1_SUCCESS)
     224                 :          0 :     exit (1);
     225                 :            : 
     226                 :          1 :   exit (0);
     227                 :            : }
     228                 :            : 
     229                 :            : static int
     230                 :          1 : simple_decode (asn1_node definitions, const char *typeName, void *der,
     231                 :            :                int der_len, int benchmark)
     232                 :            : {
     233                 :            : 
     234                 :            :   int asn1_result;
     235                 :          1 :   asn1_node structure = NULL;
     236                 :            :   char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
     237                 :            : 
     238                 :          1 :   asn1_result = asn1_create_element (definitions, typeName, &structure);
     239                 :            : 
     240                 :            :   /* asn1_print_structure(stdout,structure,"",ASN1_PRINT_ALL); */
     241                 :            : 
     242                 :            : 
     243         [ -  + ]:          1 :   if (asn1_result != ASN1_SUCCESS)
     244                 :            :     {
     245                 :          0 :       fprintf (stderr, "Structure creation: %s\n",
     246                 :            :                asn1_strerror (asn1_result));
     247                 :          0 :       asn1_delete_structure (&structure);
     248                 :          0 :       return asn1_result;
     249                 :            :     }
     250                 :            : 
     251                 :          1 :   asn1_result =
     252                 :            :     asn1_der_decoding (&structure, der, der_len, errorDescription);
     253                 :            : 
     254         [ +  - ]:          1 :   if (!benchmark)
     255                 :          1 :     fprintf (stderr, "\nDecoding: %s\n", asn1_strerror (asn1_result));
     256         [ -  + ]:          1 :   if (asn1_result != ASN1_SUCCESS)
     257                 :            :     {
     258                 :          0 :       fprintf (stderr, "asn1Decoding: %s\n", errorDescription);
     259                 :          0 :       asn1_delete_structure (&structure);
     260                 :          0 :       return asn1_result;
     261                 :            :     }
     262                 :            : 
     263         [ +  - ]:          1 :   if (!benchmark)
     264                 :            :     {
     265                 :          1 :       fprintf (stderr, "\nDECODING RESULT:\n");
     266                 :          1 :       asn1_print_structure (stdout, structure, "",
     267                 :            :                             ASN1_PRINT_NAME_TYPE_VALUE);
     268                 :            :     }
     269                 :          1 :   asn1_delete_structure (&structure);
     270                 :          1 :   return ASN1_SUCCESS;
     271                 :            : }
     272                 :            : 
     273                 :            : static int
     274                 :          1 : decode (asn1_node definitions, const char *typeName, void *der, int der_len,
     275                 :            :         int benchmark)
     276                 :            : {
     277                 :            :   struct benchmark_st st;
     278                 :            : 
     279         [ +  - ]:          1 :   if (benchmark == 0)
     280                 :          1 :     return simple_decode (definitions, typeName, der, der_len, benchmark);
     281                 :            :   else
     282                 :            :     {
     283                 :          0 :       start_benchmark (&st);
     284                 :            : 
     285                 :            :       do
     286                 :            :         {
     287                 :          0 :           simple_decode (definitions, typeName, der, der_len, benchmark);
     288                 :          0 :           st.size++;
     289                 :            :         }
     290         [ #  # ]:          0 :       while (benchmark_must_finish == 0);
     291                 :            : 
     292                 :          0 :       stop_benchmark (&st, "structures");
     293                 :          0 :       fprintf (stdout, "\n");
     294                 :            : 
     295                 :            :     }
     296                 :          1 :   return ASN1_SUCCESS;
     297                 :            : }

Generated by: LCOV version 1.9