acr120.c //acr

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "acr120.h"

#define STX 0x2
#define ETX 0x3

unsigned char *nib;

int acr120_errno;
static int acr120_proto_mode;
static struct termios old;

static void dec2nibble(unsigned int, unsigned char*);
static void nibble2dec(unsigned int*,unsigned char*);
static int check_bin_error(const unsigned char*, size_t);
static int check_ascii_error(const unsigned char*, size_t);
static int acr120_timeout(int, int);

static const char const *acr120_error[] = {
    "success", // 1
    "open device failure", // 2
    "close device failure",// 3
    "device setting failure",// 4
    "write device failure",// 5
    "read device failure",//6
    "select device failure",//7
    "operation timeout",//8
    "no TAG",//9
    "no value block",//10      
    "login fail, key wrong",//11
    "invalid key format (stored key)",//12
    "read failure",//13
    "unable to read after write",//14
    "read after write error",//15
    "write failure",//16
    "unable to read after increment",//17
    "increment failure",//18
    "unable to read after decrement",//19
    "decrement failure",//20
    "empty value decrement",//21
    "unable to read after copy",//22
    "copy failure",//23
    "data error"//24
};

static void dec2nibble(unsigned int value, unsigned char *nibble)
{
    nibble[3] = value & 0xff;
    nibble[2] = value >> 8 & 0xff;
    nibble[1] = value >> 16 & 0xff;
    nibble[0] = value >> 24 & 0xff;
}


static void nibble2dec(unsigned int *val,unsigned char *nibble)
{


int valoo = (nibble[3] & 0xff) | ((nibble[2] & 0xff) << 8) | ((nibble[1] & 0xff) << 16) | ((nibble[0] & 0xff) << 24);

*val = (nibble[0] & 0xff) | ((nibble[1] & 0xff) << 8) | ((nibble[2] & 0xff) << 16) | ((nibble[3] & 0xff) << 24);


printf("id *= %d\n",*val);
printf("id = %d\n",valoo);


}

static int check_bin_error(const unsigned char *ans, size_t len)
{
    unsigned char check = 0;
    int i, nc = len - 2 * sizeof(unsigned char );
    size_t bytes = 0;

    for (i = 1; i < nc; i++)
        check ^= ans[i];
    return (check == ans[nc]) ? 0 : 1;
}

static int check_ascii_error(const unsigned char *ans, size_t len)
{
    return (ans[len - 2] == 0xd && ans[len -1] == 0xa) ? 0 : 1;
}

const char* acr120_strerror(void)
{
    return acr120_error[acr120_errno - 1];
}

inline int acr120_open(const char *dev, unsigned char sid, speed_t speed)
{
    int fd, ret;
    unsigned char cmd[8], ans[6], val, check = 0;
    size_t bytes = 0;
    struct termios opt;

   // fd = open(dev, O_RDWR | O_NOCTTY, 0644);
   fd = open(dev, O_RDWR | O_NOCTTY, 0110);
    if (fd == -1) {
        acr120_errno = 2;
        return ACR120_ERROR;
    }

    ret = tcgetattr(fd, &opt);
    if (ret == -1) {
        close(fd);
        acr120_errno = 4;
        return ACR120_ERROR;
    }

    /* save previous setting to restore on close */
    memcpy(&old, &opt, sizeof(struct termios));

    cfsetispeed(&opt, speed);
    cfsetospeed(&opt, speed);
    /* set to canonical mode */
    opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
    /* disable flow control both input and output */
    opt.c_iflag &= ~(IXON | IXOFF);
    /* disable CR-NL or NL-CR translation both input and output */
    opt.c_iflag &= ~(INLCR | ICRNL);
    opt.c_oflag &= ~(ONLCR | OCRNL);
    ret = tcsetattr(fd, TCSANOW, &opt);
    if (ret == -1) {
        close(fd);
        acr120_errno = 4;
        return ACR120_ERROR;
    }

    /* probe in ASCII mode */
    snprintf((char *) cmd, 5 * sizeof(unsigned char), "re%.2x",
             ACR120_REGISTER_PROTOCOL);
    ret = write(fd, cmd, 4 * sizeof(unsigned char));
    if (ret <= 0) {
        acr120_close(fd);
        acr120_errno = 5;
        return ACR120_ERROR;
    }

    ret = acr120_timeout(fd, 100);
    if (ret == ACR120_ERROR) {
        if (acr120_errno != 8) {
            close(fd);
            return ret;unsigned char cmd[8], ans[6], val, check = 0;
    size_t bytes = 0;
        }
        goto bin;
    } else {
          while (bytes < 4 * sizeof(unsigned char)) {
              ret = read(fd, ans + bytes, 4 * sizeof(unsigned char) - bytes);
              if (ret <= 0) {
                  close(fd);
                  acr120_errno = 6;
                  return ACR120_ERROR;
              }
              bytes += ret;
          }
          if (check_ascii_error(ans, 4)) {
              acr120_errno = 24;
              goto bin;
          }
          ans[2] = 0;
          sscanf((char*) ans, "%x", (unsigned int*) &val);
          goto done;
    }

bin:
    /* read protocol register to obtain protocol mode */
    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 0x3;
    cmd[3] = 'r';
    cmd[4] = 'e';
    cmd[5] = ACR120_REGISTER_PROTOCOL;
    cmd[6] = cmd[1] ^ cmd[2] ^ cmd[3] ^ cmd[4] ^ cmd[5];
    cmd[7] = ETX;

    /* probe in binary mode */
    ret = write(fd, cmd, sizeof(cmd));
    if (ret <= 0) {
        acr120_close(fd);
        acr120_errno = 5;
        return ACR120_ERROR;
    }

    bytes = 0;
    while (bytes < sizeof(ans)) {
        ret = acr120_timeout(fd, 100);
        if (ret == ACR120_ERROR) {
            close(fd);
            return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
//printf("%x %x %x %x %x %x %x %x %x %x \n",ans[0],ans[1],ans[2],ans[3],ans[4],ans[5],ans[6],ans[7],ans[8],ans[9]);

        if (ret <= 0) {
            acr120_close(fd);
            acr120_errno = 6;

            return ACR120_ERROR;
        }
        bytes += ret;
        /* eventually there are no error code satisfied for
           reading register value, only check here for
           compability */
        if (bytes > 4 && !check) {
            switch (ans[3]) {
                case 'N':
                    acr120_close(fd);
                    acr120_errno = 9;
                    return ACR120_ERROR;
                case 'I':
                    acr120_close(fd);
                    acr120_errno = 10;
                    return ACR120_ERROR;
                case 'F':
                    acr120_close(fd);
                    acr120_errno = 13;
                    return ACR120_ERROR;
            }
            check ^= 1;
        }
    }

    if (check_bin_error(ans, sizeof(ans))) {
        acr120_close(fd);
        acr120_errno = 24;
        return ACR120_ERROR;
    }
    val = ans[3];

done:
    /* set protocol mode */
    acr120_proto_mode = val >> 1 & 0x1;
    acr120_errno = 1;
    return fd;
}

int acr120_close(int fd)
{
    int ret;

    /* restore previous setting */
    tcsetattr(fd, TCSANOW, &old);
    ret = close(fd);
    if (ret == -1) {
        acr120_errno = 3;
        return ACR120_ERROR;
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}          

static int acr120_timeout(int fd, int timeout)
{
    int ret;
    fd_set rset;
    struct timeval val = { .tv_sec = 0, .tv_usec = 1000 * timeout };

    FD_ZERO(&rset);
    FD_SET(fd, &rset);
    ret = select(fd + 1, &rset, NULL, NULL, &val);
    if (ret == 0) {
        acr120_errno = 8;
        return ACR120_ERROR;
    }
    if (ret == -1) {
        acr120_errno = 7;
        return ACR120_ERROR;
    }
    if (FD_ISSET(fd, &rset)) {
        acr120_errno = 1;
        return ACR120_SUCCESS;
    }
    /* should never reach here */
    acr120_errno = 7;
    return ACR120_ERROR;
}

int acr120_reset(int fd, unsigned char sid, int reply, int timeout)
{
    int ret;
    unsigned char cmd[6], ans[12];
    size_t bytes = 0, nw, nr;

    if (acr120_proto_mode) {
        cmd[0] = STX;
        cmd[1] = sid;
        cmd[2] = 0x1;
        cmd[3] = 'x';
        cmd[4] = cmd[1] ^ cmd[2] ^ cmd[3];
        cmd[5] = ETX;
        nw = sizeof(cmd);
        /* no answer on binary mode */
        nr = 0;
    } else {
        cmd[0] = 'x';
        nw = sizeof(unsigned char);unsigned int *val,
        nr = reply ? sizeof(ans) : 0;
    }

    ret = write(fd, cmd, nw);
    if (ret <= 0) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }

    while (bytes < nr) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
       
        ret = read(fd, ans + bytes, nr - bytes);
        if (ret <= 0) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
    }

    if (!acr120_proto_mode && reply) {
        if (check_ascii_error(ans, 12)) {
            acr120_errno = 24;
            return ACR120_ERROR;
        }
    }
   
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_get_id(int fd, unsigned char *id, int timeout)
{
    int ret;
    unsigned char cmd[6], ans[6];
    size_t bytes = 0;

    cmd[0] = STX;
    cmd[1] = 0xff;
    cmd[2] = 0x1;
    cmd[3] = 'g';
    cmd[4] = cmd[1] ^ cmd[2] ^ cmd[3];
    cmd[5] = ETX;

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }

    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);

        if (ret == -1) {
            acr120_errno = 6;

            return ACR120_ERROR;
        }
        bytes += ret;
    }

    if (id)
      *id = ans[3];

    acr120_errno = 1;

    return ACR120_SUCCESS;
}

int acr120_select(int fd, unsigned char sid, unsigned int *uid, int timeout)
{
    int ret;
    unsigned char cmd[6], ans[9], uids[4];
    size_t bytes = 0;

    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 0x1;
    cmd[3] = 's';
    cmd[4] = cmd[1] ^ cmd[2] ^ cmd[3];
    cmd[5] = ETX;

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
        if (bytes > 3) {
            if (ans[3] == 'N') {
                acr120_errno = 9;
                return ACR120_ERROR;
            }
        }
    }


   if (uid){
memcpy(uids, ans + 3, sizeof(uids));
        nibble2dec(uid, uids);
}

    acr120_errno = 1;
    return ACR120_SUCCESS;
}

/*
 * key ff binary sequence: 02 01 04 6c 01 ff 0d 9a 03
 * key aa or bb binary sequence: 02 01 09 6c 01 aa a0 a1 a2 a3 a4 a5 ce 03
 */
int acr120_login(int fd, unsigned char sid, unsigned char sector,
                mifare_key type, unsigned char *key, int timeout)
{
    int ret, i;
    unsigned char cmd[14], ans[6];
    size_t bytes = 0, len;

printf("sector = %x\n",sector);
printf("key= %c\n",&key);
printf("keyType= %x\n",type);
    cmd[0] = STX;
    cmd[1] = sid;
    cmd[3] = 'l';
    cmd[4] = sector;

   if (type == MIFARE_KEY_FF) {
        cmd[2] = 0x04;
        cmd[5] = 0xff;
        cmd[6] = 0xd;
        for (i = 1, cmd[7] = 0; i < 7; i++)
            cmd[7] ^= cmd[i];
        len = 9;


    } else {
        cmd[2] = 9;
        cmd[5] = (type == MIFARE_KEY_AA) ? 0xaa : 0xbb;

        memcpy(cmd + 6, key, 6 * sizeof(unsigned char));
        for (i = 1, cmd[12] = 0; i < 12; i++)
            cmd[12] ^= cmd[i];
        len = 14;
    }

    cmd[len - 1] = ETX;

printf("%x %x %x %c %x %x %x %x %x %x %x %x %x %X\n",cmd[0],cmd[1],cmd[2],cmd[3],cmd[4],cmd[5],cmd[6],cmd[7],cmd[8],cmd[9],cmd[10],cmd[11],cmd[12],cmd[13]);
   
    ret = write(fd, cmd, len);

    if (ret == -1) {

        acr120_errno = 5;

        return ACR120_ERROR;
    }
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
        if (ret == -1) {
            acr120_errno = 6;

            return ACR120_ERROR;
        }
printf("%c \n",ans[3]);

        bytes += ret;
        if (bytes > 3) {
            switch (ans[3]) {
                case 'L':
                    acr120_errno = 1;
printf("lOGIN = %s\n",acr120_strerror());
                    return ACR120_SUCCESS;
                case 'N':
                    acr120_errno = 9;


                    return ACR120_ERROR;
                case 'F':
                    acr120_errno = 11;

                    return ACR120_ERROR;
                case 'E':
                    acr120_errno = 12;

                    return ACR120_ERROR;
            }
        }
    }

    acr120_errno = 11;
    return ACR120_ERROR;
}

int acr120_write_block(int fd, unsigned char sid, unsigned char block,
                unsigned char *data, int timeout)
{
    int ret, i;
    unsigned char cmd[23], ans[21];
    size_t bytes = 0;

    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 18;
    cmd[3] = 'w';
    cmd[4] = block;
    memcpy(cmd + 5, data, 16);
    cmd[22] = ETX;

    for (i = 1, cmd[21] = 0; i < 21; i++)
        cmd[21] ^= cmd[i];

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }

    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
        if (bytes > 3) {
            switch (ans[3]) {
                case 'X':
                    acr120_errno = 14;
                    return ACR120_ERROR;
                case 'U':
                    acr120_errno = 15;
                    return ACR120_ERROR;
                case 'N':
                    acr120_errno = 9;
                    return ACR120_ERROR;
                case 'F':
                case 'I':
                    acr120_errno = 16;
                    return ACR120_ERROR;
            }
        }
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_write_value(int fd, unsigned char sid, unsigned char block,
                unsigned int value, int timeout)
{
    int ret, i;
    unsigned char cmd[12], data[4], ans[9];
    size_t bytes = 0;

printf("value write = %d \n",value);  

    dec2nibble(value, data);
    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 0x7;
    cmd[3] = 'w';
    cmd[4] = 'v';
    cmd[5] = block;
    cmd[6] = data[0];
    cmd[7] = data[1];
    cmd[8] = data[2];
    cmd[9] = data[3];
    cmd[11] = ETX;

printf("data = %x\n",data);
printf("data write = %x %x %x %x \n",data[0],data[1],data[2],data[3]);
   
printf("cmd_write = %x %x %x %x %x %x %x %x %x %x %x %x %x %x\n",cmd[0],cmd[1],cmd[2],cmd[3],cmd[4],cmd[5],cmd[6],cmd[7],cmd[8],cmd[9],cmd[10],cmd[11],cmd[12],cmd[13]);
    for (i = 1, cmd[10] = 0; i < 10; i++)
        cmd[10] ^= cmd[i];

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }
   
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
        if (bytes > 3) {
            switch (ans[3]) {
                case 'X':
                   acr120_errno = 14;
                   return ACR120_ERROR;
                case 'U':
                    acr120_errno = 15;
                    return ACR120_ERROR;
                case 'N':
                    acr120_errno = 9;
printf("ASIK\n");
                    return ACR120_ERROR;
                case 'F':
                case 'I':
                    acr120_errno = 16;
                    return ACR120_ERROR;
            }
        }
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_write_register(int fd, unsigned char sid, unsigned char reg,
                unsigned char value, int timeout)
{
    unsigned char cmd[9], ans[6], check = 0;
    size_t bytes = 0, nr, nw;
    int ret;

    if (acr120_proto_mode) {
        cmd[0] = STX;
        cmd[1] = sid;
        cmd[2] = 0x4;
        cmd[3] = 'w';
        cmd[4] = 'e';
        cmd[5] = reg;
        cmd[6] = value;
        cmd[7] = cmd[1] ^ cmd[2] ^ cmd[3] ^ cmd[4] ^ cmd[5] ^ cmd[6];
        cmd[8] = ETX;
        nw = sizeof(cmd);
        nr = sizeof(ans);
    } else {
        snprintf((char*) cmd, 7 * sizeof(unsigned char),
                 "we%.2x%.2x", reg, value);
        printf("cmd is: %s\n", (char*) cmd);
        nw = 6 * sizeof(unsigned char);
        nr = 4 * sizeof(unsigned char);
    }

    ret = write(fd, cmd, nw);

    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }

    while (bytes < nr) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }

        ret = read(fd, ans + bytes, nr - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
       
        bytes += ret;
        if (acr120_proto_mode && bytes > 4 * sizeof(unsigned char) && !check) {
            switch (ans[3]) {
                case 'X':
                    acr120_errno = 14;

                    return ACR120_ERROR;
                case 'U':
                    acr120_errno = 15;

                    return ACR120_ERROR;
                case 'N':
                    acr120_errno = 9;

                    return ACR120_ERROR;
                case 'I':
                    acr120_errno = 16;

                    return ACR120_ERROR;
            }
            check ^= 1;
        }
    }

    if (acr120_proto_mode) {
        if (check_bin_error(ans, sizeof(ans))) {
            acr120_errno = 24;
            return ACR120_ERROR;
        }
    } else {
        if (check_ascii_error(ans, 4)) {
            acr120_errno = 24;
            return ACR120_ERROR;
        }
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_read_block(int fd, unsigned char sid, unsigned char block,
                unsigned char *data, int timeout)
{
    int ret;
    unsigned char cmd[7], ans[21];
    size_t bytes = 0;

    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 2;
    cmd[3] = 'r';
    cmd[4] = block;
    cmd[5] = cmd[1] ^ cmd[2] ^ cmd[3] ^ cmd[4];
    cmd[6] = ETX;

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR )
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
        if (bytes > 3) {
            switch (ans[3]) {
                case 'N':
                    acr120_errno = 9;
                    return ACR120_ERROR;
                case 'F':
                    acr120_errno = 13;
                    return ACR120_ERROR;
            }
        }
    }
    if (data)
        memcpy(data, ans + 3, 16);
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_read_value(int fd, unsigned char sid, unsigned char block,
                unsigned int *value, int timeout)
{
    int ret;
    unsigned char cmd[8], ans[9], data[4];
    size_t bytes = 0;
   
    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 0x3;
    cmd[3] = 'r';
    cmd[4] = 'v';
    cmd[5] = block;
    cmd[6] = cmd[1] ^ cmd[2] ^ cmd[3] ^ cmd[4] ^ cmd[5];

    cmd[7] = ETX;

printf("%x %x %x %c %c %x %x %x\n",cmd[0],cmd[1],cmd[2],cmd[3],cmd[4],cmd[5],cmd[6],cmd[7]);

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }
   
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);

        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;

        if (bytes > 3) {
            switch (ans[3]) {
                case 'N':
                    acr120_errno = 9;
                    return ACR120_ERROR;
                case 'I':
                    acr120_errno = 10;
                    return ACR120_ERROR;
                case 'F':
                    acr120_errno = 13;
                    return ACR120_ERROR;
            }
        }
    }

printf("%i\n",ret);
printf("%c %c %c\n",ans[3],cmd[3],cmd[4]);
printf("%x %x %x %x %x %x %x %x %x %x\n",cmd[0],cmd[1],cmd[2],cmd[3],cmd[4],cmd[5],cmd[6],cmd[7],cmd[8],cmd[9]);
    if (value) {
        memcpy(data, ans + 3, sizeof(data));  
        nibble2dec(value, data);

    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_read_register(int fd, unsigned char sid, unsigned char reg,
                unsigned char *value, int timeout)
{
    int ret;
    unsigned char cmd[8], ans[6], check = 0;
    size_t bytes = 0, nw, nr;

    if (acr120_proto_mode) {
        cmd[0] = STX;
        cmd[1] = sid;
        cmd[2] = 0x3;
        cmd[3] = 'r';
        cmd[4] = 'e';
        cmd[5] = reg;
        cmd[6] = cmd[1] ^ cmd[2] ^ cmd[3] ^ cmd[4] ^ cmd[5];
        cmd[7] = ETX;
        nw = sizeof(cmd);
        nr = sizeof(ans);
    } else {
        snprintf((char *) cmd, 5 * sizeof(unsigned char), "re%.2x", reg);
        nw = 4 * sizeof(unsigned char);
        nr = 4 * sizeof(unsigned char);
    }

    ret = write(fd, cmd, nw);
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }

    while (bytes < nr) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, nr - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
        if (acr120_proto_mode && bytes > 4 && !check) {
            switch (ans[3]) {
                case 'N':
                    acr120_errno = 9;
                    return ACR120_ERROR;
                case 'I':
                    acr120_errno = 10;
                    return ACR120_ERROR;
                case 'F':
                    acr120_errno = 13;
                    return ACR120_ERROR;
            }
            check ^= 1;
        }
    }

    if (acr120_proto_mode) {
        if (check_bin_error(ans, sizeof(ans))) {
            acr120_errno = 24;
            return ACR120_ERROR;
        }
        *value = ans[3];
    } else {
        if (check_ascii_error(ans, 4)) {
            acr120_errno = 24;
            return ACR120_ERROR;
        }
        ans[2] = 0;
        sscanf((char*) ans, "%x", (unsigned int*) value);
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_copy_block(int fd, unsigned char sid, unsigned char source,
                unsigned char dest, int timeout)
{
    int ret;
    unsigned char cmd[8], ans[9];
    size_t bytes = 0;

    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 0x3;
    cmd[3] = '=';
    cmd[4] = source;
    cmd[5] = dest;
    cmd[6] = cmd[1] ^ cmd[2] ^ cmd[3] ^ cmd[4] ^ cmd[5];
    cmd[7] = ETX;
   
    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
        if (bytes > 3) {
            switch (ans[3]) {
                case 'X':
                    acr120_errno = 22;
                    return ACR120_ERROR;
                case 'N':
                    acr120_errno = 9;
                    return ACR120_ERROR;
                case 'I':
                    acr120_errno = 10;
                    return ACR120_ERROR;
                case 'F':
                    acr120_errno = 23;
                    return ACR120_ERROR;
            }
        }
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_inc_value(int fd, unsigned char sid, unsigned char block,
                unsigned int inc, int timeout)
{
    int ret, i;
    unsigned char cmd[11], ans[9], data[4];
    size_t bytes = 0;

    dec2nibble(inc, data);
    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 6;
    cmd[3] = '+';
    cmd[4] = block;
    cmd[5] = data[0];
    cmd[6] = data[1];
    cmd[7] = data[2];
    cmd[8] = data[3];
    cmd[10] = ETX;

    for (i = 1, cmd[9] = 0; i < 9; i++)
        cmd[9] ^= cmd[i];

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
        if (bytes > 3) {
            switch (ans[3]) {
                case 'X':
                    acr120_errno = 17;
                    return ACR120_ERROR;
                case 'N':
                    acr120_errno = 9;
                    return ACR120_ERROR;
                case 'I':
                    acr120_errno = 10;
                    return ACR120_ERROR;
                case 'F':
                    acr120_errno = 18;
                    return ACR120_ERROR;
            }
        }
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_dec_value(int fd, unsigned char sid, unsigned char block,
                unsigned int dec, int timeout)
{
    int ret, i;
    unsigned char cmd[11], ans[9], data[4];
    size_t bytes = 0;
   
    dec2nibble(dec, data);
    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 6;
    cmd[3] = '-';
    cmd[4] = block;
    cmd[5] = data[0];
    cmd[6] = data[1];
    cmd[7] = data[2];
    cmd[8] = data[3];
    cmd[10] = ETX;
   
    for (i = 1, cmd[9] = 0; i < 9; i++)
        cmd[9] ^= cmd[i];

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == -1) {
        acr120_errno = 5;
        return ACR120_ERROR;
    }
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, ans + bytes, sizeof(ans) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
        if (bytes > 3) {
            switch(ans[3]) {
                case 'X':
                    acr120_errno = 19;
                    return ACR120_ERROR;
                case 'N':
                    acr120_errno = 9;
                    return ACR120_ERROR;
                case 'I':
                    acr120_errno = 10;
                    return ACR120_ERROR;
                case 'F':
                case 'E':
                    acr120_errno = 20;
                    return ACR120_ERROR;
            }
        }
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_power_on(int fd, unsigned char sid, int timeout)
{
    int ret;
    unsigned char cmd[8], ans[6];
    size_t bytes = 0;

    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 3;
    cmd[3] = 'p';
    cmd[4] = 'o';
    cmd[5] = 'n';
    cmd[6] = cmd[1] ^ cmd[2] ^ cmd[3] ^ cmd[4] ^ cmd[5];
    cmd[7] = ETX;
   
    ret = write(fd, cmd, sizeof(cmd));
    if (ret == ACR120_ERROR) {
        acr120_errno = 5;
        return ret;
    }

    /*
     * actually no error condition answer here, but the
     * reader will send 6 bytes of characters reply, so we
     * only receive the buffer to make sure it is empty
     */
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, cmd + bytes, sizeof(cmd) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}

int acr120_power_off(int fd, unsigned char sid, int timeout)
{
    int ret;
    unsigned char cmd[9], ans[6];
    size_t bytes = 0;

    cmd[0] = STX;
    cmd[1] = sid;
    cmd[2] = 4;
    cmd[3] = 'p';
    cmd[4] = 'o';
    cmd[5] = 'f';
    cmd[6] = 'f';
    cmd[7] = cmd[1] ^ cmd[2] ^ cmd[3] ^ cmd[4] ^ cmd[5] ^ cmd[6];
    cmd[8] = ETX;

    ret = write(fd, cmd, sizeof(cmd));
    if (ret == ACR120_ERROR) {
        acr120_errno = 5;
        return ret;
    }
    while (bytes < sizeof(ans)) {
        if (timeout) {
            ret = acr120_timeout(fd, timeout);
            if (ret == ACR120_ERROR)
                return ret;
        }
        ret = read(fd, cmd + bytes, sizeof(cmd) - bytes);
        if (ret == -1) {
            acr120_errno = 6;
            return ACR120_ERROR;
        }
        bytes += ret;
    }
    acr120_errno = 1;
    return ACR120_SUCCESS;
}