客户端网络

socket.cpp

#include "soket.h"
#include <iostream>

#define SLEEP_SECEND 1000000*0.001 // 1S
#pragma comment(lib,"ws2_32.lib")

/*QT封装*/
CSoket::CSoket()
{
    InitNet();
}

CSoket::~CSoket()
{
    UinitNet();
}

bool CSoket::StartNetServer()
{
    //创建套接字

    //连接
    Connect(client, SERVER_IP, SERVER_PORT);
}

bool CSoket::InitNet()
{
    //初始化网络环境
    WSAData wsaData;
    int nRet = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (nRet != INVALID_SOCKET)
            return true;
    else
       // UiLog("初始化网络环境失败\n");
    return false;
}

SOCKET CSoket::Socket()
{
    //创建套接字
    SOCKET sock = socket(AF_INET, SOCK_STREAM,0);
    if (sock != INVALID_SOCKET)
    {
        //UiLog("创建套接字成功\n");
        return sock;
    }

    //UiLog("创建套接字失败\n");
    return INVALID_SOCKET;
}

char* CSoket::startLoop(const char ip[],int port,int* len_)
{
    char* pBuf = nullptr;
    if(client != INVALID_SOCKET)
    {
        int len = Recv();
        if(len > 0)
        {
            *len_ = len;
            return m_recvBuf;
        }
        else
        {
            return nullptr;
        }
    }
    else
    {
        client = Socket();
        if(!Connect(client, ip, port))
        {
            qDebug()<<"连接服务失败，等待重连...";
            client = INVALID_SOCKET;
        }
        else
        {
           QString ip_ = ip;
          qDebug()<<"连接服务成功！ip：" + ip_ + " port:" + QString::number(port);
        }
    }

    return pBuf;
}

bool CSoket::Connect(SOCKET sock, const char ip[], int port)
{
    //设置IPV4协议
    SOCKADDR_IN sAddr;
    sAddr.sin_addr.S_un.S_addr = inet_addr(ip);
    sAddr.sin_port = htons(port);
    sAddr.sin_family = AF_INET;
    int nRet = ::connect(sock, (sockaddr*)&sAddr, (unsigned int)sizeof(sAddr));
    if (nRet == SOCKET_ERROR)
    {
        return false;
    }
    //UiLog("连接服务成功！");
    return true;
}

void CSoket::UinitNet()
{
    //卸载网络环境
    WSACleanup();
}


int CSoket::Recv()
{
    if(client == INVALID_SOCKET)
        return -1;
    fd_set t_set;
    FD_ZERO(&t_set);
    FD_SET(client, &t_set);
    m_outtime.tv_sec = 0;
    m_outtime.tv_usec = 0;
    int result = select(client + 1, &t_set,NULL,NULL, &m_outtime);
    if (-1 == result)
    {
        if (EINTR != errno)
        {
            qDebug("select error ,errno = %d",QString::number(errno));
            CLoseSocket();
            return -1;
        }
    }
    else if (0 == result)
    {
        return 0;
    }
    else
    {
        memset(&m_recvBuf, 0x0, sizeof(m_recvBuf));
        int  ret = recv(client, m_recvBuf, MAX_RECVBUF_LENTH, 0);
        if (ret <= 0)
        {
            UiLog("服务端断开连接");
            CLoseSocket();
            return -1;
        }
        else
        {
            if(soName == "REMOTE")
            {
                int msglen = Parsemsgfrombuf(m_recvBuf);

                qDebug()<<"Parsemsgfrombuf 长度"<<msglen;
                if(msglen <= 0 || msglen >= 65355)
                    return -1;
            }
        }
    }

    return 1;
}

/*打消息头 所有发送消息的通用接口*/
int CSoket::Send(char *p, int len)
{
    uint32_t msglen = ntohl(len);
    struct iovec iov[2];
    iov[0].iov_base = &msglen;
    iov[0].iov_len = sizeof(uint32_t);
    iov[1].iov_base = p;
    iov[1].iov_len = len;
    return sendv(client, iov, 2);
}

void CSoket::CLoseSocket()
{
    //卸载网络环境
    closesocket(client);
    client = INVALID_SOCKET;
}

/*************************************************************/
/*************************************************************/
/*************************************************************/
/*---------分-----------------割-----------------线---------*/


bool CSoket::SendMsgInterface(QString SendBuf)
{
    //UiLog("发送消息");
    QByteArray ba = SendBuf.toLatin1();
    char* msg = ba.data();

    int msglen = strlen(msg)+1;
    if( Send(msg,msglen) <= 0 )
    {
        //UiLog("发送消息失败");
        CLoseSocket();
    }
}

bool CSoket::SendMsgInterface(T_Message* pInmsg,int msglen)
{
    if(!pInmsg)
    {
        UiLog("SendMsgInterface 入参 pInmsg 为空");
    }

    CSendTr Tr;
    Tr.m_len =  msglen + 8; //pInmsg 消息体总长度

    memcpy(Tr.m_send_buf,(char*)pInmsg,sizeof(T_Message));

    int sLen = send(client,(const char*)&Tr,msglen + 12,0);

    if( sLen <= 0 )
    {
        UiLog("pInmsg 网络断开，发送消息失败");
        CLoseSocket();
    }
    else
    {
        UiLog("pInmsg 发送消息成功，发送长度："+QString::number(sLen)+"  消息体长度："+QString::number(msglen+4));
    }
}

bool CSoket::SendMsgInterface(char* msg)
{
    if(!msg)
    {
        //UiLog("msg 为空");
    }

    int msglen = strlen(msg)+1;
    if( Send(msg,msglen) <= 0 )
    {
       // UiLog("发送消息失败");
        CLoseSocket();
    }
}

int CSoket::Parsemsgfrombuf(char *pbuf)
{
    if(!pbuf)
        return -1;
    int len = 0;
    memcpy(&len,pbuf,sizeof(int));
    len = ntohl(len);
    pbuf=pbuf+sizeof(int);
    return len;
}

void CSoket::ProcASyncMsg(void * pInmsg,int Msglen)
{
    if( !pInmsg)
    {
        return;
    }
    qDebug()<<"解析数据";
    T_Message *ptMsg = (T_Message * )pInmsg;
    switch ((unsigned int)ntohl((ptMsg->m_ucMessage)))
    {
        case SERVER_R_CLIENT_UPGRADE:
        {
            //log recevie msg
            qDebug()<<"收到升级url %s"<<ptMsg->m_pMsgcontent;
            break;
        }
        case SERVER_R_CLEINT_UPGRADEVERSION:
        {
            //log recevie msg
            qDebug()<<"收到版本号 %s"<<ptMsg->m_pMsgcontent;
            break;
        }
        default:
        {
           qDebug()<<"消息类型错误 ";
            break;
        }
    }
}

bool CSoket::Getupdataurl()
{
    qDebug()<<"获取升级url";
    T_Message tmessage;
    tmessage.m_ucMessage   = htonl(CLIENT_G_SERVER_UPGRADEURL);
    tmessage.m_Msglen      = 0;
    Send((char *)&tmessage,sizeof(T_Message));
        return false;
    return true;
}

soket.h

#ifndef SOKET_H
#define SOKET_H

#include "common.h"
#include "Msgcommon.h"
#include <WinSock2.h>
#include "buffer.h"
#include "threadbase.h"

struct iovec{
    void *iov_base; /* Pointer to data. */
    size_t iov_len; /* Length of data. */
};
///*实现类似于writev功能*/
static long sendv(int socket , struct iovec *iov , int count)
{
    long totallen ,tlen = -1;
    while(count)
    {
        tlen = send(socket, (const char*)iov->iov_base,iov->iov_len,0);
        if(tlen < 0)
        return totallen;
        totallen+=tlen;
        iov++;
        count--;
    }
}
//#if 0
//static long readv(int socket , struct iovec *iov , int count)
//{

//  long totallen ,tlen = -1;
//  while (count)
//  {

//    tlen = recv(socket, iov->iov_base, iov->iov_len);
//    if (tlen <= 0)
//      return totallen;
//     totallen+=tlen;
//    iov++;
//    count--;

//}
//#endif

class CSoket
{
public:
    CSoket();
   ~CSoket();
public:
    bool InitNet();
    void UinitNet();
    bool Connect(SOCKET sock, const char ip[], int port);
    char* startLoop(const char ip[],int port,int*);
    SOCKET Socket();
    int Recv();
    int Send(char *p, int len);
    void CLoseSocket();
    bool StartNetServer();
    bool SendMsgInterface(QString SendBuf);
    bool SendMsgInterface(char*);
    bool SendMsgInterface(T_Message*,int msglen);
    int Parsemsgfrombuf(char* pbuf);
    void ProcASyncMsg(void * pInmsg, int Msglen);

    /*************************************************************/
    /*--------------------------GET--------------------------*/
    bool Getupdataurl();



    /*************************************************************/
    /*--------------------------SET--------------------------*/

    /*************************************************************/
    /*--------------------------REPORT-----------------------*/
    //bool Report


    char m_recvBuf[MAX_RECVBUF_LENTH] = { 0 };
private:
    SOCKET client = {INVALID_SOCKET};
    timeval m_outtime;
    Buffer inputBuffer_;
    Buffer outputBuffer_;
public:
    QString soName;
};

#endif // SOKET_H

Msgcommon.h

#ifndef _MSGCOMMON_H_
#define _MSGCOMMON_H_
#include <string>
#include <iostream>
using namespace std;

#define MAX_MSG_LEN sizeof(T_ConsoleMsg)

//#define MAX_CONSOLE_MSG_LEN 4096

#define MAX_COMMON_MSG_LEN 1024

#define CLI_SERVER_BEGIN                      0x10000000
#define SERVER_CLI_BEGIN                      0x50000000

#define CLI_GET                               CLI_SERVER_BEGIN + 0x00010000
#define CLI_SET                               CLI_SERVER_BEGIN + 0x00020000
#define CLI_REPORT                            CLI_SERVER_BEGIN + 0x00030000

#define SERVER_GET                            SERVER_CLI_BEGIN + 0x00010000
#define SERVER_SET                            SERVER_CLI_BEGIN + 0x00020000
#define SERVER_REPORT                         SERVER_CLI_BEGIN + 0x00030000

#define LOCAT_CLI_GET                         CLI_SERVER_BEGIN + 0x00040000
#define LOCAT_CLI_SET                         CLI_SERVER_BEGIN + 0x00050000
#define LOCAT_CLI_REPORT                      CLI_SERVER_BEGIN + 0x00060000

#define LOCAT_SERVER_GET                      SERVER_CLI_BEGIN + 0x00040000
#define LOCAT_SERVER_SET                      SERVER_CLI_BEGIN + 0x00050000
#define LOCAT_SERVER_REPORT                   SERVER_CLI_BEGIN + 0x00060000

#define MAX_RECVBUF_LENTH                     1700
#define MAX_SEND_LENTH                        1400
#define SERVER_IP                             "10.234.19.202"
#define SERVER_PORT                           40000

#define LOCAL_SERVER_IP                       "127.0.0.1"
#define LOCAL_SERVER_PORT                     8000

#define LOGTOOL_UPGRADE_URL                   "http://10.234.19.202/logTool_boxed.exe"
/*客户端向远端服务端发送消息定义*/
/*GET*/
#define CLIENT_G_SERVER_UPGRADEURL            CLI_GET + 0x00000001 //获取升级链接
#define CLIENT_G_SERVER_UPGRADEVERSION        CLI_GET + 0x00000002 //获取版本号
#define CLIENT_G_SERVER_UPGRADE_LOG           CLI_GET + 0x00000003 //获取远端更新日志
/*SET*/

/*REPORT*/



/*远端服务端向客户端发送消息定义*/
/*GET*/

/*SET*/

/*REPORT*/
#define SERVER_R_CLIENT_UPGRADE                 SERVER_REPORT    + 0x00000001   //URL
#define SERVER_R_CLEINT_UPGRADEVERSION          SERVER_REPORT    + 0x00000002   //版本号
#define SERVER_R_CLEINT_UPGRADE_LOG             SERVER_REPORT    + 0x00000003   //远端回复更新日志
/*本地客户端向本地服务端（升级进程）发送消息定义*/
/*GET*/


/*SET*/
#define LOCAL_CLIENT_S_CARRY_UPDATE              LOCAT_CLI_SET + 0x00000001 /* 执行更新 */
#define LOCAL_CLIENT_S_QUIT_UPDATE_PROGRAMA      LOCAT_CLI_SET + 0x00000002 /* 退出升级进程 */

/*REPORT*/
#define LOCAL_CLIENT_R_SERVER_HEART_BEAT         LOCAT_CLI_REPORT + 0x00000001  /* 客户端心跳 */

/*本地服务端向客户端发送消息定义*/
/*GET*/

/*SET*/

/*REPORT*/
#define LOCAL_SERVER_R_CLIENT_HEART_BEAT         LOCAT_SERVER_REPORT    + 0x00000001 /* 服务端心跳 */
#define LOCAL_SERVER_R_CLIENT_INFO_UPDATE        LOCAT_SERVER_REPORT    + 0x00000002 /* 提示用户更新 */

/*对消息类型进行整体分类*/
enum MSG_TYPE{
   CLI_LOGIN       = 1,
   CLI_LOGOUT      = 2,
   CLI_COMMON_MSG  = 3,
   CLI_KEEP_ALIVE  = 4,
};

typedef	struct
{
   int 	dwFrameLength;                      /* 消息帧长度，这里代表以字节为单位的本消息帧的总长度 */
   unsigned char 	bFrameHead;					/* 消息头指示，固定为0xAAH */
   unsigned char	ucCommand;					/* 消息类型 */
}
T_ConsoleMsgHeader;						/* 和PC控制台交互消息头部结构*/

/*common_msg 解析结构体 */
typedef struct{
   unsigned int        MessageType;
   unsigned int        MessageLen;
   unsigned char       MessageCont[MAX_COMMON_MSG_LEN];
}T_CommonMsg;

typedef	struct
{
   T_ConsoleMsgHeader	tMsgHead;		/* 消息头部结构 */
   T_CommonMsg	        acMsg;	/* 消息正文 */
   unsigned char	    bFrameTail;					/* 消息尾，固定为0x55H */
}
T_ConsoleMsg;							/* 和PC控制台交互消息结构*/

class CMsgTr
{
public:
   unsigned char m_templet_Name[100];
   int m_Model_score;
};

class T_Message{
public:
    T_Message():m_ucMessage(0),m_Msglen(0)
    {
        memset(m_pMsgcontent,0x0,MAX_SEND_LENTH);
    };
    ~T_Message(){};

public:
    unsigned int    m_ucMessage;//消息号
    int             m_Msglen;//数组长度
    char            m_pMsgcontent[MAX_SEND_LENTH];
};

typedef	struct
{
    int m_len;
    unsigned char m_send_buf[sizeof(T_Message)+1];
}CSendTr;

class CCheckUpdate
{
public:
    char m_Url[256];          /* url链接 */
    char m_abstr[256];        /* 软件相对位置 */
};
#endif //end of _MSGCOMMON_H_

Business process

#ifndef NET_CLIENT_H
#define NET_CLIENT_H

#include "common.h"
#include "threadbase.h"
#include "soket.h"
#include <QProcess>
class CNet_client : public ThreadBase
{
    Q_OBJECT

public:
    CNet_client();
public:
    virtual void RunTask();
    virtual bool TaskDispatch(const UiActions uiactions);

    /* 业务开始 */
public:
    void QuitUpdateProgram();//退出升级进程
    void ObtainVirtualVersion();//获取虚拟工具版本号
    void WriteLocalVersion(QString);
    void ObtainRemoteVersion();//获取本地工具版本号
    void ObtainRemoteUrl(); //获取URL
    void ObtainRemoteLog(); //获取更新说明
    bool CompareVersion();//比对版本号
    void InfoUserUpdate();//提示用户更新
    void InfoUserNoUpdate();//提示用户没有更新
    void CarryUpdate();//执行更新
    void HandelLocalRecv();
    void HandRemoteRecv();
    void SendHartBeat();
    void ProcASyncMsg(void * pInmsg,int Msglen);
    bool WhetherProcessRunning(QString processName);
    void UpgradeEngine();
    void StratProcess(QString path);
    void CheckVersionNum();//检查本地版本号和拷贝文件版本号是否一致

private:
    void TimerInit_();

private slots:
    void on_timer_timeout();

private:
    QString m_VirtualVersionNum;//虚拟文件版本号
    QString m_RemoteVersionNum;//服务器版本号
    CCheckUpdate m_CheckUpdate; //版本号和升级链接
    bool isBootCheckUpdate{false};  //是否有检查更新
    QString m_UpgradeLog;
    CSoket m_Localclient;//本地通信，进程间通信
    CSoket m_client;//服务器通信
    char m_recvBuf[MAX_RECVBUF_LENTH] = { 0 };
    char m_Temp[3000] = {0};
    QTimer *m_timer_ = nullptr;        /* 定时器 */
public:
    QProcess *m_pTest;
    /* 业务结束 */
};
#endif // NET_CLIENT_H

#include "net_client.h"
#include <iostream>
#include "Msgcommon.h"

#define SLEEP_SECEND 1000000 // 1S
#define UPGREAD_PROCESS_NAME "Upgrade.exe"
#define VERSION_TXT_PATH "version.txt"

extern MainInterfaceVar g_mainVars;

/*QT封装*/
CNet_client::CNet_client()
{
    m_threadName = NET_THREAD;
}

void CNet_client::RunTask()
{
    m_Localclient.soName = "LOCAL";
    m_client.soName = "REMOTE";

    UpgradeEngine();//巡检和RF阶段不拉起来

    //获取虚拟文件版本号是否异常
    ObtainVirtualVersion();
    TimerInit_();
    while(1)
    {
       QApplication::processEvents();      /* 处理其他线程发过来的信号等事件 */
       QThread::usleep(SLEEP_SECEND);
       HandelLocalRecv();
       HandRemoteRecv();
       //SendHartBeat();  /* 定时发送心跳 */
    }
}

/*
*工具启动拉起后需要主动检查更新，如果有更新立即使用服务端的url链接下载到本地
*
    1、获取当前版本号
    2、向服务端请求最新版本号
    3、比对版本号，版本号相同则不处理
    4、版本号不一致则立即使用服务端的url链接下载到本地
    5、下载完成提升用户更新
    6、用户确认后工具立即退出，升级进程将文件移动到原先的目录，并重新拉起工具进程
*/


/* 线程通信 */
bool CNet_client::TaskDispatch(const UiActions uiactions)
{
    e_actionType action = uiactions.e_action;

    switch (action)
    {
        case HTML_TO_NET_STATISTIC_INFO:
        {
            //统计信息
            break;
        }
        case UI_TO_NET_CHECK_UPDATE:
        {
            ObtainRemoteVersion();
            break;
        }
        case UI_TO_NET_CARRY_UPDATE:
        {
            //执行更新先获取URL
            ObtainRemoteUrl();
            break;
        }
        case UI_TO_NET_QUIT_UPDATE_PROGRAMA:
        {
            QuitUpdateProgram();
            break;
        }
        default:break;
    }

    return true;
}

//本地进程间接收消息业务
void CNet_client::ProcASyncMsg(void * pInmsg,int Msglen)
{
    T_Message *ptMsg = (T_Message * )pInmsg;

    switch ((unsigned int)((ptMsg->m_ucMessage)))
    {
        case LOCAL_SERVER_R_CLIENT_HEART_BEAT:
        {
            UiLog("收到升级进程心跳");
            break;
        }
        case LOCAL_SERVER_R_CLIENT_INFO_UPDATE:
        {
            UiLog("提示用户更新");
            
            InfoUserUpdate();
            break;
        }
        default:
        {
            UiLog("消息类型错误 ");
            break;
        }
    }
}

//远端服务接收消息业务
void CNet_client::HandRemoteRecv()
{
    int len = 0;
    char* pInmsg = m_client.startLoop(SERVER_IP,SERVER_PORT,&len);

    if( !pInmsg)
    {
        return;
    }
    pInmsg = pInmsg+4;
    T_Message *ptMsg = (T_Message * )pInmsg;

    switch ((unsigned int)ntohl((ptMsg->m_ucMessage)))
    {
        case SERVER_R_CLIENT_UPGRADE:
        {
            //收到升级url
            qDebug("收到升级url： %s",ptMsg->m_pMsgcontent);

            //填充升级链接
            memset(m_CheckUpdate.m_Url,0,256);
            memcpy(m_CheckUpdate.m_Url,ptMsg->m_pMsgcontent,ptMsg->m_Msglen+1);

            //填充软件相对位置
            memset(m_CheckUpdate.m_abstr,0,256);
            QString absDir = QCoreApplication::applicationDirPath();
            memcpy(m_CheckUpdate.m_abstr,absDir.toStdString().c_str(),absDir.length());

            //***执行更新***
            CarryUpdate();
            break;
        }
        case SERVER_R_CLEINT_UPGRADEVERSION:
        {
            //收到版本号
            memset(m_Temp,0,sizeof(m_Temp));
            memcpy(m_Temp,ptMsg->m_pMsgcontent,ptMsg->m_Msglen+1);
            m_RemoteVersionNum = QString::fromLocal8Bit(m_Temp,strlen(m_Temp));

            qDebug()<<"远端版本号 "<<m_RemoteVersionNum;
            qDebug()<<"本地版本号 "<<m_VirtualVersionNum;

            if(CompareVersion())
            {
                //有更新，获取远端跟新说明
                ObtainRemoteLog();
            }
            else
            {
                qDebug()<<"没有更新";
                //提示主界面弹窗无更新,开机自动检查更新不弹出
                if(isBootCheckUpdate)
                {
                    InfoUserNoUpdate();
                }
                else
                {
                    isBootCheckUpdate = true;
                }
            }
            break;
        }
        case SERVER_R_CLEINT_UPGRADE_LOG:
        {
            //收到更新说明
            qDebug()<<"收到更新说明";
            memset(m_Temp,0,sizeof(m_Temp));
            memcpy(m_Temp,ptMsg->m_pMsgcontent,ptMsg->m_Msglen+1);
            m_UpgradeLog = QString::fromLocal8Bit(m_Temp,strlen(m_Temp));

            //发送更新提示给主线程
            InfoUserUpdate();
        }
        default:
        {
            qDebug()<<"消息类型错误 ";
            break;
        }
    }
}

void CNet_client::CheckVersionNum()
{

    //这里后续要连接服务器直接比对
}

void CNet_client::UpgradeEngine()
{
    bool isRunging = WhetherProcessRunning(UPGREAD_PROCESS_NAME);
    if(!isRunging)
    {
        //起进程
        qDebug()<<"起进程";
        QString absDir = QCoreApplication::applicationDirPath();
        QString updateEngin = absDir + BOX_ROOT_DIR + UPGRADE_PATH + UPGREAD_PROCESS_NAME;
        qDebug()<<"path:"<<updateEngin;

        StratProcess(updateEngin);
    }
    else
    {
        UiLog("进程已在运行");
    }
}

void CNet_client::StratProcess(QString path)
{
    m_pTest->startDetached(path);
}

bool CNet_client::WhetherProcessRunning(QString processName)
{
    QProcess process;
    QString cmd = "tasklist";
    process.start(cmd);
    process.waitForFinished();                    //等待进程结束
    QString str = process.readAllStandardOutput();//获取执行命令后的输出内容

    if(str.contains(processName))//判断是否有包含当前指定的进程名
    {
        return true;
    }
    else
    {
        return false;
    }
}

//进程通信消息接收业务
void CNet_client::HandelLocalRecv()
{
    int len = 0;
    char* pInmsg = m_Localclient.startLoop(LOCAL_SERVER_IP,LOCAL_SERVER_PORT,&len);//网络

    //处理本地网络接收消息业务
    if( !pInmsg)
    {
        return;
    }

    QByteArray tp;
    tp = QByteArray(pInmsg,len);
    qDebug()<<"包总长度："<<tp.length()<<"  pInmsg 长度"<<strlen(pInmsg);
    while (tp.size() >0 ) {

        memset(&m_recvBuf, 0x0, sizeof(m_recvBuf));
        int len = 0;
        memcpy(&len,tp.data(),4);
        qDebug()<<"包的长度 收到服务端消息 len = "<< len;
        tp.remove(0,4);
        memcpy(&m_recvBuf,tp.data(),len);
        tp.remove(0,len);

        int msglen = strlen(m_recvBuf);
        //qDebug()<<"包的长度 收到服务端消息 msglen = "<< msglen;

        UiLog("包的长度 收到服务端消息 msglen ="+QString::number(msglen));
        if(msglen < 0 || msglen >= 65355)
        {
            qDebug()<<"网络接受数据长度不对";
            //UiLog("网络接受数据长度不对");
            return;
        }
        ProcASyncMsg(&m_recvBuf,msglen);
    }
}

void CNet_client::SendHartBeat()
{
    T_Message pInmsg;
    pInmsg.m_ucMessage = LOCAL_CLIENT_R_SERVER_HEART_BEAT;
    pInmsg.m_Msglen = sizeof(pInmsg);
    m_Localclient.SendMsgInterface(&pInmsg,8);
}


//杀升级进程
void CNet_client::QuitUpdateProgram()
{
    UiLog("退出升级进程");
    T_Message pInmsg;
    pInmsg.m_ucMessage = LOCAL_CLIENT_S_QUIT_UPDATE_PROGRAMA;
    pInmsg.m_Msglen = sizeof(pInmsg);
    m_Localclient.SendMsgInterface(&pInmsg,8);
}

//获取虚拟文件版本
void CNet_client::ObtainVirtualVersion()
{
    QString absdir = QCoreApplication::applicationDirPath();
    QString VersionPath = absdir + UPGRADE_PATH + VERSION_TXT_PATH;
    QFile file(VersionPath);

    if(!file.open(QIODevice::ReadOnly))
    {
        qDebug()<<"虚拟version.txt 打开异常";
        return;
    }

    QTextStream in(&file);
    m_VirtualVersionNum = in.readLine();
    qDebug()<<"路劲："<<VersionPath<<"  虚拟版本号："<<m_VirtualVersionNum;
    file.close();

    ToUiDatas touiDatas;
    touiDatas.e_action = NET_TO_UI_INFO_VERSION_NUM;
    touiDatas.m_netToUi.m_VersionNum = m_VirtualVersionNum;
    SendToUI(touiDatas);
}

void CNet_client::WriteLocalVersion(QString VersionNum)
{
    QString absdir = QCoreApplication::applicationDirPath();
    QString VersionPath = absdir + BOX_ROOT_DIR + UPGRADE_PATH + VERSION_TXT_PATH;
    QFile file(VersionPath);

    if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        qDebug()<<"version.txt 打开异常";
        return;
    }

    QTextStream in(&file);
    in<<VersionNum;
    file.close();
}

void CNet_client::ObtainRemoteUrl()
{
    //获取版本
    T_Message tmessage;
    tmessage.m_ucMessage   = htonl(CLIENT_G_SERVER_UPGRADEURL);
    tmessage.m_Msglen      = 0;
    m_client.Send((char *)&tmessage,sizeof(T_Message));
}

void CNet_client::ObtainRemoteLog()
{
    //获取远端升级日志
    T_Message tmessage;
    tmessage.m_ucMessage   = htonl(CLIENT_G_SERVER_UPGRADE_LOG);
    tmessage.m_Msglen      = 0;
    m_client.Send((char *)&tmessage,sizeof(T_Message));
}

void CNet_client::ObtainRemoteVersion()
{
    //获取远端版本号
    qDebug()<<"获取远端版本号";
    T_Message tmessage;
    tmessage.m_ucMessage   = htonl(CLIENT_G_SERVER_UPGRADEVERSION);
    tmessage.m_Msglen      = 0;
    m_client.Send((char *)&tmessage,sizeof(T_Message));
}

bool CNet_client::CompareVersion()
{
    if(m_VirtualVersionNum == ""|| m_RemoteVersionNum == "")
    {
        UiLog("版本号为空");
        return false;
    }
    if(m_VirtualVersionNum.contains("v"))
        m_VirtualVersionNum.remove("v");
    m_RemoteVersionNum.remove("v");
    QStringList Local = m_VirtualVersionNum.split(".");
    QStringList Remote = m_RemoteVersionNum.split(".");

    QString l1 = Local[0];
    QString l2 = Local[1];

    QString r1 = Remote[0];
    QString r2 = Remote[1];

    if(r1.toInt() > l1.toInt())
    {
        return true;
    }
    if(r1.toInt() == l1.toInt() && r2.toInt() > l2.toInt())
    {
        return true;
    }
    else
    {
        return false;
    }
}

void CNet_client::InfoUserUpdate()
{
    //通知用户更新，发送版本号和更新日志至主界面
    ToUiDatas touiDatas;
    touiDatas.e_action = NET_TO_UI_INFO_UPDATE;
    touiDatas.m_netToUi.m_UpgradeLog = m_UpgradeLog;
    touiDatas.m_netToUi.m_VersionNum = m_RemoteVersionNum;
    SendToUI(touiDatas);
}

void CNet_client::InfoUserNoUpdate()
{
    //提示用户现在没有更新，你不要再检查了
    ToUiDatas touiDatas;
    touiDatas.e_action = NET_TO_UI_INFO_NO_UPDATE;
    SendToUI(touiDatas);
}

void CNet_client::CarryUpdate()
{
    UiLog("执行更新");

    //填充执行更新所需要的数据
    T_Message pInmsg;
    pInmsg.m_ucMessage = LOCAL_CLIENT_S_CARRY_UPDATE;
    memcpy(pInmsg.m_pMsgcontent,&m_CheckUpdate,sizeof(m_CheckUpdate));
    pInmsg.m_Msglen = sizeof(m_CheckUpdate);
    m_Localclient.SendMsgInterface(&pInmsg,pInmsg.m_Msglen);

    qDebug()<<"url:"<<m_CheckUpdate.m_Url<<"  根目录："<<m_CheckUpdate.m_abstr;

    //执行更新后，工具进程要退出
    ToUiDatas touiDatas;
    touiDatas.m_filterDatasToUi.m_ExceptionLogMsg.m_TopSummary = "upgrade";
    touiDatas.e_action = FILTER_TO_UI_QUIT_SIGNAL;
    SendToUI(touiDatas);
}

void CNet_client::TimerInit_()
{
    if (m_timer)
    {
        m_timer->stop();
        m_timer->setInterval(2000);//设置定时周期，单位：毫秒
        m_timer->start();
    }
}

void CNet_client::on_timer_timeout()
{
    //开机检查更新,仅用户模式下支持
    qDebug("开机检查更新");
    if (!g_mainVars.m_isLoopCheckMode)
    {
        ObtainRemoteVersion();
    }
    m_timer->stop();
}