/* Copyright (C) 2007-2008 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
*/
#include "sim_card.h"
#include <string.h>
#include <assert.h>
#include <stdio.h>
/* set ENABLE_DYNAMIC_RECORDS to 1 to enable dynamic records
* for now, this is an experimental feature that needs more testing
*/
#define ENABLE_DYNAMIC_RECORDS 0
#define A_SIM_PIN_SIZE 4
#define A_SIM_PUK_SIZE 8
typedef struct ASimCardRec_ {
ASimStatus status;
char pin[ A_SIM_PIN_SIZE+1 ];
char puk[ A_SIM_PUK_SIZE+1 ];
int pin_retries;
int port;
char out_buff[ 256 ];
int out_size;
} ASimCardRec;
static ASimCardRec _s_card[1];
ASimCard
asimcard_create(int port)
{
ASimCard card = _s_card;
card->status = A_SIM_STATUS_READY;
card->pin_retries = 0;
strncpy( card->pin, "0000", sizeof(card->pin) );
strncpy( card->puk, "12345678", sizeof(card->puk) );
card->port = port;
return card;
}
void
asimcard_destroy( ASimCard card )
{
/* nothing really */
card=card;
}
static __inline__ int
asimcard_ready( ASimCard card )
{
return card->status == A_SIM_STATUS_READY;
}
ASimStatus
asimcard_get_status( ASimCard sim )
{
return sim->status;
}
void
asimcard_set_status( ASimCard sim, ASimStatus status )
{
sim->status = status;
}
const char*
asimcard_get_pin( ASimCard sim )
{
return sim->pin;
}
const char*
asimcard_get_puk( ASimCard sim )
{
return sim->puk;
}
void
asimcard_set_pin( ASimCard sim, const char* pin )
{
strncpy( sim->pin, pin, A_SIM_PIN_SIZE );
sim->pin_retries = 0;
}
void
asimcard_set_puk( ASimCard sim, const char* puk )
{
strncpy( sim->puk, puk, A_SIM_PUK_SIZE );
sim->pin_retries = 0;
}
int
asimcard_check_pin( ASimCard sim, const char* pin )
{
if (sim->status != A_SIM_STATUS_PIN &&
sim->status != A_SIM_STATUS_READY )
return 0;
if ( !strcmp( sim->pin, pin ) ) {
sim->status = A_SIM_STATUS_READY;
sim->pin_retries = 0;
return 1;
}
if (sim->status != A_SIM_STATUS_READY) {
if (++sim->pin_retries == 3)
sim->status = A_SIM_STATUS_PUK;
}
return 0;
}
int
asimcard_check_puk( ASimCard sim, const char* puk, const char* pin )
{
if (sim->status != A_SIM_STATUS_PUK)
return 0;
if ( !strcmp( sim->puk, puk ) ) {
strncpy( sim->puk, puk, A_SIM_PUK_SIZE );
strncpy( sim->pin, pin, A_SIM_PIN_SIZE );
sim->status = A_SIM_STATUS_READY;
sim->pin_retries = 0;
return 1;
}
if ( ++sim->pin_retries == 6 ) {
sim->status = A_SIM_STATUS_ABSENT;
}
return 0;
}
typedef enum {
SIM_FILE_DM = 0,
SIM_FILE_DF,
SIM_FILE_EF_DEDICATED,
SIM_FILE_EF_LINEAR,
SIM_FILE_EF_CYCLIC
} SimFileType;
typedef enum {
SIM_FILE_READ_ONLY = (1 << 0),
SIM_FILE_NEED_PIN = (1 << 1),
} SimFileFlags;
/* descriptor for a known SIM File */
#define SIM_FILE_HEAD \
SimFileType type; \
unsigned short id; \
unsigned short flags;
typedef struct {
SIM_FILE_HEAD
} SimFileAnyRec, *SimFileAny;
typedef struct {
SIM_FILE_HEAD
cbytes_t data;
int length;
} SimFileEFDedicatedRec, *SimFileEFDedicated;
typedef struct {
SIM_FILE_HEAD
byte_t rec_count;
byte_t rec_len;
cbytes_t records;
} SimFileEFLinearRec, *SimFileEFLinear;
typedef SimFileEFLinearRec SimFileEFCyclicRec;
typedef SimFileEFCyclicRec* SimFileEFCyclic;
typedef union {
SimFileAnyRec any;
SimFileEFDedicatedRec dedicated;
SimFileEFLinearRec linear;
SimFileEFCyclicRec cyclic;
} SimFileRec, *SimFile;
#if ENABLE_DYNAMIC_RECORDS
/* convert a SIM File descriptor into an ASCII string,
assumes 'dst' is NULL or properly sized.
return the number of chars, or -1 on error */
static int
sim_file_to_hex( SimFile file, bytes_t dst )
{
SimFileType type = file->any.type;
int result = 0;
/* see 9.2.1 in TS 51.011 */
switch (type) {
case SIM_FILE_EF_DEDICATED:
case SIM_FILE_EF_LINEAR:
case SIM_FILE_EF_CYCLIC:
{
if (dst) {
int file_size, perm;
memcpy(dst, "0000", 4); /* bytes 1-2 are RFU */
dst += 4;
/* bytes 3-4 are the file size */
if (type == SIM_FILE_EF_DEDICATED)
file_size = file->dedicated.length;
else
file_size = file->linear.rec_count * file->linear.rec_len;
gsm_hex_from_short( dst, file_size );
dst += 4;
/* bytes 5-6 are the file id */
gsm_hex_from_short( dst, file->any.id );
dst += 4;
/* byte 7 is the file type - always EF, i.e. 0x04 */
dst[0] = '0';
dst[1] = '4';
dst += 2;
/* byte 8 is RFU, except bit 7 for cyclic files, which indicates
that INCREASE is allowed. Since we don't support this yet... */
dst[0] = '0';
dst[1] = '0';
dst += 2;
/* byte 9-11 are access conditions */
if (file->any.flags & SIM_FILE_READ_ONLY) {
if (file->any.flags & SIM_FILE_NEED_PIN)
perm = 0x1a;
else
perm = 0x0a;
} else {
if (file->any.flags & SIM_FILE_NEED_PIN)
perm = 0x11;
else
perm = 0x00;
}
gsm_hex_from_byte(dst, perm);
memcpy( dst+2, "a0aa", 4 );
dst += 6;
/* byte 12 is file status, we don't support invalidation */
dst[0] = '0';
dst[1] = '0';
dst += 2;
/* byte 13 is length of the following data, always 2 */
dst[0] = '0';
dst[1] = '2';
dst += 2;
/* byte 14 is struct of EF */
dst[0] = '0';
if (type == SIM_FILE_EF_DEDICATED)
dst[1] = '0';
else if (type == SIM_FILE_EF_LINEAR)
dst[1] = '1';
else
dst[1] = '3';
/* byte 15 is lenght of record, or 0 */
if (type == SIM_FILE_EF_DEDICATED) {
dst[0] = '0';
dst[1] = '0';
} else
gsm_hex_from_byte( dst, file->linear.rec_len );
}
result = 30;
}
break;
default:
result = -1;
}
return result;
}
static const byte_t _const_spn_cphs[20] = {
0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
static const byte_t _const_voicemail_cphs[1] = {
0x55
};
static const byte_t _const_iccid[10] = {
0x98, 0x10, 0x14, 0x30, 0x12, 0x11, 0x81, 0x15, 0x70, 0x02
};
static const byte_t _const_cff_cphs[1] = {
0x55
};
static SimFileEFDedicatedRec _const_files_dedicated[] =
{
{ SIM_FILE_EF_DEDICATED, 0x6f14, SIM_FILE_READ_ONLY | SIM_FILE_NEED_PIN,
_const_spn_cphs, sizeof(_const_spn_cphs) },
{ SIM_FILE_EF_DEDICATED, 0x6f11, SIM_FILE_NEED_PIN,
_const_voicemail_cphs, sizeof(_const_voicemail_cphs) },
{ SIM_FILE_EF_DEDICATED, 0x2fe2, SIM_FILE_READ_ONLY,
_const_iccid, sizeof(_const_iccid) },
{ SIM_FILE_EF_DEDICATED, 0x6f13, SIM_FILE_NEED_PIN,
_const_cff_cphs, sizeof(_const_cff_cphs) },
{ 0, 0, 0, NULL, 0 } /* end of list */
};
#endif /* ENABLE_DYNAMIC_RECORDS */
const char*
asimcard_io( ASimCard sim, const char* cmd )
{
int nn;
#if ENABLE_DYNAMIC_RECORDS
int command, id, p1, p2, p3;
#endif
static const struct { const char* cmd; const char* answer; } answers[] =
{
{ "+CRSM=192,28436,0,0,15", "+CRSM: 144,0,000000146f1404001aa0aa01020000" },
{ "+CRSM=176,28436,0,0,20", "+CRSM: 144,0,416e64726f6964ffffffffffffffffffffffffff" },
{ "+CRSM=192,28433,0,0,15", "+CRSM: 144,0,000000016f11040011a0aa01020000" },
{ "+CRSM=176,28433,0,0,1", "+CRSM: 144,0,55" },
{ "+CRSM=192,12258,0,0,15", "+CRSM: 144,0,0000000a2fe204000fa0aa01020000" },
{ "+CRSM=176,12258,0,0,10", "+CRSM: 144,0,98101430121181157002" },
{ "+CRSM=192,28435,0,0,15", "+CRSM: 144,0,000000016f13040011a0aa01020000" },
{ "+CRSM=176,28435,0,0,1", "+CRSM: 144,0,55" },
{ "+CRSM=192,28472,0,0,15", "+CRSM: 144,0,0000000f6f3804001aa0aa01020000" },
{ "+CRSM=176,28472,0,0,15", "+CRSM: 144,0,ff30ffff3c003c03000c0000f03f00" },
{ "+CRSM=192,28617,0,0,15", "+CRSM: 144,0,000000086fc9040011a0aa01020104" },
{ "+CRSM=178,28617,1,4,4", "+CRSM: 144,0,01000000" },
{ "+CRSM=192,28618,0,0,15", "+CRSM: 144,0,0000000a6fca040011a0aa01020105" },
{ "+CRSM=178,28618,1,4,5", "+CRSM: 144,0,0000000000" },
{ "+CRSM=192,28589,0,0,15", "+CRSM: 144,0,000000046fad04000aa0aa01020000" },
{ "+CRSM=176,28589,0,0,4", "+CRSM: 144,0,00000003" },
{ "+CRSM=192,28438,0,0,15", "+CRSM: 144,0,000000026f1604001aa0aa01020000" },
{ "+CRSM=176,28438,0,0,2", "+CRSM: 144,0,0233" },
{ "+CRSM=192,28486,0,0,15", "+CRSM: 148,4" },
{ "+CRSM=192,28621,0,0,15", "+CRSM: 148,4" },
{ "+CRSM=192,28613,0,0,15", "+CRSM: 144,0,000000f06fc504000aa0aa01020118" },
{ "+CRSM=178,28613,1,4,24", "+CRSM: 144,0,43058441aa890affffffffffffffffffffffffffffffffff" },
{ "+CRSM=192,28480,0,0,15", "+CRSM: 144,0,000000806f40040011a0aa01020120" },
{ "+CRSM=178,28480,1,4,32", "+CRSM: 144,0,ffffffffffffffffffffffffffffffffffff07815155258131f5ffffffffffff" },
{ "+CRSM=192,28615,0,0,15", "+CRSM: 144,0,000000406fc7040011a0aa01020120" },
{ "+CRSM=178,28615,1,4,32", "+CRSM: 144,0,566f6963656d61696cffffffffffffffffff07915155125740f9ffffffffffff" },
{ NULL, NULL }
};
assert( memcmp( cmd, "+CRSM=", 6 ) == 0 );
#if ENABLE_DYNAMIC_RECORDS
if ( sscanf(cmd, "+CRSM=%d,%d,%d,%d,%d", &command, &id, &p1, &p2, &p3) == 5 ) {
switch (command) {
case A_SIM_CMD_GET_RESPONSE:
{
const SimFileEFDedicatedRec* file = _const_files_dedicated;
assert(p1 == 0 && p2 == 0 && p3 == 15);
for ( ; file->id != 0; file++ ) {
if (file->id == id) {
int count;
char* out = sim->out_buff;
strcpy( out, "+CRSM: 144,0," );
out += strlen(out);
count = sim_file_to_hex( (SimFile) file, out );
if (count < 0)
return "ERROR: INTERNAL SIM ERROR";
out[count] = 0;
return sim->out_buff;
}
}
break;
}
case A_SIM_CMD_READ_BINARY:
{
const SimFileEFDedicatedRec* file = _const_files_dedicated;
assert(p1 == 0 && p2 == 0);
for ( ; file->id != 0; file++ ) {
if (file->id == id) {
char* out = sim->out_buff;
if (p3 > file->length)
return "ERROR: BINARY LENGTH IS TOO LONG";
strcpy( out, "+CRSM: 144,0," );
out += strlen(out);
gsm_hex_from_bytes( out, file->data, p3 );
out[p3*2] = 0;
return sim->out_buff;
}
}
break;
}
case A_SIM_CMD_READ_RECORD:
break;
default:
return "ERROR: UNSUPPORTED SIM COMMAND";
}
}
#endif
if (!strcmp("+CRSM=178,28480,1,4,32", cmd)) {
snprintf( sim->out_buff, sizeof(sim->out_buff), "+CRSM: 144,0,ffffffffffffffffffffffffffffffffffff0781515525%d1%d%df%dffffffffffff", (sim->port / 1000) % 10, (sim->port / 10) % 10, (sim->port / 100) % 10, sim->port % 10);
return sim->out_buff;
}
for (nn = 0; answers[nn].cmd != NULL; nn++) {
if ( !strcmp( answers[nn].cmd, cmd ) ) {
return answers[nn].answer;
}
}
return "ERROR: BAD COMMAND";
}