data-agent/ytDog/dogthread.cpp

#include "dogthread.h"
#include "../ytCore/yt_unit_shm.h"
#include <QCryptographicHash>

extern void MD5Init (MD5_CTX *context);
extern void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen);
extern void MD5Final (unsigned char digest[16], MD5_CTX *context);

extern YT_UNIT_SHM *ytShm;

#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

static void MD5_memcpy (POINTER output, POINTER input, unsigned int len);
static void MD5Transform (UINT4 state[4], unsigned char block[64]);
static void Encode (unsigned char *output, UINT4 *input, unsigned int len);
static void MD5_memset (POINTER output, int value, unsigned int len);
static void Decode (UINT4 *output, unsigned char *input, unsigned int len);

static unsigned char PADDING[64] = {
 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
#define FF(a, b, c, d, x, s, ac) { (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac);  (a) = ROTATE_LEFT ((a), (s));  (a) += (b);  }
#define GG(a, b, c, d, x, s, ac) { (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac);  (a) = ROTATE_LEFT ((a), (s));  (a) += (b);  }
#define HH(a, b, c, d, x, s, ac) { (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac);  (a) = ROTATE_LEFT ((a), (s));  (a) += (b);  }
#define II(a, b, c, d, x, s, ac) { (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac);  (a) = ROTATE_LEFT ((a), (s));  (a) += (b);  }

static void MD5Transform (UINT4 state[4], unsigned char block[64])
{
 UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];

 Decode (x, block, 64);

 /* Round 1 */
 FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

 /* Round 2 */
 GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
 GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

 /* Round 3 */
 HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
 HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

 /* Round 4 */
 II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

 state[0] += a;
 state[1] += b;
 state[2] += c;
 state[3] += d;
 MD5_memset ((POINTER)x, 0, sizeof (x));
}
static void Decode (UINT4 *output, unsigned char *input, unsigned int len)
{
 unsigned int i, j;

 for (i = 0, j = 0; j < len; i++, j += 4)
  output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
  (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
}

static void MD5_memcpy (POINTER output, POINTER input, unsigned int len)
{
 unsigned int i;

 for (i = 0; i < len; i++)
  output[i] = input[i];
}

static void MD5_memset (POINTER output, int value, unsigned int len)
{
 unsigned int i;

 for (i = 0; i < len; i++)
  ((char *)output)[i] = (char)value;
}

static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
{
 unsigned int i, j;

 for (i = 0, j = 0; j < len; i++, j += 4) {
  output[j] = (unsigned char)(input[i] & 0xff);
  output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
  output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
  output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
 }
}

void MD5Init (MD5_CTX *context)          /* context */
{
 context->count[0] = context->count[1] = 0;
 /* Load magic initialization constants.
 */
 context->state[0] = 0x67452301;
 context->state[1] = 0xefcdab89;
 context->state[2] = 0x98badcfe;
 context->state[3] = 0x10325476;
}

void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)

{
 unsigned int i, index, partLen;

 /* Compute number of bytes mod 64 */
 index = (unsigned int)((context->count[0] >> 3) & 0x3F);

 /* Update number of bits */
 if ((context->count[0] += ((UINT4)inputLen << 3))
  < ((UINT4)inputLen << 3))
  context->count[1]++;
 context->count[1] += ((UINT4)inputLen >> 29);

 partLen = 64 - index;

 /* Transform as many times as possible.
 */
 if (inputLen >= partLen) {
  MD5_memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
  MD5Transform (context->state, context->buffer);

  for (i = partLen; i + 63 < inputLen; i += 64)
   MD5Transform (context->state, &input[i]);

  index = 0;
 }
 else
  i = 0;

 /* Buffer remaining input */
 MD5_memcpy((POINTER)&context->buffer[index], (POINTER)&input[i],inputLen-i);
}

void MD5Final (unsigned char digest[16], MD5_CTX *context)
{
 unsigned char bits[8];
 unsigned int index, padLen;

 /* Save number of bits */
 Encode (bits, context->count, 8);

 /* Pad out to 56 mod 64.
 */
 index = (unsigned int)((context->count[0] >> 3) & 0x3f);
 padLen = (index < 56) ? (56 - index) : (120 - index);
 MD5Update (context, PADDING, padLen);

 /* Append length (before padding) */
 MD5Update (context, bits, 8);

 /* Store state in digest */
 Encode (digest, context->state, 16);

 /* Zeroize sensitive information.
 */
 MD5_memset ((POINTER)context, 0, sizeof (*context));
}

dogThread::dogThread(QObject *parent, QStringList params) :
    QThread(parent)
{
    runFlag = false;
    QFile db_dir(QString(DB_PATH));
    QDateTime t = QDateTime::currentDateTime();
    start_t = t.toTime_t();
    start_h = t.time().hour();
    if(!db_dir.exists())
        system(QString("mkdir -p %1").arg(DB_PATH).toUtf8().data());
    Params.clear();
    if(params.length()>0)
        Params.append(params);
}

void dogThread::start_app()
{
    QString cmd = QString("./%1 ").arg(APP_NAME);
    if(Params.length()>0)
    {
        for(int i=0;i<Params.length();i++)
        {
            if(Params.at(i).compare("&")!=0)
                cmd.append(QString("%1 ").arg(Params.at(i)));
        }
    }
    cmd.append(" &");
    system(cmd.toUtf8().data());
}

int dogThread::mk_verqry(unsigned char *cmd)
{
    int i,row=0;
    size_t idLen = strlen(APP_ID);
    unsigned char crc=0x00;
    unsigned short dLen = idLen+4;
    unsigned short Len = dLen+14;
    cmd[row++] = 0x7e;
    cmd[row++] = 0x01;
    cmd[row++] = (dLen>>8)&0xff;
    cmd[row++] = dLen&0xff;
    cmd[row++] = 0x05;
    cmd[row++] = 0x85;
    cmd[row++] = 0x83;
    cmd[row++] = 0x75;
    cmd[row++] = 0x89;
    cmd[row++] = 0x73;
    cmd[row++] = 0x79;
    cmd[row++] = 0x84;
    cmd[row++] = 0x01;
    cmd[row++] = (idLen>>8)&0xff;
    cmd[row++] = idLen&0xff;
    for(i=0;i<idLen;i++)
        cmd[row++] = APP_ID[i]&0xff;
    cmd[row++] = 0x00;
    cmd[row] = 0x00;
    cmd[row+1] = 0xe7;
    for(i=1;i<row;i++)
        crc += cmd[i];
    cmd[row] = crc&0xff;
    if(Len!=(row+2))
        return 0;
    return Len;
}

int dogThread::mk_proqry(unsigned char *cmd, int idx)
{
    int i, row=0;
    size_t idLen = strlen(APP_ID);
    unsigned char crc=0x00;
    unsigned short dLen = idLen+8;
    unsigned short Len = dLen+14;
    cmd[row++] = 0x7e;
    cmd[row++] = 0x01;
    cmd[row++] = (dLen>>8)&0xff;
    cmd[row++] = dLen&0xff;
    cmd[row++] = 0x05;
    cmd[row++] = 0x85;
    cmd[row++] = 0x83;
    cmd[row++] = 0x75;
    cmd[row++] = 0x89;
    cmd[row++] = 0x73;
    cmd[row++] = 0x79;
    cmd[row++] = 0x84;
    cmd[row++] = 0x02;
    cmd[row++] = (idLen>>8)&0xff;
    cmd[row++] = idLen&0xff;
    for(i=0;i<idLen;i++)
        cmd[row++] = APP_ID[i]&0xff;
    cmd[row++] = 0x00;
    cmd[row++] = t_Major;
    cmd[row++] = t_Minor;
    cmd[row++] = (idx>>8)&0xff;
    cmd[row++] = idx&0xff;
    cmd[row] = 0x00;
    cmd[row+1] = 0xe7;
    for(i=1;i<row;i++)
        crc += cmd[i];
    cmd[row] = crc&0xff;
    if(Len!=(row+2))
        return 0;
    return Len;
}

bool dogThread::check_frame(QByteArray rtn, int idx, FILE *fd)
{
    int i,bLen,t_len,crc_len,pro_len;
    unsigned char crc=0x00;
    unsigned char data[1200];
    unsigned short t_datachk,datachk=0x0000;
    if(rtn.length()<=14)
        return false;
    bLen = (int)(((rtn.at(2)&0x00ff)<<8)|(rtn.at(3)&0x00ff))+14;
    if(rtn.length()!=bLen)
        return false;
    if(((rtn.at(0)&0xff)!=0x7e)||((rtn.at(rtn.length()-1)&0xff)!=0xe7))
        return false;
    for(i=1;i<(rtn.length()-2);i++)
        crc += (rtn.at(i)&0xff);

    if((rtn.at(rtn.length()-2)&0xff)!=crc)
        return false;
    switch(rtn.at(12)&0xff){
        case 0x01:
        {
            bzero(t_DeviceTypeId,sizeof(t_DeviceTypeId));
            bzero(t_Checksum,sizeof(t_Checksum));
            t_Major = 0x00;
            t_Minor = 0x00;
            t_len = (int)(((rtn.at(13)&0x00ff)<<8)|(rtn.at(14)&0x00ff));
            if(t_len>0){
                for(i=0;i<t_len;i++){
                    t_DeviceTypeId[i] = rtn.at(15+i)&0xff;
                }
                t_DeviceTypeId[t_len]=0x00;
            }
            t_Major = rtn.at(16+t_len)&0xff;
            t_Minor = rtn.at(17+t_len)&0xff;
            t_Length = ((rtn.at(18+t_len)&0x000000ff)<<24)|((rtn.at(19+t_len)&0x000000ff)<<16)|((rtn.at(20+t_len)&0x000000ff)<<8)|(rtn.at(21+t_len)&0x000000ff);
            crc_len = (int)(((rtn.at(22+t_len)&0x00ff)<<8)|(rtn.at(23+t_len)&0x00ff));
            if(crc_len>0){
                for(i=0;i<crc_len;i++){
                    t_Checksum[i] = rtn.at(24+t_len+i);
                }
                t_Checksum[crc_len]=0x00;
            }
            t_UpTime = ((rtn.at(25+t_len+crc_len)&0x000000ff)<<24)|((rtn.at(26+t_len+crc_len)&0x000000ff)<<16)|((rtn.at(27+t_len+crc_len)&0x000000ff)<<8)|(rtn.at(28+t_len+crc_len)&0x000000ff);
            printf("t_DeviceTypeId [%s], APP_ID [%s]\n",t_DeviceTypeId,APP_ID);
            printf("t_Major*256+t_Minor [%d], Major*256+Minor [%d]\n",t_Major*256+t_Minor,Major*256+Minor);
            printf("t_UpTime [%ld], UpTime [%ld]\n",t_UpTime,UpTime);
            printf("t_UpTime yyyymmddhh: %s, current yyyymmddhh %s\n",(QDateTime::fromTime_t(t_UpTime)).toString("yyyy-MM-dd hh").toUtf8().data(),QDateTime::currentDateTime().toString("yyyy-MM-dd hh").toUtf8().data());
            printf("t_Checksum [%s], Checksum [%s]\n",t_Checksum,Checksum);

            if(strcmp((QDateTime::fromTime_t(t_UpTime)).toString("yyyy-MM-dd hh").toUtf8().data(),QDateTime::currentDateTime().toString("yyyy-MM-dd hh").toUtf8().data())==0){
                printf("equal test\n");
                if(strcmp(t_DeviceTypeId,APP_ID)!=0)
                    return false;
                if((t_Major*256+t_Minor)<(Major*256+Minor))
                    return false;
                if(t_UpTime==UpTime)
                    return false;
                if(strcmp(t_Checksum,Checksum)==0)
                    return false;
            }else{
                return false;
            }
        }
            break;
        case 0x02:
        {
            bzero(t_DeviceTypeId,sizeof(t_DeviceTypeId));
            bzero(data,sizeof(data));
            t_len = (int)(((rtn.at(13)&0x00ff)<<8)|(rtn.at(14)&0x00ff));
            if(t_len>0){
                for(i=0;i<t_len;i++){
                    t_DeviceTypeId[i] = rtn.at(15+i)&0xff;
                }
                t_DeviceTypeId[t_len]=0x00;
            }
            if((t_Major!=(rtn.at(16+t_len)&0xff))||(t_Minor!=(rtn.at(17+t_len)&0xff)))
                return false;
            if(strcmp(t_DeviceTypeId,APP_ID)!=0)
                return false;
            pro_len = ((rtn.at(20+t_len)&0x00ff)<<8)|(rtn.at(21+t_len)&0x00ff);
            for(i=0;i<pro_len;i++){
                data[i] = rtn.at(22+t_len+i)&0xff;
                datachk += (rtn.at(22+t_len+i)&0x00ff);
                //datachk = (datachk+rtn.at(22+t_len+i)&0x00ff)&0xffff;
            }
            MD5Update (&context, data, pro_len);
            t_datachk = ((rtn.at(23+t_len+pro_len)&0x00ff)<<8)|(rtn.at(24+t_len+pro_len)&0x00ff);
            if(t_datachk==datachk){
                fwrite(data,pro_len,1,fd);
            }else{
                return false;
            }
        }
        break;
    }
    return true;
}

void dogThread::chk_version()
{
    unsigned char cmd[1024], md5[16];
    char chksum[33];
    int len,times;
    QByteArray Rtn;
    FILE *pfile;
    so->connectToHost("172.16.120.191",51212);
    if(so->waitForConnected(3000)){
        set_termtime();
        len = mk_verqry(cmd);
        if(len>0){
            so->write((const char *)cmd,len);
            if(so->waitForBytesWritten(3000)){
                set_termtime();
                if(so->waitForReadyRead(3000)){
                    set_termtime();
                    Rtn = so->readAll();
                    QString dataTmp = "";
                    for(int i=0;i<Rtn.length();i++){
                        dataTmp.append(QString("%1").arg(Rtn.at(i)&0xff,2,16,QChar('0')));
                    }
                    printf("dataTmp [%s]\n",dataTmp.toUtf8().data());
                    if(!check_frame(Rtn,0,NULL)){
                        so->abort();
                        return;
                    }else{
                        times = t_Length>>10;
                        if(t_Length&1023)
                            times++;
                        pfile = fopen("/home/zyj/IOT-03/program.tmp","wb");
                        if(pfile!=NULL){
                            MD5Init (&context);
                            for(int i=0;i<times;i++){
                                len = mk_proqry(cmd,i);
                                if(len>0){
                                    so->write((const char *)cmd,len);
                                    if(so->waitForBytesWritten(3000)){
                                        set_termtime();
                                        if(so->waitForReadyRead(3000)){
                                            set_termtime();
                                            Rtn = so->readAll();
                                            if(!check_frame(Rtn,i,pfile)){
                                                fclose(pfile);
                                                so->abort();
                                                return;
                                            }
                                        }else
                                            break;
                                    }else
                                        break;
                                }
                            }
                            fclose(pfile);
                            so->close();
                            printf("222222\n");
//                            MD5Final (md5, &context);
//                            for(int i=0;i<16;i++){
//                                if(((md5[i]>>4)&0x0f)<0x0a)
//                                    chksum[i*2+0] = (md5[i]>>4)|0x30;
//                                else
//                                    chksum[i*2+0] = (md5[i]>>4)+0x57;
//                                if((md5[i]&0x0f)<0x0a)
//                                    chksum[i*2+1] = (md5[i]&0x0f)|0x30;
//                                else
//                                    chksum[i*2+1] = (md5[i]&0x0f)+0x57;
//                            }
//                            chksum[32]=0x00;
                            QString md5;
                            int len=0;
                            FILE *file;
                            unsigned char buffer[1024];
                            QCryptographicHash hash(QCryptographicHash::Md5);
                            if((file=fopen("/home/zyj/IOT-03/program.tmp","rb"))!=NULL){
                                while ((len=fread(buffer,1,1024,file))>0) {
                                    hash.addData(QByteArray((const char*)buffer,len));
                                }
                                md5.append(hash.result().toHex());
                                fclose(file);
                            }
                            printf("33333333 chksum [%s], t_Checksum [%s]\n",md5.toUtf8().data(),t_Checksum);
                            if(strcmp(md5.toUtf8().data(),t_Checksum)==0){
                                Major = t_Major;
                                Minor = t_Minor;
                                Length =t_Length;
                                UpTime = t_UpTime;
                                sprintf(Checksum,"%s",md5.toUtf8().data());
                                save_cfg();
                                runFlag = true;
                                system("killall ytCore");
                                rename("/home/zyj/IOT-03/program.tmp","/home/zyj/IOT-03/ytCore");
                                system("chmod +x /home/zyj/IOT-03/ytCore");
                                sleep(3);
                                system("reboot");
                            }
                        }
                    }
                }
            }
        }
    }
}

void dogThread::set_termtime()
{
    QDateTime  curDatetime = QDateTime::currentDateTime();
    uint chkTime = curDatetime.toTime_t();
    ytShm->currentTime.YEAR = curDatetime.date().year()&0xffff;
    ytShm->currentTime.MONTH = curDatetime.date().month()&0xff;
    ytShm->currentTime.DAY = curDatetime.date().day()&0xff;
    ytShm->currentTime.HOUR = curDatetime.time().hour()&0xff;
    ytShm->currentTime.MINUTE = curDatetime.time().minute()&0xff;
    ytShm->currentTime.SECOND = curDatetime.time().second()&0xff;
    ytShm->currentTime.TIMESTAMP = chkTime;
}

void dogThread::run()
{
    QDateTime curDatetime;
    so = new QTcpSocket;
    load_param();
    chk_file();
    if(!runFlag)
        chk_version();

    while(runFlag)
    {
        bool restart_app = false;
        curDatetime = QDateTime::currentDateTime();
        uint chkTime = curDatetime.toTime_t();
        set_termtime();
        for(quint8 i=1;i<60;i++)
        {
            if(ytShm->dogTimeList.dogTime[i].ENABLED==0x01){
                if((ytShm->dogTimeList.dogTime[i].LASTFEED<chkTime)
                        &&((chkTime>(ytShm->dogTimeList.dogTime[i].LASTFEED
                                     +ytShm->dogTimeList.dogTime[i].WAITSEC))))
                {
                    restart_app = true;
                    break;
                }
            }
        }
        if(restart_app)
        {
            system(QString("killall %1").arg(APP_NAME).toUtf8().data());
            usleep(500000);
            start_app();
        }else if((curDatetime.time().hour()!=start_h)&&(curDatetime.time().minute()>12)){
            chk_version();
            start_h = curDatetime.time().hour();
        }
        sleep(1);
    }

//    while(runFlag)
//    {
//        bool restart_app = false;
//        curDatetime = QDateTime::currentDateTime();
//        uint chkTime = curDatetime.toTime_t();
//        set_termtime();
//        for(quint8 i=1;i<60;i++)
//        {
//            if(ytShm->dogTimeList.dogTime[i].ENABLED==0x01){
//                if((ytShm->dogTimeList.dogTime[i].LASTFEED<chkTime)
//                        &&((chkTime>(ytShm->dogTimeList.dogTime[i].LASTFEED
//                                     +ytShm->dogTimeList.dogTime[i].WAITSEC))))
//                {
//                    restart_app = true;
//                    break;
//                }
//            }
//        }
//        if(restart_app)
//        {
//            system(QString("killall %1").arg(APP_NAME).toUtf8().data());
//            usleep(500000);
//            start_app();
//        }
//        sleep(1);
//    }
}

void dogThread::chk_file()
{
    int i,len;
    unsigned char md5[16];
    QCryptographicHash hash(QCryptographicHash::Md5);
    unsigned char buffer[1024];
//    char MD5[33];
    QString MD5;
    FILE *file = fopen("/home/zyj/IOT-03/ytCore","rb");
    if(file!=NULL){
//        MD5Init (&context);
//        while((len=fread (buffer, 1, 1024, file))>0){
//            MD5Update (&context, buffer, len);
//        }
//        fclose(file);
//        MD5Final (md5, &context);
//        for(i=0;i<16;i++){
//            if(((md5[i]>>4)&0x0f)<0x0a)
//                MD5[i*2+0] = (md5[i]>>4)|0x30;
//            else
//                MD5[i*2+0] = (md5[i]>>4)+0x57;
//            if((md5[i]&0x0f)<0x0a)
//                MD5[i*2+1] = (md5[i]&0x0f)|0x30;
//            else
//                MD5[i*2+1] = (md5[i]&0x0f)+0x57;
//        }
//        MD5[32] = 0x00;
        while ((len=fread(buffer,1,1024,file))>0) {
            hash.addData(QByteArray((const char*)buffer,len));
        }
        MD5.append(hash.result().toHex());
        fclose(file);
        printf("MD5: %s\n",MD5.toUtf8().data());
        if(strcmp(MD5.toUtf8().data(),Checksum)==0){
            system("chmod +x /home/zyj/IOT-03/ytCore");
            runFlag = true;
            system("./ytCore &");
        }
    }
}

void dogThread::trim(char *buf, char *dat)
{
    int i,n=0;
    bool start = false;
    for(i=0;i<256;i++)
        dat[i] = 0x00;
    for(i=0;i<strlen(buf);i++){
        if(!start){
            if(!isspace(buf[i])){
                start = true;
                if(isprint(buf[i]))
                    dat[n++] = buf[i];
            }
        }else if(isprint(buf[i]))
            dat[n++] = buf[i];
    }
    for(i=(strlen(dat)-1);i>=0;i--){
        if((!isspace(dat[i]))&&(isprint(buf[i]))&&(buf[i]!='\r')&&(buf[i]!='\n'))
            break;
        else
            dat[i] = 0x00;
    }
}

void dogThread::chk_param(char *buf)
{
    char name[256],value[256];
    char tmp[256];
    int i,n=0;
    bool start = false;
    bzero(name,sizeof(name));
    bzero(value,sizeof(value));
    trim(buf,tmp);
    for(i=0;i<strlen(tmp);i++){
        buf[i] = tmp[i];
        buf[i+1] = 0x00;
    }
    buf[strlen(tmp)] = 0x00;
    if(buf[0]=='#')
        return;
    for(i=0;i<strlen(buf);i++){
        if(!start){
            if(buf[i]=='='){
                start = true;
                n=0;
            }else
                name[n++] = buf[i];
        }else{
            value[n++] = buf[i];
        }
    }
    trim(name,tmp);
    bzero(name,sizeof(name));
    for(i=0;i<strlen(tmp);i++)
        name[i] = toupper(tmp[i]);
    name[strlen(tmp)]=0x00;
    trim(value,tmp);
    bzero(value,sizeof(value));
    for(i=0;i<strlen(tmp);i++)
        value[i] = tmp[i];
    value[strlen(tmp)]=0x00;
    if(strcmp(name,"MAJOR")==0)
        Major = atoi(value)&0xff;
    else if(strcmp(name,"MINOR")==0)
        Minor = atoi(value)&0xff;
    else if(strcmp(name,"LENGTH")==0)
        Length = atol(value)&0xffffffff;
    else if(strcmp(name,"UPTIME")==0)
        UpTime = atoll(value)&0xffffffff;
    else if(strcmp(name,"CHECKSUM")==0){
        for(i=0;i<32;i++)
            Checksum[i] = value[i];
        Checksum[32] = 0x00;
        printf("md5: %s\n",Checksum);
    }

}

bool dogThread::load_param()
{
    char buf[256];
        FILE *file = fopen(daefile,"r");
        if(file!=NULL){
            while(!feof(file)){
                fgets(buf,256,file);
                chk_param(buf);
            }
            fclose(file);
            return true;
        }
        return false;
}

void dogThread::save_cfg()
{
    FILE *file;
    char str[256];
    QDateTime dt = QDateTime::currentDateTime();
    file = fopen(daefile,"w");
    sprintf(str,"###################\r\n");
    printf("%s",str);
    fwrite(str,strlen(str),1,file);
    sprintf(str,"# Program Version File\r\n");
    printf("%s",str);
    fwrite(str,strlen(str),1,file);
    sprintf(str,"# Auto Create at %04d-%02d-%02d %02d:%02d:%02d\r\n"
            ,dt.date().year(),dt.date().month(),dt.date().day()
            ,dt.time().hour(),dt.time().minute(),dt.time().second());
    printf("%s",str);
    fwrite(str,strlen(str),1,file);
    sprintf(str,"###################\r\n\r\n");
    printf("%s",str);
    fwrite(str,strlen(str),1,file);
    printf("%s",str);
    sprintf(str,"DEVTYPE= %s\r\n",APP_ID);
    fwrite(str,strlen(str),1,file);
    printf("%s",str);
    sprintf(str,"MAJOR= %d\r\n",Major);
    fwrite(str,strlen(str),1,file);
    printf("%s",str);
    sprintf(str,"MINOR = %d\r\n",Minor);
    fwrite(str,strlen(str),1,file);
    printf("%s",str);
    sprintf(str,"LENGTH = %ld\r\n",Length);
    fwrite(str,strlen(str),1,file);
    printf("%s",str);
    sprintf(str,"UPTIME = %ld\r\n",UpTime);
    fwrite(str,strlen(str),1,file);
    printf("%s",str);
    sprintf(str,"CHECKSUM = %s\r\n",Checksum);
    fwrite(str,strlen(str),1,file);
    printf("%s",str);
    fflush(file);
    fclose(file);
    runFlag=true;
}