mifare1.c.bak

mifarea卡程序mifarea卡程序mifarea卡程序

/****************************************
 * mifare1.c                            *
 * Designe by 刘俐训                    *
 * excute command for m1 card           *
 * check if a card is actived           *
 * last update: 05-01-2007              *
 ****************************************/
#include "includes.h"

/* About auto search rf card: the default value is read from 
 * the configration table and it is configrable, the current
 * value can be enable or disable by a command.
 */

static unsigned char snr[4];            // serial number of m1 card
static bit fWaitCmd = 0;                // flag of waiting for command


unsigned char snr[4];
unsigned char oldsnr[4];
unsigned char m1keys[16][6];      // save 16 keys max
unsigned char m1keystatus[16];    // sector id and a/b flag
unsigned char m1keycnt = 0;
unsigned char code m1keycntmax = 16;


// 按照8086的格式（低位在前，高位在后）进行转换
long buftolong86(char *buf);
void longtobuf86(long val, char *buf);

// 按照8051的格式（高位在前，低位在后）进行转换
long buftolong51(char *buf);
void longtobuf51(long val, char *buf);
unsigned char M1Auth(unsigned char keyab, unsigned char *key, unsigned char sec);


void M1Init(void)
{
    int ch;
    
    // rf card
    M500PcdInit();  // remember to set if we should set auto search rf card function
    M500PcdMfOutSelect(3);
    
    ch = ParaRead(PARA_RFRXGAIN);
    if((ch >= 0) && (ch <= 3))
    {
        M500SetRcvGain((unsigned char)ch);
    }
    else
    {
        ParaWrite(PARA_RFRXGAIN, 2);
        M500SetRcvGain(2);
    }
}

// check if a rf card is arrived and if I have sent a notice to host
// but the host give no response, I will send the notice once every
// second untill I get a response or a command for rf card.
void M1Card(void)
{
    static unsigned int waitcmdtime = 0;
    unsigned char buf[4];
    static bit fCardIn = 0;                 // flag of card in
    static unsigned char cnt = 0;
    
    if(fAutoSearchCard)
    {
        if(M1Search(snr))
        {
            if(!fCardIn)
            {
                fCardIn = 1;
                
                // beep
                if(fRFCBeep)
                {
                    beep(2, 10);
                }
                
                // light
                CardLed(1, 1);
                
                if(memcmp(snr, oldsnr, 4))  // 不相等
                {
                    memcpy(oldsnr, snr, 4);
                    m1keycnt = 0;
                }

                // 通知主机有卡
                if(fNotice)
                {
                    buf[0] = RFCARD;
                    buf[1] = 1;
    
                    if(!fStopOnACK)
                    {
                        CommSendNotWaitAck(buf, 2);
                        waitcmdtime = GetTickCount();
                        fWaitCmd = 1;
                    }
                    else if(!CommSend(buf, 2))
                    {
                        fCardIn = 0;
                        CardLed(1, 0);
                        
                        cnt ++;
                        // if 3 times host no response, beep to notice customer
                        if(cnt > 3)
                        {
                            cnt = 0;
                            beep(3, 25);
                        }
                    }
                }
            }
        }
        else
        {
            cnt = 0;
            if(fCardIn)
            {
                fCardIn = 0;
                fWaitCmd = 0;
                
                if(fRFCBeep)
                {
                    beep(1, 40);
                }
                
                CardLed(1, 0);
    
                if(fNotice)
                {
                    buf[0] = RFCARD;
                    buf[1] = 0;
                    
                    #if 1
                    CommSendNotWaitAck(buf, 2);        /////////////////////////////////////
                    #else
                    CommSend(buf, 2);
                    #endif
                }
            }
        }
    }
    
    if(fWaitCmd)
    {
        if(GetTickCount() - waitcmdtime >= 1000)
        {										  	
            fCardIn = 0;
            fWaitCmd = 0;
            beep(3, 25);
        }
    }
}

// excute the command for m1 card from host
unsigned int M1Command(unsigned char *cmd, unsigned int len)
{
    unsigned char m1sector;     // m1卡命令针对的扇区
    unsigned char m1block;      // m1卡命令针对的块号
    long epvalue;
    long oldepvalue;
    unsigned char epstatus = 0x03;
    unsigned char m1keyidx;
    bit fkeypassed;
    unsigned char *m1data;
    int i;
    
    // clear waiting cmd flag
    fWaitCmd = 0;
    
    m1sector = cmd[2];
    m1block = cmd[3];
    m1data = cmd + 4;
    
    ///////////////////////////////////////
    // request card!
    if(!M1Search(snr))
    {
        // error
        cmd[0] = FAIL;
        cmd[1] = MI_NOTAGERR;
        return 2;
    }
    
    if(cmd[1] == CMD_GETSNR)       // get card snr
    {
        if(len != 2)
        {
            cmd[0] = ERRORCMDLEN;
            return 1;
        }
        
        // copy snr to cmd
        cmd[0] = SUCCESS;
        memcpy(cmd+1, snr, 4);
        return 5;
    }
    
    if(cmd[1] == CMD_AUTH)    // auth card with specified key
    {
        if(len != 10)
        {
            cmd[0] = ERRORCMDLEN;
            return 1;
        }
        
        m1sector &= 0x7f;       // mask the invalid msb
        i = M1Auth(m1block, m1data, m1sector);
        if(MI_OK != i)
        {
            cmd[0] = FAIL;
            cmd[1] = i;
            return 2;
        }
        else
        {
            cmd[0] = SUCCESS;
            return 1;
        }
    }
    else if(cmd[1] == CMD_LDKEY)
    {
        if((len < 10) && (len != 2))
        {
            cmd[0] = ERRORCMDLEN;
            return 1;
        }
        
        len -= 2;
        if((len & 0x07) != 0)       // len % 8
        {
            cmd[0] = ERRORCMDLEN;
            return 1;
        }
        
        len >>= 3;  // len = len / 8;
        if(len > m1keycntmax)       // too much keys
        {
            cmd[0] = ERRORCMDLEN;
            return 1;
        }
        
        // check if there are same key sector in the data
        for(i=0; i<len-1; i++)
        {
            unsigned char i1;
            bit fsame = 0;
            
            for(i1=i+1; i1<len; i1++)
            {
                if(cmd[2+(i<<3)] > 0x7f)
                {
                    fsame = 1;
                    break;
                }
                if(cmd[2+(i<<3)] == cmd[2+(i1<<3)])
                {
                    fsame = 1;
                    break;
                }
            }
            if(fsame)
                break;
        }
        if(i < len-1)  // found same sector in buffer
        {
            cmd[0] = ERRORCMD;
            return 1;
        }
        
        // cmd --> m1sector
        cmd += 2;
        
        // copy to key buffer
        for(i=0; i<len; i++)
        {
            m1sector = cmd[0] & 0x7f;
            m1block = cmd[1];
            m1data = cmd + 2;
    
            // store key
            memcpy(m1keys[i], m1data, 6);
            if(!m1block)
                m1keystatus[i] = m1sector & 0x7f;
            else
                m1keystatus[i] = m1sector | 0x80;
            
            cmd += 8;
        }
        m1keycnt = i;
        
        cmd[0] = SUCCESS;
        cmd[1] = m1keycnt;
        return 2;
    }
    
    // 其他命令，首先作认证
    // search key for current sector
    m1keyidx = 0xff;
    fkeypassed = 0;
    for(i=0; i<m1keycnt; i++)
    {
        if(m1sector == (m1keystatus[i] & 0x7f))
        {
            m1keyidx = i;
            break;
        }
    }
    if(m1keyidx == 0xff)
    {
        cmd[0] = FAIL;
        cmd[1] = MI_NOTAUTHERR;
        return 2;
    }
    if((m1keystatus[m1keyidx] & 0x80) == 0x80)    // key b
    {
        if(MI_OK == M500Auth(PICC_AUTHENT1B, snr, m1keys[m1keyidx], m1sector))
            fkeypassed = 1;
        else if(MI_OK == M500Auth(PICC_AUTHENT1B, snr, m1keys[m1keyidx], m1sector))
            fkeypassed = 1;
        else if(MI_OK == M500Auth(PICC_AUTHENT1B, snr, m1keys[m1keyidx], m1sector))
            fkeypassed = 1;
    }
    else                                        // key a
    {
        if(MI_OK == M500Auth(PICC_AUTHENT1A, snr, m1keys[m1keyidx], m1sector))
            fkeypassed = 1;
        else if(MI_OK == M500Auth(PICC_AUTHENT1A, snr, m1keys[m1keyidx], m1sector))
            fkeypassed = 1;
        else if(MI_OK == M500Auth(PICC_AUTHENT1A, snr, m1keys[m1keyidx], m1sector))
            fkeypassed = 1;
    }
    if(!fkeypassed)
    {
        cmd[0] = FAIL;
        cmd[1] = MI_AUTHERR;
        return 2;
    }
    
    if(cmd[1] == CMD_READ)    // READ M1 CARD
    {
        if(len != 4)
        {
            cmd[0] = ERRORCMDLEN;
            return 1;
        }
        
        if(m1block == ALLBLOCK)
        {
            if((i = M500Read((m1sector<<2), cmd+1)) != MI_OK)
            {
                // error
                cmd[0] = FAIL;
                cmd[1] = i;
                return 2;
            }
            else if((i = M500Read((m1sector<<2) + 1, cmd+1+16)) != MI_OK)
            {
                // error
                cmd[0] = FAIL;
                cmd[1] = i;
                return 2;
            }
            else if((i = M500Read((m1sector<<2) + 2, cmd+1+16+16)) != MI_OK)
            {
                // error
                cmd[0] = FAIL;
                cmd[1] = i;
                return 2;
            }
            else
            {
                // success
                cmd[0] = SUCCESS;
                return 49;
            }
        }
        else
        {
            if((i = M500Read((m1sector<<2) + m1block, cmd+1)) != MI_OK)
            {
                // read error
                cmd[0] = FAIL;
                cmd[1] = i;
                return 2;
            }
            else
            {
                cmd[0] = SUCCESS;
                return 17;
            }
        }
    }
    else if(cmd[1] == CMD_WRITE)
    {
        if(len != 20)
        {
            cmd[0] = ERRORCMDLEN;
            return 1;
        }
        
        if((i = M500Write((m1sector<<2) + m1block, m1data)) != MI_OK)
        {
            cmd[0] = FAIL;
            cmd[1] = i;
            return 2;
        }
        else if((i = M500Read((m1sector<<2) + m1block, cmd+1)) != MI_OK) // read back
        {
            cmd[0] = FAIL;
            cmd[1] = i;
            return 2;
        }
        else
        {
            cmd[0] = SUCCESS;
            return 17;
        }
    }
    
    // 钱包 ////////////////////////////////////////////
    else if(cmd[1] == CMD_INCEP)
    {
        uchar m1bakblock, m1eptype;
        
        m1bakblock = m1data[0];
        m1eptype = m1data[1];
        m1data += 2;
        m1block = (m1sector << 2) + m1block;
        m1bakblock = (m1sector << 2) + m1bakblock;
        
        if(len != 10)
        {
            cmd[0] = ERRORCMDLEN;
            return 1;
        }
    
        epvalue = buftolong86(m1data);
        
        i = M500ReadValue(m1block, cmd, m1bakblock);
        if(i != MI_OK)
        {
            // error
            cmd[0] = FAIL;
            cmd[1] = i;
            return 2;
        }
    
        if(!m1eptype)    // lsb first ep
            oldepvalue = buftolong86(cmd);
        else            // msb first ep
            oldepvalue = buftolong51(cmd);
        
        epvalue += oldepvalue;
        
        if(!m1eptype)    // lsb first ep
            longtobuf86(epvalue, cmd);
        else            // msb first ep
            longtobuf51(epvalue, cmd);
    
        if(MI_OK != (i = M500WriteValue(m1block, cmd, m1bakblock)))
        {
            // error
            cmd[0] = FAIL;