tck_bios_fs.c

一个免费的SMART CARD OS系统。

	if (val!=10) {
		fprintf(stderr,"!!! val=%ld\n",val);
		giNumErr++;
	}
	val = 3;
	INCREASE_SUCCESS(FID_COUNTERS,0,&val);
	if (val!=13) {
		fprintf(stderr,"!!! val=%ld\n",val);
		giNumErr++;
	}
	val = 3;
	INCREASE_SUCCESS(FID_COUNTERS,0,&val);
	if (val!=16) {
		fprintf(stderr,"!!! val=%ld\n",val);
		giNumErr++;
	}
	val = 3;
	INCREASE_SUCCESS(FID_COUNTERS,0,&val);
	if (val!=19) {
		fprintf(stderr,"!!! val=%ld\n",val);
		giNumErr++;
	}

	printf("\n\tTest 3 : delete the counter file\n\n");
	DELETE_FILE_SUCCESS(FID_COUNTERS);

	__simu_save_XML_eeprom(5);
}

/* ============================================================================
    Pattern6    Test around cyclic files
   ========================================================================= */

void pattern6(void)
{
    jbyte   b_org[] = { 0xAA, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
    jbyte   b_dst[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

    printf("\n\tTest 1 : create then delete files, various lengths\n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    CREATE_RECORD_FILE_SUCCESS(0x1,1,0x20,jtrue);
    CREATE_RECORD_FILE_SUCCESS(0x2,2,0x10,jtrue);
    CREATE_RECORD_FILE_SUCCESS(0x3,3,0x30,jtrue);
    DELETE_FILE_SUCCESS(0x1);
    DELETE_FILE_SUCCESS(0x2);
    DELETE_FILE_SUCCESS(0x3);

    printf("\n\tTest 2 : create files, reusing same lengths\n\n");
    CREATE_RECORD_FILE_SUCCESS(0x1,1,0x20,jtrue);
    CREATE_RECORD_FILE_SUCCESS(0x2,2,0x10,jtrue);
    CREATE_RECORD_FILE_SUCCESS(0x3,3,0x30,jtrue);
    DELETE_FILE_SUCCESS(0x1);
    DELETE_FILE_SUCCESS(0x2);
    DELETE_FILE_SUCCESS(0x3);

    printf("\n\tTest 3 : manipulate some records\n\n");
    WRITE_RECORD_FILE_ERR(0x01,b_org,0,SET_RECORD,1,ERR_FILE_NOT_FOUND);
    CREATE_RECORD_FILE_SUCCESS(0x1,1,0x20,jtrue);
    WRITE_RECORD_FILE_ERR(0x01,b_org,0,SET_RECORD,1,ERR_RECORD_NOT_FOUND);

    b_org[0] = 0x01;
    APPEND_RECORD_FILE_SUCCESS(0x01,b_org,1);
    b_org[0] = 0x02;
    APPEND_RECORD_FILE_SUCCESS(0x01,b_org,1);

    READ_RECORD_FILE_SUCCESS(0x1,b_dst,0,SET_RECORD,1);
    b_org[0] = 0x02;
    COMPARE_ARRAY(b_org,b_dst,1);

    READ_RECORD_FILE_SUCCESS(0x1,b_dst,1,SET_RECORD,1);
    b_org[0] = 0x02;
    COMPARE_ARRAY(b_org,b_dst,1);

    READ_RECORD_FILE_ERR(0x1,b_dst,2,SET_RECORD,1,ERR_RECORD_NOT_FOUND);

    DELETE_FILE_SUCCESS(0x1);

    printf("\n\tTest 3 : manipulate more records\n\n");
    CREATE_RECORD_FILE_SUCCESS(0x2,3,0x10,jtrue);

    b_org[0] = 0x01;
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);
    b_org[0] = 0x02;
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);
    b_org[0] = 0x03;
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);
    b_org[0] = 0x04;
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);
    b_org[0] = 0x05;
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);
    b_org[0] = 0x06;
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);
    b_org[0] = 0x07;
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);
    b_org[0] = 0x08;
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);

    READ_RECORD_FILE_SUCCESS(0x2,b_dst,0,FIRST_RECORD,1);
    b_org[0] = 0x08;
    COMPARE_ARRAY(b_org,b_dst,1);

    READ_RECORD_FILE_SUCCESS(0x2,b_dst,0,NEXT_RECORD,1);
    b_org[0] = 0x07; /* __x read the spec luke ! */
    COMPARE_ARRAY(b_org,b_dst,1);

    DELETE_FILE_SUCCESS(0x2);

    __simu_save_XML_eeprom(6);
}

/* ============================================================================
    Pattern7    Test INVALIDATE/REHABILITATE
   ========================================================================= */

void pattern7(void)
{
    jbyte   b_org[] = { 0xAA, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15 };
    jbyte   b_dst[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

    printf("\n\tTest 1 : invalidate/rehabilitate - basic case \n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    DELETE_FILE_ERR(0x1,ERR_FILE_NOT_FOUND);
    CREATE_BINARY_FILE_SUCCESS(0x1,0x1);
    INVALIDATE_SUCCESS(0x1);
    UPDATE_BINARY_FILE_ERR(0x1,b_org,0,1,ERR_FILE_INVALIDATED);
    READ_BINARY_FILE_ERR(0x1,b_dst,0,1,ERR_FILE_INVALIDATED);
    REHABILITATE_SUCCESS(0x1);
    UPDATE_BINARY_FILE_SUCCESS(0x1,b_org,0,1);
    READ_BINARY_FILE_SUCCESS(0x1,b_dst,0,1);
    COMPARE_ARRAY(b_org,b_dst,1);
    DELETE_FILE_SUCCESS(0x1);

    /*

    printf("\n\tTest 2 : invalidate then delete a file \n\n");
    LOG_ENABLE("FS");
    LOG_ENABLE("STREAM");
    LOG_ENABLE("FSTOOLS");
    CREATE_BINARY_FILE_SUCCESS(0x1,0x1);
    INVALIDATE_SUCCESS(0x1);
    DELETE_FILE_SUCCESS(0x1);

    printf("\n\tTest 3 : create / delete - id = 1, length = 16 \n\n");
    DELETE_FILE_ERR(0x1,ERR_FILE_NOT_FOUND);
    CREATE_BINARY_FILE_SUCCESS(0x1,16);
    CREATE_BINARY_FILE_ERR(0x1,15,ERR_FILE_ALREADY_EXIST);
    UPDATE_BINARY_FILE_SUCCESS(0x1,b_org,0,16);
    READ_BINARY_FILE_SUCCESS(0x1,b_dst,0,16);
    COMPARE_ARRAY(b_org,b_dst,16);
    READ_BINARY_FILE_SUCCESS(0x1,b_dst,1,2);
    COMPARE_ARRAY(b_org+1,b_dst,2);
    READ_BINARY_FILE_SUCCESS(0x1,b_dst,15,1);
    COMPARE_ARRAY(b_org+15,b_dst,1);
    READ_BINARY_FILE_ERR(0x1,b_dst,15,2,ERR_INVALID_OFFSET);
    DELETE_FILE_SUCCESS(0x1);
    DELETE_FILE_ERR(0x1,ERR_FILE_NOT_FOUND);
    */

    __simu_save_XML_eeprom(7);

}

/* ============================================================================
    Pattern8    Update Once
   ========================================================================= */

void pattern8(void)
{
    jbyte   b_org[] = { 0xAA, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15 };
    jbyte   b_dst[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

    printf("\n\tTest : create update once file then update\n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    DELETE_FILE_ERR(FID_UPDATEONCE,ERR_FILE_NOT_FOUND);
    CREATE_BINARY_FILE_SUCCESS(FID_UPDATEONCE,0x1);
    CREATE_BINARY_FILE_ERR(FID_UPDATEONCE,0x1,ERR_FILE_ALREADY_EXIST);
    UPDATE_BINARY_FILE_SUCCESS(FID_UPDATEONCE,b_org,0,1);
    READ_BINARY_FILE_SUCCESS(FID_UPDATEONCE,b_dst,0,1);
    COMPARE_ARRAY(b_org,b_dst,1);
    UPDATE_BINARY_FILE_ERR(FID_UPDATEONCE,b_org,0,1,ERR_ACCESS_DENIED);
    READ_BINARY_FILE_SUCCESS(FID_UPDATEONCE,b_dst,0,1);
    COMPARE_ARRAY(b_org,b_dst,1);
    ERASE_BINARY_FILE_ERR(FID_UPDATEONCE,0,ERR_ACCESS_DENIED);
    DELETE_FILE_SUCCESS(FID_UPDATEONCE);

    printf("\n\tTest : create update once file then erase\n\n");
    DELETE_FILE_ERR(FID_UPDATEONCE,ERR_FILE_NOT_FOUND);
    CREATE_BINARY_FILE_SUCCESS(FID_UPDATEONCE,0x1);
    ERASE_BINARY_FILE_SUCCESS(FID_UPDATEONCE,0);
    ERASE_BINARY_FILE_ERR(FID_UPDATEONCE,0,ERR_ACCESS_DENIED);
    DELETE_FILE_SUCCESS(FID_UPDATEONCE);

    __simu_save_XML_eeprom(8);
}

/* ============================================================================
    Pattern9    Access Conditions
   ========================================================================= */

void pattern9(void)
{
    jbyte   b_org[] = { 0xAA, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15 };
    jbyte   b_dst[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

    printf("\n\tTest 1 : create file, DF, DF/file with default access conditions\n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    CREATE_BINARY_FILE_SUCCESS(0x01,0x1);
    UPDATE_BINARY_FILE_SUCCESS(0x01,b_org,0,1);
    READ_BINARY_FILE_SUCCESS(0x01,b_dst,0,1);
    COMPARE_ARRAY(b_org,b_dst,1);
    CREATE_DF_SUCCESS(0x11);
    CREATE_BINARY_FILE_SUCCESS(0x111,0x1);
    UPDATE_BINARY_FILE_SUCCESS(0x111,b_org,0,1);
    READ_BINARY_FILE_SUCCESS(0x111,b_dst,0,1);
    COMPARE_ARRAY(b_org,b_dst,1);

    printf("\n\tTest 2 : change to NEVER conditions (exhaustive tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    SELECT_FILE_SUCCESS(0x01);
    current_EF.ac[0] = 0x00;
    current_EF.ac[0] = 0x00;
    current_EF.ac[0] = 0x00;

    SELECT_FILE_SUCCESS(FID_MF);
    SELECT_FILE_SUCCESS(0x11);
    SELECT_FILE_SUCCESS(0x111);
    current_EF.ac[0] = 0x00;
    current_EF.ac[0] = 0x00;
    current_EF.ac[0] = 0x00;

    SELECT_FILE_SUCCESS(FID_MF);
    SELECT_FILE_SUCCESS(0x11);
    current_DF.ac[0] = 0x00;
    current_DF.ac[0] = 0x00;
    current_DF.ac[0] = 0x00;
    SELECT_FILE_ERR(0x111,ERR_ACCESS_DENIED);
    CREATE_BINARY_FILE_ERR(0x112,0x1,ERR_ACCESS_DENIED);

    printf("\n\tTest 3 : change to AUTH conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 4 : change to PIN conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 5 : change to AUTH or PIN conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 6 : change to AUTH and PIN conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 7 : change to PIN CHV2 conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 8 : change to PICOSEAL conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 9 : change to PRIOR_PIN conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 10 : change to EXT conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 11 : change to PRIOR_PIN and AUTH conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 11 : change to PRIOR_PIN or AUTH conditions (simple tests)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    printf("\n\tTest 12 : delete the files\n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    DELETE_FILE_SUCCESS(0x01);
    SELECT_FILE_SUCCESS(0x11);
    DELETE_FILE_SUCCESS(0x111);
    SELECT_FILE_SUCCESS(FID_MF);
    DELETE_FILE_ERR(0x11,ERR_INVALID_FILE_TYPE);

    __simu_save_XML_eeprom(9);
}

/* ============================================================================
	main()
   ========================================================================= */

int nPattern = 0; /* pass all the tests */

int main(int argc, char ** argv)
{
    if (argc > 1 && atoi( argv[1] ) ) {

        nPattern = atoi( argv[1] );

    }

    if (nPattern == 0) {
        printf("Start of TCK::bios::fs [ALL PATTERNS]\n\n");
    } else {
        printf("Start of TCK::bios::fs [PATTERN %d]\n\n",nPattern);
    }
    giNumErr = 0;

	LOG_DISABLE("HAL");
	LOG_DISABLE("LOCK");
	LOG_DISABLE("BIOS");
	LOG_DISABLE("EEPROM");
	LOG_DISABLE("CRYPTO");
	LOG_DISABLE("TAGLIFE");
	LOG_DISABLE("STREAM");
    LOG_DISABLE("ERROR");
	LOG_DISABLE("SEQVAL");
    LOG_DISABLE("FS");
    LOG_DISABLE("RECORD");
    LOG_DISABLE("ACL");
    LOG_DISABLE("FSTOOLS");
    LOG_DISABLE("simuXML");
    LOG_DISABLE("TRANSACTION");
    LOG_DISABLE("INTROSPECTION");
    LOG_DISABLE("COUNTERS");

	LOG_DISABLE("TCK");

	/* init all the required sub-systems */
	printf("\n---[ Init ]--------------------------------------\n");
	LOG_DISABLE("TCK");
	__simu_blank_eeprom();
	BIOS_SETERR(NOERR);
	BIOS_INIT();
	BIOS_INIT_TAGLIFE();
	FS_MOUNT_MF();

	/* bootstrap the filesystem / create the MF */
	printf("\n---[ Bootstrap ]---------------------------------\n");
	LOG_DISABLE("TCK");
	boostrap_filesystem();
	FS_MOUNT_MF();
	BIOS_TRANS_COMMIT();

	/* pattern #1 */
    if ((nPattern == 0) || (nPattern == 1)) {
        printf("\n---[ Pattern #1 BASIC TESTS]---------------------\n");
        LOG_ENABLE("TCK");
        pattern1();
    }

	/* pattern #2*/
    if ((nPattern == 0) || (nPattern == 2)) {
        printf("\n---[ Pattern #2 CREATE/DELETE FILES]-------------\n");
        LOG_ENABLE("TCK");
        pattern2();
    }

	/* pattern #3*/
    if ((nPattern == 0) || (nPattern == 3)) {
        printf("\n---[ Pattern #3 TLV]-----------------------------\n");
        LOG_ENABLE("TCK");
        pattern3();
    }

	/* pattern #4*/
    if ((nPattern == 0) || (nPattern == 4)) {
        printf("\n---[ Pattern #4 LINEAR FILES]--------------------\n");
        LOG_ENABLE("TCK");
        pattern4();
    }

    /* pattern #5*/
    if ((nPattern == 0) || (nPattern == 5)) {
        printf("\n---[ Pattern #5 COUNTERS]------------------------\n");
        LOG_ENABLE("TCK");
        pattern5();
    }

    /* pattern #6*/
    if ((nPattern == 0) || (nPattern == 6)) {
        printf("\n---[ Pattern #6 CYCLIC FILES]--------------------\n");
        LOG_ENABLE("TCK");
        pattern6();
    }

    /* pattern #7*/
    if ((nPattern == 0) || (nPattern == 7)) {
        printf("\n---[ Pattern #7 INVALIDATE/REHABBILITATE]--------\n");
        LOG_ENABLE("TCK");
        pattern7();
    }

    /* pattern #8*/
    if ((nPattern == 0) || (nPattern == 8)) {
        printf("\n---[ Pattern #8 UPDATE ONCE)---------------------\n");
        LOG_ENABLE("TCK");
        pattern8();
    }

    /* pattern #9*/
    if ((nPattern == 0) || (nPattern == 9)) {
        printf("\n---[ Pattern #9 ACCESS CONDITIONS]---------------\n");
        LOG_ENABLE("TCK");
        pattern9();
    }

    printf("\nEnd of TCK::bios::fs with %ld error(s)\n",giNumErr);
	return giNumErr;
}