MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/ssl/tsrc/crypto_test/src/crypto_testBlocks.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     3 

     4 * Redistribution and use in source and binary forms, with or without 

     5 * modification, are permitted provided that the following conditions are met:

     6 

     7 * Redistributions of source code must retain the above copyright notice, this 

     8 * list of conditions and the following disclaimer.

     9 * Redistributions in binary form must reproduce the above copyright notice, 

    10 * this list of conditions and the following disclaimer in the documentation 

    11 * and/or other materials provided with the distribution.

    12 * Neither the name of Nokia Corporation nor the names of its contributors 

    13 * may be used to endorse or promote products derived from this software 

    14 * without specific prior written permission.

    15 

    16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 

    17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 

    18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 

    19 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 

    20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 

    21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 

    22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 

    23 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 

    24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 

    25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    26 *

    27 * Description:  ?Description

    28 *

    29 */

    30 

    31 

    32 

    33 // INCLUDE FILES

    34 #include <e32svr.h>

    35 #include <StifParser.h>

    36 #include <Stiftestinterface.h>

    37 #include "crypto_test.h"

    38 #include "tcrypto_test.h"

    39 #include <stdio.h>

    40 #include <string.h>

    41 #include  <stdlib.h>

    42 #include <errno.h>

    43 // EXTERNAL DATA STRUCTURES

    44 //extern  ?external_data;

    45 

    46 // EXTERNAL FUNCTION PROTOTYPES  

    47 //extern ?external_function( ?arg_type,?arg_type );

    48 

    49 // CONSTANTS

    50 //const ?type ?constant_var = ?constant;

    51 

    52 // MACROS

    53 //#define ?macro ?macro_def

    54 

    55 // LOCAL CONSTANTS AND MACROS

    56 //const ?type ?constant_var = ?constant;

    57 //#define ?macro_name ?macro_def

    58 

    59 // MODULE DATA STRUCTURES

    60 //enum ?declaration

    61 //typedef ?declaration

    62 

    63 // LOCAL FUNCTION PROTOTYPES

    64 //?type ?function_name( ?arg_type, ?arg_type );

    65 

    66 // FORWARD DECLARATIONS

    67 //class ?FORWARD_CLASSNAME;

    68 

    69 // ============================= LOCAL FUNCTIONS ===============================

    70 

    71 // -----------------------------------------------------------------------------

    72 // ?function_name ?description.

    73 // ?description

    74 // Returns: ?value_1: ?description

    75 //          ?value_n: ?description_line1

    76 //                    ?description_line2

    77 // -----------------------------------------------------------------------------

    78 //

    79 /*

    80 ?type ?function_name(

    81     ?arg_type arg,  // ?description

    82     ?arg_type arg)  // ?description

    83     {

    84 

    85     ?code  // ?comment

    86 

    87     // ?comment

    88     ?code

    89     }

    90 */

    91 

    92 // ============================ MEMBER FUNCTIONS ===============================

    93 

    94 // -----------------------------------------------------------------------------

    95 // Ccrypto_test::Delete

    96 // Delete here all resources allocated and opened from test methods. 

    97 // Called from destructor. 

    98 // -----------------------------------------------------------------------------

    99 //

   100 void Ccrypto_test::Delete() 

   101     {

   102 

   103     }

   104 

   105 // -----------------------------------------------------------------------------

   106 // Ccrypto_test::RunMethodL

   107 // Run specified method. Contains also table of test mothods and their names.

   108 // -----------------------------------------------------------------------------

   109 //

   110 TInt Ccrypto_test::RunMethodL( 

   111     CStifItemParser& aItem ) 

   112     {

   113 

   114     static TStifFunctionInfo const KFunctions[] =

   115         {  

   116         // Copy this line for every implemented function.

   117         // First string is the function name used in TestScripter script file.

   118         // Second is the actual implementation member function. 

   119         ENTRY( "BNTest", Ccrypto_test::BnTest ),

   120         ENTRY( "DESTest", Ccrypto_test::DesTest ),

   121         ENTRY( "DHTest", Ccrypto_test::DhTest ),

   122         ENTRY( "DSATest", Ccrypto_test::DsaTest ),

   123         ENTRY( "ENGINETest", Ccrypto_test::EngineTest ),

   124         ENTRY( "EVPTest", Ccrypto_test::EvpTest ),

   125         ENTRY( "EXPTest", Ccrypto_test::ExpTest ),

   126         ENTRY( "HMACTest", Ccrypto_test::HmacTest ),

   127         ENTRY( "MD2Test", Ccrypto_test::Md2Test ),

   128         ENTRY( "MD5Test", Ccrypto_test::Md5Test ),

   129         ENTRY( "RANDTest", Ccrypto_test::RandTest ),

   130         ENTRY( "RC2Test", Ccrypto_test::Rc2Test ),

   131         ENTRY( "RC4Test", Ccrypto_test::Rc4Test ),

   132         ENTRY( "RSATest", Ccrypto_test::RsaTest ),

   133         ENTRY( "SHATest", Ccrypto_test::ShaTest ),

   134         ENTRY( "SHA1Test", Ccrypto_test::Sha1Test ),

   135 		ENTRY( "SHA256Test", Ccrypto_test::Sha256Test ),

   136 		ENTRY( "SHA512Test", Ccrypto_test::Sha512Test ),

   137 

   138         };

   139 

   140     const TInt count = sizeof( KFunctions ) / 

   141                         sizeof( TStifFunctionInfo );

   142 

   143     return RunInternalL( KFunctions, count, aItem );

   144 

   145     }

   146     

   147 #ifdef __cplusplus

   148 extern "C"

   149 {

   150 #endif	

   151     

   152 FILE *fp_stdout=NULL;

   153 FILE *fp_stderr=NULL;

   154 

   155 #ifdef __cplusplus

   156 }

   157 #endif

   158 int cryptotest_init(char *mod)

   159 {

   160     char str[200];

   161     int len=0;

   162     if(!mod)

   163     return 1;

   164     len=strlen(LOG_STDOUT);

   165     strcpy(str,LOG_STDOUT);

   166     strcat(str,"_");

   167     strcat(str,mod);

   168     len+=strlen(mod);

   169     str[len+1]='\0';

   170 	fp_stdout = fopen(str,"a+b");

   171 	if(!fp_stdout)

   172 	return 1;

   173 	fp_stderr=fp_stdout;

   174 	return 0;

   175 }

   176 

   177 void cryptotest_deinit(void)

   178 {

   179     fclose(fp_stdout);

   180     fp_stderr=NULL;

   181     fp_stdout=NULL;

   182 }

   183 char ** MakeArgs(CStifItemParser& aItem,int * argc)

   184 {

   185 	char *ini_cmd[256];

   186 	char **cmd_line;

   187 	   

   188 	TInt len=0;

   189 	TPtrC string;

   190     TBuf8<50> buf1;

   191 	char* argument;

   192 	int cnt=0;

   193 	int i;

   194 	

   195 	//parse through the parameters of cfg to find the number and strings of cmd line

   196 		

   197 	while(aItem.GetNextString(string)!=-1)

   198 	{

   199 		buf1.Copy(string);

   200 		argument=(char *)buf1.Ptr();

   201 		len=buf1.Length();

   202 		argument[len]='\0';

   203 		

   204 		ini_cmd[cnt]=(char *)malloc(sizeof(char)*len+1);

   205 		if(ini_cmd[cnt]==NULL)

   206 		{

   207 			for(i=0;i<cnt;i++)

   208 			{

   209 				if(ini_cmd[i])

   210 			  free(ini_cmd[i]);

   211 		  }

   212 			return NULL;

   213 		}	

   214 		strcpy(ini_cmd[cnt],(const char *)argument);

   215 		

   216 		cnt++;

   217 	}

   218 	

   219 	//allocate memory for the command line ragged array

   220 	

   221 	cmd_line=(char **)malloc(cnt*sizeof(char *));

   222 	if(cmd_line==NULL)

   223 	{

   224 		for(i=0;i<cnt;i++)

   225   	   {

   226 	  	if(ini_cmd[i])

   227 		  free(ini_cmd[i]);

   228 	   }

   229     return NULL;

   230 	}	

   231 	

   232 	//initialize the array

   233 	

   234 	for(i=0;i<cnt;i++) cmd_line[i]=ini_cmd[i];

   235 	

   236 	//initialize argc

   237 	

   238 	*argc=cnt;

   239 	

   240 	return cmd_line;

   241 	

   242 }

   243 //-----------------------------------------------------------------------------

   244 //function function for destroying argv

   245 //-----------------------------------------------------------------------------

   246 void DeleteArgs(char ** cmd_line,int argc)

   247 {

   248 	int i;

   249 	for(i=0;i<argc;i++) free(cmd_line[i]);

   250 	

   251 	free(cmd_line);

   252 }

   253 

   254 

   255 // -----------------------------------------------------------------------------

   256 // Ccrypto_test::ExampleL

   257 // Example test method function.

   258 // (other items were commented in a header).

   259 // -----------------------------------------------------------------------------

   260 //

   261 

   262 

   263 TInt Ccrypto_test::BnTest( CStifItemParser&/* aItem*/ )

   264     {

   265     TInt ret=1;

   266     

   267     

   268     if(!cryptotest_init("bn"))

   269     {

   270      ret = bn_main(0,NULL);

   271      cryptotest_deinit();

   272 

   273     }

   274     if(ret==1&&errno==ENOMEM)

   275     {

   276     	return KErrNoMemory;

   277     }

   278     return ret;

   279 

   280     }

   281 

   282 

   283 

   284 TInt Ccrypto_test::DesTest( CStifItemParser&/* aItem*/ )

   285     {

   286     TInt ret=1;

   287     

   288     

   289     if(!cryptotest_init("des"))

   290     {

   291     ret = des_main(0,NULL);

   292     cryptotest_deinit();

   293 	

   294     }

   295     if(ret==1&&errno==ENOMEM)

   296     {

   297     	return KErrNoMemory;

   298     }

   299     return ret;

   300 

   301     return ret;

   302 

   303     }

   304     

   305     

   306 TInt Ccrypto_test::DhTest( CStifItemParser&/* aItem*/ )

   307     {

   308     TInt ret=1;

   309     

   310       

   311     if(!cryptotest_init("dh"))

   312     {

   313     ret = dh_main(0,NULL);

   314     cryptotest_deinit();

   315     }

   316     if(ret==1&&errno==ENOMEM)

   317     {

   318     	return KErrNoMemory;

   319     }

   320     return ret;

   321 

   322     }    

   323     

   324 TInt Ccrypto_test::DsaTest( CStifItemParser&/* aItem*/ )

   325     {

   326     TInt ret=1;

   327     if(!cryptotest_init("dsa"))

   328     {

   329     ret = dsa_main(0,NULL);

   330     cryptotest_deinit();

   331     

   332     }

   333     if(ret==1&&errno==ENOMEM)

   334     {

   335     	return KErrNoMemory;

   336     }

   337     return ret;

   338     

   339 

   340     }      

   341     

   342     

   343 TInt Ccrypto_test::EngineTest( CStifItemParser&/* aItem*/ )

   344     {

   345     TInt ret=1;

   346     

   347     if(!cryptotest_init("eng"))

   348     {

   349     ret = engine_main(0,NULL);

   350     cryptotest_deinit();

   351     	

   352     }

   353     if(ret==1&&errno==ENOMEM)

   354     {

   355     	return KErrNoMemory;

   356     }

   357     return ret;

   358 

   359     }      

   360     

   361 TInt Ccrypto_test::EvpTest( CStifItemParser& aItem )

   362     {

   363     TInt ret=1;

   364     int argc=0;

   365     char** argv=NULL;

   366 

   367     argv = MakeArgs(aItem,&argc);

   368     if(!argv)

   369     {

   370       return KErrNoMemory;    

   371     }	

   372     if(!cryptotest_init("evp"))

   373     {

   374     ret = evp_main(argc,argv);

   375     cryptotest_deinit();

   376     

   377     }

   378     DeleteArgs(argv,argc);

   379     if(ret==1&&errno==ENOMEM)

   380     {

   381     	return KErrNoMemory;

   382     }

   383     return ret;

   384     }     

   385     

   386     

   387     

   388 TInt Ccrypto_test::ExpTest( CStifItemParser& /*aItem */)

   389     {

   390     TInt ret=1;

   391     

   392     if(!cryptotest_init("exp"))

   393     {

   394     ret = exp_main(0,NULL);

   395     cryptotest_deinit();

   396    

   397     }

   398    if(ret==1&&errno==ENOMEM)

   399     {

   400     	return KErrNoMemory;

   401     }

   402     return ret;

   403 

   404     }          

   405 TInt Ccrypto_test::HmacTest( CStifItemParser& /*aItem */)

   406     {

   407     TInt ret=1;

   408     

   409     if(!cryptotest_init("hmac"))

   410     {

   411     ret = hmac_main(0,NULL);

   412     cryptotest_deinit();

   413     	

   414     }

   415     if(ret==1&&errno==ENOMEM)

   416     {

   417     	return KErrNoMemory;

   418     }

   419     return ret;

   420 

   421     }     

   422 

   423              

   424 TInt Ccrypto_test::Md2Test( CStifItemParser& /*aItem */)

   425     {

   426     TInt ret=1;

   427     

   428     if(!cryptotest_init("md2"))

   429     {

   430     ret = md2_main(0,NULL);

   431     cryptotest_deinit();

   432     	

   433     }

   434     if(ret==1&&errno==ENOMEM)

   435     {

   436     	return KErrNoMemory;

   437     }

   438     return ret;

   439 

   440     }   

   441 TInt Ccrypto_test::Md5Test( CStifItemParser& /*aItem */)

   442     {

   443     TInt ret=1;

   444 

   445     if(!cryptotest_init("md5"))

   446     {

   447     ret = md5_main(0,NULL);

   448     cryptotest_deinit();

   449     	

   450     }

   451     if(ret==1&&errno==ENOMEM)

   452     {

   453     	return KErrNoMemory;

   454     }

   455     return ret;

   456 

   457     }   

   458 TInt Ccrypto_test::RandTest( CStifItemParser& /*aItem */)

   459     {

   460     TInt ret=1;

   461 

   462     if(!cryptotest_init("rand"))

   463     {

   464     ret = rand_main(0,NULL);

   465     cryptotest_deinit();

   466     	

   467     }

   468     if(ret==1&&errno==ENOMEM)

   469     {

   470     	return KErrNoMemory;

   471     }

   472     return ret;

   473 

   474     }      

   475     

   476     

   477 TInt Ccrypto_test::Rc2Test( CStifItemParser& /*aItem */)

   478     {

   479     TInt ret=1;

   480 

   481     if(!cryptotest_init("rc2"))

   482     {

   483     ret = rc2_main(0,NULL);

   484     cryptotest_deinit();

   485     	

   486     }

   487 

   488     if(ret==1&&errno==ENOMEM)

   489     {

   490     	return KErrNoMemory;

   491     }

   492     return ret;

   493 

   494     }      

   495     

   496 TInt Ccrypto_test::Rc4Test( CStifItemParser& /*aItem */)

   497     {

   498     TInt ret=1;

   499 

   500     if(!cryptotest_init("rc4"))

   501     {

   502     ret = rc4_main(0,NULL);

   503     cryptotest_deinit();

   504     	

   505     }

   506 

   507     if(ret==1&&errno==ENOMEM)

   508     {

   509     	return KErrNoMemory;

   510     }

   511     return ret;

   512 

   513     }     

   514 

   515 TInt Ccrypto_test::RsaTest( CStifItemParser& /*aItem */)

   516     {

   517     TInt ret=1;

   518 

   519     if(!cryptotest_init("rsa"))

   520     {

   521     ret = rsa_main(0,NULL);

   522     cryptotest_deinit();

   523     	

   524     }

   525 

   526     if(ret==1&&errno==ENOMEM)

   527     {

   528     	return KErrNoMemory;

   529     }

   530     return ret;

   531 

   532     }      

   533     

   534 TInt Ccrypto_test::ShaTest( CStifItemParser& /*aItem */)

   535     {

   536     TInt ret=1;

   537 

   538     if(!cryptotest_init("sha"))

   539     {

   540     ret = sha_main(0,NULL);

   541     cryptotest_deinit();

   542     	

   543     }

   544 

   545     if(ret==1&&errno==ENOMEM)

   546     {

   547     	return KErrNoMemory;

   548     }

   549     return ret;

   550 

   551     }     

   552 

   553 TInt Ccrypto_test::Sha1Test( CStifItemParser& /*aItem */)

   554     {

   555     TInt ret=1;

   556 

   557     if(!cryptotest_init("sha1"))

   558     {

   559     ret = sha1_main(0,NULL);

   560     cryptotest_deinit();

   561     	

   562     }

   563 

   564     if(ret==1&&errno==ENOMEM)

   565     {

   566     	return KErrNoMemory;

   567     }

   568     return ret;

   569 

   570     }                                         

   571     

   572 TInt Ccrypto_test::Sha256Test( CStifItemParser& /*aItem */)

   573     {

   574     TInt ret=1;

   575 

   576     if(!cryptotest_init("sha256"))

   577     {

   578     ret = sha256_main(0,NULL);

   579     cryptotest_deinit();

   580     	

   581     }

   582 

   583     if(ret==1&&errno==ENOMEM)

   584     {

   585     	return KErrNoMemory;

   586     }

   587     return ret;

   588 

   589     }       

   590     

   591 TInt Ccrypto_test::Sha512Test( CStifItemParser& /*aItem */)

   592     {

   593     TInt ret=1;

   594 

   595     if(!cryptotest_init("sha512"))

   596     {

   597     ret = sha512_main(0,NULL);

   598     cryptotest_deinit();

   599     	

   600     }

   601 

   602     if(ret==1&&errno==ENOMEM)

   603     {

   604     	return KErrNoMemory;

   605     }

   606     return ret;

   607 

   608     }   

   609 

   610                                        

   611 // -----------------------------------------------------------------------------

   612 // Ccrypto_test::?member_function

   613 // ?implementation_description

   614 // (other items were commented in a header).

   615 // -----------------------------------------------------------------------------

   616 //

   617 /*

   618 TInt Ccrypto_test::?member_function(

   619    CItemParser& aItem )

   620    {

   621 

   622    ?code

   623 

   624    }

   625 */

   626 

   627 // ========================== OTHER EXPORTED FUNCTIONS =========================

   628 // None

   629 

   630 //  End of File
Symaptic