tck_bios_fs.c

一个免费的SMART CARD OS系统。

	/* decrease */
	*val = BIOS_DEC_COUNTER(counter,*val);
	if (lasterr!=NOERR) return lasterr;

	/* commit the new value */
	BIOS_TRANS_COMMIT();
	if (lasterr!=NOERR) return lasterr;

	return lasterr;
}

void DECREASE_SUCCESS(jword id,jbyte counter,jdword* val)
{
	jbyte	err;

	LOG3("TCK","DECREASE (9000) id=%.4X counter=%d val=%ld",id,counter,*val);
	err = decrease(id,counter,val);
	if (err != SUCCESS) {
		fprintf(stderr,"decrease(%.4X,%d,%ld): nok: error code %d\n",id,counter,*val,err);
		giNumErr++;
	}

}

void DECREASE_ERR(jword id,jbyte counter,jdword* val, jbyte _err)
{
	jbyte	err;

	LOG4("TCK","DECREASE (%.4X) id=%.4X counter=%d val=%ld",isoerr(_err),id,counter,*val);
	err = decrease(id,counter,val);
	if (err != _err) {
		fprintf(stderr,"decrease(%.4X,%d,%ld): nok: error code %d but %d was required\n",id,counter,*val,err,_err);
		giNumErr++;
	}
}

/* ============================================================================
    Invalidate a file

    Returns lasterr error code or SUCCESS
   ========================================================================= */

jbyte invalidate(jword id)
{
    BIOS_SETERR(NOERR);

    FS_LOOKUP_FID(id,LOOKUP_MODE_EF_ONLY);
    if (lasterr!=SUCCESS) return lasterr;

    /* invalidate */
    FS_INVALIDATE();

    return lasterr;
}

void INVALIDATE_SUCCESS(jword id)
{
    jbyte   err;

    LOG1("TCK","INVALIDATE (9000) id=%.4X ",id);
    err = invalidate(id);
    if (err != SUCCESS) {
        fprintf(stderr,"invalidate(%.4X): nok: error code %d\n",id,err);
        giNumErr++;
    }

}

void INVALIDATE_ERR(jword id,jbyte _err)
{
    jbyte   err;

    LOG2("TCK","INVALIDATE (%.4X) id=%.4X ",isoerr(_err),id);
    err = invalidate(id);
    if (err != _err) {
        fprintf(stderr,"invalidate(%.4X): nok: error code %d but %d was required\n",id,err,_err);
        giNumErr++;
    }
}

/* ============================================================================
    Rehabilitate a file

    Returns lasterr error code or SUCCESS
   ========================================================================= */

jbyte rehabilitate(jword id)
{
    BIOS_SETERR(NOERR);

    FS_LOOKUP_FID(id,LOOKUP_MODE_EF_ONLY);
    if (lasterr!=SUCCESS) return lasterr;

    /* rehabilitate */
    FS_REHABILITATE();

    return lasterr;
}

void REHABILITATE_SUCCESS(jword id)
{
    jbyte   err;

    LOG1("TCK","REHABILITATE (9000) id=%.4X ",id);
    err = rehabilitate(id);
    if (err != SUCCESS) {
        fprintf(stderr,"rehabilitate(%.4X): nok: error code %d\n",id,err);
        giNumErr++;
    }

}

void REHABILITATE_ERR(jword id,jbyte _err)
{
    jbyte   err;

    LOG2("TCK","REHABILITATE (%.4X) id=%.4X ",isoerr(_err),id);
    err = rehabilitate(id);
    if (err != _err) {
        fprintf(stderr,"rehabilitate(%.4X): nok: error code %d but %d was required\n",id,err,_err);
        giNumErr++;
    }
}

/* ============================================================================
	Compare array of bytes
   ========================================================================= */

void COMPARE_ARRAY(jbyte* b1,jbyte* b2,jword len)
{
	jbool	bDiff = jfalse;
	jword	i;

	for (i=0; i<len; i++) {
		if (b1[i]!=b2[i]) bDiff = jtrue;
	}

	if (bDiff) {
		fprintf(stderr,"array are different : ");
		fprintf(stderr,"\narray1 : ");
		for (i=0;i<len;i++) { fprintf(stderr,"%.2X ",b1[i]); }
		fprintf(stderr,"\narray2 : ");
		for (i=0;i<len;i++) { fprintf(stderr,"%.2X ",b2[i]); }
		fprintf(stderr,"\n");
		giNumErr++;
	}
}

/* ============================================================================
	Pattern1	Very basic tests
   ========================================================================= */

void pattern1(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 - id = 1, various lengths\n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    DELETE_FILE_ERR(0x1,ERR_FILE_NOT_FOUND);
	CREATE_BINARY_FILE_ERR(0x1,0x0,ERR_INVALID_LENGTH);
	CREATE_BINARY_FILE_ERR(0x1,0xFFFF,ERR_INVALID_LENGTH);
	CREATE_BINARY_FILE_ERR(0x1,SIZE_EEPROM,ERR_INVALID_LENGTH);
	CREATE_BINARY_FILE_ERR(0x1,SIZE_EEPROM-1,ERR_OUT_OF_MEMORY);

	printf("\n\tTest 2 : create / delete - id = 1, length = 1 \n\n");
	DELETE_FILE_ERR(0x1,ERR_FILE_NOT_FOUND);
	CREATE_BINARY_FILE_SUCCESS(0x1,0x1);
	CREATE_BINARY_FILE_ERR(0x1,0x1,ERR_FILE_ALREADY_EXIST);
	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);
    ERASE_BINARY_FILE_SUCCESS(0x1,0);
    DELETE_FILE_SUCCESS(0x1);
	DELETE_FILE_ERR(0x1,ERR_FILE_NOT_FOUND);

	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(1);
}

/* ============================================================================
	Pattern2	Test around create / deletion of multiple files
   ========================================================================= */

void pattern2(void)
{
	printf("\n\tTest 1 : create then delete files, various lengths\n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    CREATE_BINARY_FILE_SUCCESS(0x1,0x20);
	CREATE_BINARY_FILE_SUCCESS(0x2,0x10);
	CREATE_BINARY_FILE_SUCCESS(0x3,0x30);
	DELETE_FILE_SUCCESS(0x1);
	DELETE_FILE_SUCCESS(0x2);
	DELETE_FILE_SUCCESS(0x3);

	printf("\n\tTest 2 : create files, reusing various lengths\n\n");
	CREATE_BINARY_FILE_SUCCESS(0x1,0x20);
	CREATE_BINARY_FILE_SUCCESS(0x2,0x10);
	CREATE_BINARY_FILE_SUCCESS(0x3,0x30);
	DELETE_FILE_SUCCESS(0x1);
	DELETE_FILE_SUCCESS(0x2);
	DELETE_FILE_SUCCESS(0x3);

	printf("\n\tTest 3 : create files, reusing various minus lengths\n\n");
	CREATE_BINARY_FILE_SUCCESS(0x1,0x1F);
	CREATE_BINARY_FILE_SUCCESS(0x2,0x0F);
	CREATE_BINARY_FILE_SUCCESS(0x3,0x2F);
	DELETE_FILE_SUCCESS(0x1);
	DELETE_FILE_SUCCESS(0x2);
	DELETE_FILE_SUCCESS(0x3);

    printf("\n\tTest 4 : create files, reusing various lengths\n\n");
	CREATE_BINARY_FILE_SUCCESS(0x1,0x20);
	CREATE_BINARY_FILE_SUCCESS(0x2,0x10);
	CREATE_BINARY_FILE_SUCCESS(0x3,0x30);
	DELETE_FILE_SUCCESS(0x1);
	DELETE_FILE_SUCCESS(0x2);
	DELETE_FILE_SUCCESS(0x3);

    printf("\n\tTest 5 : create DF then files, reusing various lengths\n\n");
    CREATE_DF_SUCCESS(0x101);
    CREATE_BINARY_FILE_SUCCESS(0x1,0x20);
    CREATE_BINARY_FILE_SUCCESS(0x2,0x10);
    CREATE_BINARY_FILE_SUCCESS(0x3,0x30);
    DELETE_FILE_SUCCESS(0x1);
    DELETE_FILE_SUCCESS(0x2);
    DELETE_FILE_SUCCESS(0x3);
    SELECT_FILE_SUCCESS(0x101);
    DELETE_FILE_ERR(0x101,ERR_INVALID_FILE_TYPE);

    printf("\n\tTest 6 : create DF then files / some bogus \n\n");
    CREATE_DF_SUCCESS(0x102);
    CREATE_BINARY_FILE_SUCCESS(0x1,0x20);
    CREATE_BINARY_FILE_ERR(0x102,0x20,ERR_INVALID_FID);

	__simu_save_XML_eeprom(2);
}

/* ============================================================================
	Pattern3	Test around TLV in files
   ========================================================================= */

void pattern3(void)
{
    printf("\n\tTest 1 : ...\n\n");
    SELECT_FILE_SUCCESS(FID_MF);

    __simu_save_XML_eeprom(3);
}

/* ============================================================================
	Pattern4	Test around linear files
   ========================================================================= */

void pattern4(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,jfalse);
    CREATE_RECORD_FILE_SUCCESS(0x2,2,0x10,jfalse);
    CREATE_RECORD_FILE_SUCCESS(0x3,3,0x30,jfalse);
    CREATE_RECORD_FILE_ERR(0x4,0,0x30,jfalse,ERR_INVALID_PARAMETER);
    CREATE_RECORD_FILE_ERR(0x5,5,0,jfalse,ERR_INVALID_PARAMETER);
    CREATE_RECORD_FILE_ERR(0x6,0,0,jfalse,ERR_INVALID_PARAMETER);
    CREATE_RECORD_FILE_ERR(0x7,0xFF,0x30,jfalse,ERR_INVALID_PARAMETER);
    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,jfalse);
    CREATE_RECORD_FILE_SUCCESS(0x2,2,0x10,jfalse);
    CREATE_RECORD_FILE_SUCCESS(0x3,3,0x30,jfalse);
    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,jfalse);
    WRITE_RECORD_FILE_ERR(0x01,b_org,0,SET_RECORD,1,ERR_RECORD_NOT_FOUND);
    APPEND_RECORD_FILE_SUCCESS(0x01,b_org,1);
    APPEND_RECORD_FILE_ERR(0x01,b_org,1,ERR_OUT_OF_MEMORY);
    WRITE_RECORD_FILE_SUCCESS(0x01,b_org,0,SET_RECORD,1);   /* write default record */
    WRITE_RECORD_FILE_SUCCESS(0x01,b_org,1,SET_RECORD,1);   /* write explicit record 1 */

    WRITE_RECORD_FILE_ERR(0x02,b_org,0,SET_RECORD,0x10,ERR_FILE_NOT_FOUND);
    CREATE_RECORD_FILE_SUCCESS(0x2,2,0x10,jfalse);
    WRITE_RECORD_FILE_ERR(0x02,b_org,0,SET_RECORD,0x10,ERR_RECORD_NOT_FOUND);
    APPEND_RECORD_FILE_ERR(0x02,b_org,0x11,ERR_INVALID_LENGTH);
    APPEND_RECORD_FILE_ERR(0x02,b_org,0x00,ERR_INVALID_LENGTH);
    APPEND_RECORD_FILE_SUCCESS(0x02,b_org,0x10);
    READ_RECORD_FILE_ERR(0x02,b_dst,2,SET_RECORD,0x10,ERR_RECORD_NOT_FOUND);
    READ_RECORD_FILE_SUCCESS(0x02,b_dst,1,SET_RECORD,0x10);
    COMPARE_ARRAY(b_org,b_dst,0x10);
    READ_RECORD_FILE_ERR(0x02,b_dst,0,SET_RECORD,0x11,ERR_INVALID_LENGTH);
    READ_RECORD_FILE_ERR(0x02,b_dst,0,SET_RECORD,0x00,ERR_INVALID_LENGTH);
    READ_RECORD_FILE_SUCCESS(0x02,b_dst,0,SET_RECORD,0x10);
    COMPARE_ARRAY(b_org,b_dst,0x10);
    DELETE_FILE_SUCCESS(0x1);
    DELETE_FILE_SUCCESS(0x2);

    printf("\n\tTest 4 : move through records\n\n");
    CREATE_RECORD_FILE_SUCCESS(0x3,5,0x10,jfalse);      /* 5 records ! */
    APPEND_RECORD_FILE_SUCCESS(0x3,b_org,0x10);
    APPEND_RECORD_FILE_SUCCESS(0x3,b_org,0x10);
    APPEND_RECORD_FILE_SUCCESS(0x3,b_org,0x10);
    APPEND_RECORD_FILE_SUCCESS(0x3,b_org,0x10);
    APPEND_RECORD_FILE_SUCCESS(0x3,b_org,0x10);
    APPEND_RECORD_FILE_ERR(0x3,b_org,0x10,ERR_OUT_OF_MEMORY);
    b_org[0] = 0x01;
    WRITE_RECORD_FILE_SUCCESS(0x3,b_org,1,SET_RECORD,1);
    b_org[0] = 0x02;
    WRITE_RECORD_FILE_SUCCESS(0x3,b_org,0,NEXT_RECORD,1);
    b_org[0] = 0x03;
    WRITE_RECORD_FILE_SUCCESS(0x3,b_org,0,NEXT_RECORD,1);
    b_org[0] = 0x04;
    WRITE_RECORD_FILE_SUCCESS(0x3,b_org,0,NEXT_RECORD,1);
    b_org[0] = 0x05;
    WRITE_RECORD_FILE_SUCCESS(0x3,b_org,0,NEXT_RECORD,1);
    b_org[0] = 0x06;
    WRITE_RECORD_FILE_ERR(0x3,b_org,0,NEXT_RECORD,1,ERR_RECORD_NOT_FOUND);

    READ_RECORD_FILE_SUCCESS(0x3,b_dst,0,LAST_RECORD,5);
    b_org[0] = 0x05;
    COMPARE_ARRAY(b_org,b_dst,1);
    READ_RECORD_FILE_SUCCESS(0x3,b_dst,0,PREV_RECORD,5);
    b_org[0] = 0x04;
    COMPARE_ARRAY(b_org,b_dst,1);
    READ_RECORD_FILE_SUCCESS(0x3,b_dst,0,PREV_RECORD,5);
    b_org[0] = 0x03;
    COMPARE_ARRAY(b_org,b_dst,1);
    READ_RECORD_FILE_SUCCESS(0x3,b_dst,0,PREV_RECORD,5);
    b_org[0] = 0x02;
    COMPARE_ARRAY(b_org,b_dst,1);
    READ_RECORD_FILE_SUCCESS(0x3,b_dst,0,PREV_RECORD,5);
    b_org[0] = 0x01;
    COMPARE_ARRAY(b_org,b_dst,1);
    READ_RECORD_FILE_ERR(0x3,b_dst,0,PREV_RECORD,5,ERR_RECORD_NOT_FOUND);

    DELETE_FILE_SUCCESS(0x3);

    __simu_save_XML_eeprom(4);
}

/* ============================================================================
	Pattern5	Test around counters
   ========================================================================= */

void pattern5(void)
{
	jdword	val;

	printf("\n\tTest 1 : create the counter file (3 counters)\n\n");
    SELECT_FILE_SUCCESS(FID_MF);
    CREATE_BINARY_FILE_SUCCESS(FID_COUNTERS,sizeof(jdword)*3);
    __simu_save_XML_eeprom(55);
    INVALIDATE_SUCCESS(FID_COUNTERS);
    val = 10;
    INCREASE_ERR(FID_COUNTERS,0,&val,ERR_FILE_INVALIDATED);
    val = 10;
    DECREASE_ERR(FID_COUNTERS,0,&val,ERR_FILE_INVALIDATED);
    REHABILITATE_SUCCESS(FID_COUNTERS);

	printf("\n\tTest 2 : increase then decrease the counter \n\n");
	val = 10;
	INCREASE_SUCCESS(FID_COUNTERS,0,&val);
	if (val!=10) {
		fprintf(stderr,"!!! val=%ld\n",val);
		giNumErr++;
	}
	val = 10;
	DECREASE_SUCCESS(FID_COUNTERS,0,&val);
	if (val!=0) {
		fprintf(stderr,"!!! val=%ld\n",val);
		giNumErr++;
	}

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