#include "common_func.hpp"
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <sys/types.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <linux/sockios.h>
#include <linux/rtc.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#include <stdlib.h>
#include <memory.h>
#include <string>
#include <list>
#include <iostream>
#include <fstream>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <memory.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "dirent.h"
#include <iconv.h>
#include <termios.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netdb.h>
#include <boost/algorithm/string/split.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/xpressive/xpressive_dynamic.hpp>
#include <json/json.h>
#include <zlog.h>
#include "global.hpp"
#include "dbaccess/sql_db.hpp"


#define ETHTOOL_GLINK 0x0000000a /* Get link status (ethtool_value) */
#define MAX_WAIT_TIME 1
#define MAX_NO_PACKETS 1
#define ICMP_HEADSIZE 8
#define PACKET_SIZE 4096
struct timeval tvsend, tvrecv;
struct sockaddr_in dest_addr, recv_addr;
int sockfd;
pid_t pid;
char sendpacket[PACKET_SIZE];
char recvpacket[PACKET_SIZE];

static boost::mutex s_config_mu;

extern zlog_category_t *zct;
extern zlog_category_t *zbt;

std::string GetLocalTimeWithMs(void) {
    std::string defaultTime = "19700101000000000";
    try {
        struct timeval curTime;
        gettimeofday(&curTime, NULL);
        int milli = curTime.tv_usec / 1000;

        char buffer[80] = {0};
        struct tm nowTime;
        localtime_r(&curTime.tv_sec, &nowTime); //闂傚倷鑳堕、濠傗枖濞戙垺鏅濋柕鍫濇处椤愪粙姊洪鈧粔瀵哥矆閸℃稒鐓欐繛鍫濈仢閺嬬喖鏌ｉ敐澶夋喚闁哄本绋掔换婵嬪礋椤愵澀绮梻浣割吔閺夊灝顫囬悗瑙勬礃椤ㄥ﹥淇婇悜钘壩ч柛婊€鐒︿簺闂傚倷绀侀幖顐﹀疮閸愭祴鏋栨繛鎴欏灩閸ㄥ倿骞栧ǎ顒€濡介柣鎾亾闁诲骸绠嶉崕鍗灻洪敃鍌涘仼闂侇剙绉甸悡鏇㈡煙闁箑澧柛锝呯秺閺岋絾骞婇柛鏂跨Ф缁瑦寰勯幇鍨櫍闂侀潧臎閸滀焦啸缂傚倸鍊烽悞锕€鐣峰Ο琛℃灃闁哄洢鍨归悡婵嬫煠濞村鏉归柛瀣崌閹兘鏌囬敂鍙箓姊洪崨濠勬嚂闁瑰嚖鎷�
        strftime(buffer, sizeof(buffer), "%Y%m%d%H%M%S", &nowTime);

        char currentTime[84] = {0};
        snprintf(currentTime, sizeof(currentTime), "%s%03d", buffer, milli);
        return currentTime;
    } catch (...) {
        zlog_error(zct, "GetLocalTimeWithMs failed, use default time");
        return defaultTime;
    }
}

int code_convert(const char *from_charset, const char *to_charset, char *inbuf, size_t inlen, char *outbuf, size_t outlen) {
    iconv_t cd;
    char **pin = &inbuf;
    char **pout = &outbuf;
    cd = iconv_open(to_charset, from_charset);
    if (cd == 0) {
        zlog_error(zct, "iconv_open failed");
        return -1;
    }

    memset(outbuf, 0, outlen);
    if ((int)iconv(cd, pin, &inlen, pout, &outlen) == -1) {
        zlog_error(zct, "iconv failed");
        iconv_close(cd);
        return -2;
    }
    iconv_close(cd);
    *pout = '\0';
    return 0;
}

int InitGpio(unsigned int gpioN, unsigned int inout) {
    int fd = 0;
    char tmp[100] = {0};
    //闂傚倷鑳堕幊鎾绘倶濮樿泛绠伴柛婵勫劜椤洟鏌熸潏鈺佲偓宄闂備浇宕垫慨鎶芥倿閿曞倸纾块柟璺哄閸ヮ剦鏁嗛柛鏇ㄥ亝椤ユ繈姊洪幖鐐插姷闂傚嫬瀚伴、鏇㈡晸閿燂拷
    fd = open("/sys/class/gpio/export", O_WRONLY);
    if (-1 == fd) {
        zlog_error(zbt, "open gpio export file error");
        return 1;
    }
    //闂傚倷鐒﹂惇褰掑垂瑜版帗鍋柛銉墻閺佸鏌ｉ悙鍨紬io
    sprintf(tmp, "%d", gpioN);
    if (write(fd, tmp, strlen(tmp)) < 0) {
        zlog_error(zbt, "write file operation error:%s", tmp);
        close(fd);
        return 2;
    }

    close(fd);
    sleep(1);
//闂傚倸鍊烽悞锕€顭垮Ο鑲╃煋闁割偅娲橀崑顏堟煕閻愭彃鍘o闂傚倷绀侀幖顐﹀磹婵犳艾绠犻柟鎹愵嚙缁犳牠鏌ㄩ悤鍌涘
#ifdef G2UL_GATEWAY
    char tmp2[100] = {0};
    if (gpioN == 507)
        memcpy(tmp2, "P18_3", 5);
    else if (gpioN == 499)
        memcpy(tmp2, "P17_3", 5);
    else if (gpioN == 496)
        memcpy(tmp2, "P17_0", 5);
    else if (gpioN == 130)
        memcpy(tmp2, "P9_0", 4);
    else if (gpioN == 408)
        memcpy(tmp2, "P6_0", 4);
    else if (gpioN == 363)
        memcpy(tmp2, "P0_3", 4);
    else if (gpioN == 498)
        memcpy(tmp2, "P17_2", 5);
    else if (gpioN == 466)
        memcpy(tmp2, "P13_2", 5);
    else if (gpioN == 488)
        memcpy(tmp2, "P16_0", 5);
    else if (gpioN == 474)
        memcpy(tmp2, "P14_2", 5);
    else if (gpioN == 497)
        memcpy(tmp2, "P17_1", 5);
    else if (gpioN == 409)
        memcpy(tmp2, "P6_1", 4);
    else if (gpioN == 410)
        memcpy(tmp2, "P6_2", 4);
    else if (gpioN == 449)
        memcpy(tmp2, "P11_1", 5);
    else if (gpioN == 489)
        memcpy(tmp2, "P16_1", 5);

    sprintf(tmp, "/sys/class/gpio/%s/direction", tmp2);
#endif
#ifdef IMX6UL_GATEWAY
    sprintf(tmp, "/sys/class/gpio/gpio%d/direction", gpioN);
#endif

    zlog_info(zbt, "open GPIO = %s", tmp);
    fd = open(tmp, O_WRONLY);
    if (-1 == fd) {
        zlog_error(zbt, "open gpio direction file error");
        close(fd);
        return 3;
    }

    if (inout == 0) {
        zlog_info(zbt, "=====InitGpio=====in");
        if (-1 == write(fd, "in", sizeof("in"))) {
            zlog_error(zbt, "[%d]write operation direction error", gpioN);
            close(fd);
            return 4;
        }
    } else if (inout == 1) {
        zlog_info(zbt, "=====InitGpio=====out");
        if (-1 == write(fd, "out", sizeof("out"))) {
            zlog_error(zbt, "[%d]write operation direction error", gpioN);
            close(fd);
            return 5;
        }
    }
    close(fd);
    return 0;
}

int gpio_set(unsigned int gpioN, char x) {
    int fd = 0;
    char tmp[100] = {0};
#ifdef G2UL_GATEWAY
    char tmp2[100] = {0};
    if (gpioN == 507)
        memcpy(tmp2, "P18_3", 5);
    else if (gpioN == 499)
        memcpy(tmp2, "P17_3", 5);
    else if (gpioN == 496)
        memcpy(tmp2, "P17_0", 5);
    else if (gpioN == 130)
        memcpy(tmp2, "P9_0", 4);
    else if (gpioN == 408)
        memcpy(tmp2, "P6_0", 4);
    else if (gpioN == 363)
        memcpy(tmp2, "P0_3", 4);
    else if (gpioN == 498)
        memcpy(tmp2, "P17_2", 5);
    else if (gpioN == 466)
        memcpy(tmp2, "P13_2", 5);
    else if (gpioN == 488)
        memcpy(tmp2, "P16_0", 5);
    else if (gpioN == 474)
        memcpy(tmp2, "P14_2", 5);
    else if (gpioN == 497)
        memcpy(tmp2, "P17_1", 5);
    else if (gpioN == 409)
        memcpy(tmp2, "P6_1", 4);
    else if (gpioN == 410)
        memcpy(tmp2, "P6_2", 4);
    else if (gpioN == 449)
        memcpy(tmp2, "P11_1", 5);
    else if (gpioN == 489)
        memcpy(tmp2, "P16_1", 5);
    sprintf(tmp, "/sys/class/gpio/%s/value", tmp2);
#endif
#ifdef IMX6UL_GATEWAY
    sprintf(tmp, "/sys/class/gpio/gpio%d/value", gpioN);
#endif

    zlog_info(zbt, "set GPIO = %s", tmp);
    //闂傚倷鑳堕幊鎾绘倶濮樿泛绠伴柛婵勫劜椤洟鏌熸潏鈺佲偓宄 value闂傚倷绀侀幖顐﹀磹缁嬫５娲晲閸涱亝鐎婚梺璺ㄥ櫐閹凤拷
    fd = open(tmp, O_WRONLY);
    if (-1 == fd) {
        zlog_error(zbt, "[%s] open gpio export file error", tmp);
        close(fd);
        return (-1);
    }
    //闂備浇宕垫慨宕囩矆娴ｈ娅犲ù鐘差儐閸嬵亪鏌涢埄鍐姇闁稿鍔戝濠氬醇閻旂儤鍒涢梺褰掓交閹凤拷
    if (x) {
        if (-1 == write(fd, "1", sizeof("1"))) {
            zlog_error(zbt, "%d write operation value error", gpioN);
            close(fd);
            return (-2);
        }
    } else {
        if (-1 == write(fd, "0", sizeof("0"))) {
            zlog_error(zbt, "%d write operation value errorn", gpioN);
            close(fd);
            return (-3);
        }
    }
    zlog_info(zbt, "gpio%d set %d ok", gpioN, x);
    close(fd);
    return 0;
}

int gpio_read(unsigned int gpioN) {
    int fd = 0;
    char value;

    char tmp[100] = {0};

#ifdef G2UL_GATEWAY
    char tmp2[100] = {0};
    if (gpioN == 507)
        memcpy(tmp2, "P18_3", 5);
    else if (gpioN == 499)
        memcpy(tmp2, "P17_3", 5);
    else if (gpioN == 496)
        memcpy(tmp2, "P17_0", 5);
    else if (gpioN == 130)
        memcpy(tmp2, "P9_0", 4);
    else if (gpioN == 408)
        memcpy(tmp2, "P6_0", 4);
    else if (gpioN == 363)
        memcpy(tmp2, "P0_3", 4);
    else if (gpioN == 498)
        memcpy(tmp2, "P17_2", 5);
    else if (gpioN == 466)
        memcpy(tmp2, "P13_2", 5);
    else if (gpioN == 488)
        memcpy(tmp2, "P16_0", 5);
    else if (gpioN == 474)
        memcpy(tmp2, "P14_2", 5);
    else if (gpioN == 497)
        memcpy(tmp2, "P17_1", 5);
    else if (gpioN == 409)
        memcpy(tmp2, "P6_1", 4);
    else if (gpioN == 410)
        memcpy(tmp2, "P6_2", 4);
    else if (gpioN == 449)
        memcpy(tmp2, "P11_1", 5);
    else if (gpioN == 489)
        memcpy(tmp2, "P16_1", 5);
    sprintf(tmp, "/sys/class/gpio/%s/value", tmp2);
#endif
#ifdef IMX6UL_GATEWAY
    sprintf(tmp, "/sys/class/gpio/gpio%d/value", gpioN);
#endif
    //闂傚倷鑳堕幊鎾绘倶濮樿泛绠伴柛婵勫劜椤洟鏌熸潏鈺佲偓宄 value闂傚倷绀侀幖顐﹀磹缁嬫５娲晲閸涱亝鐎婚梺璺ㄥ櫐閹凤拷
    fd = open(tmp, O_RDONLY);
    if (-1 == fd) {
        zlog_error(zbt, "%d open gpio export file error", gpioN);
        return (-1);
    }
    //闂備浇宕垫慨鏉懨洪埡鍜佹晪鐟滄垿濡甸幇鐗堟櫢闁跨噦鎷� value闂傚倷绀侀幖顐﹀磹缁嬫５娲晲閸涱亝鐎婚梺璺ㄥ櫐閹凤拷
    if (-1 == read(fd, &value, sizeof(value))) {
        zlog_error(zbt, "%d read gpiovalue is fail", gpioN);
        close(fd);
        return (-2);
    }
    close(fd);
    zlog_info(zbt, "gpio%d get %d", gpioN, value);
    return value;
}

int config_uart(const char *port, int speed) {
    int iFd = open(port, O_RDWR | O_NOCTTY);
    if (iFd < 0) {
        zlog_error(zbt, "open port:%s failed", port);
        return -1;
    }
    struct termios opt;
    tcgetattr(iFd, &opt);
    cfsetispeed(&opt, speed);
    cfsetospeed(&opt, speed);
    if (tcgetattr(iFd, &opt) < 0) {
        zlog_error(zbt, "tcgetattr failed");
        return -1;
    }
    opt.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    opt.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
    opt.c_oflag &= ~(OPOST);
    opt.c_cflag &= ~(CSIZE | PARENB | CBAUD);
    opt.c_cflag |= (CS8 | speed);
    opt.c_cc[VMIN] = 255;
    opt.c_cc[VTIME] = 5;
    if (tcsetattr(iFd, TCSANOW, &opt) < 0) {
        zlog_error(zbt, "tcsetattr failed");
        return -2;
    }
    tcflush(iFd, TCIOFLUSH);
    return iFd;
}

int write_data(int fd, char *buff, int len) {
    int ret;
    ret = write(fd, buff, len);
    if (ret < 0) {
        zlog_error(zct, "write failed");
        return -1;
    }
    return ret;
}

int read_data(int fd, char *buff, int len, int timeout) {
    int ret;
    struct timeval to;
    fd_set rdfds;

    to.tv_sec = 0;
    to.tv_usec = timeout;

    FD_ZERO(&rdfds);
    FD_SET(fd, &rdfds);

    if (timeout > 0) {
        ret = select(fd + 1, &rdfds, NULL, NULL, &to);
        if (ret <= 0) {
            return ret;
        }
    }

    ret = read(fd, buff, len);
    if (ret < 0) {
        zlog_error(zct, "read_data failed");
        return -1;
    }
    buff[ret] = '\0';
    return ret;
}

int ModifyMac(char *buff) {
    FILE *fp = NULL;
    fp = fopen("/opt/system/mac", "w");
    if (fp == NULL) {
        zlog_error(zbt, "fail to open /opt/system/mac");
        return 1;
    }
    fprintf(fp, buff);
    fprintf(fp, "\n");
    fclose(fp);
    system("cp /opt/system/mac /opt/system/macbak");
    system("/opt/Cidn/init.sh");
    return 0;
}

void mssleep(unsigned long microseconds) {
    struct timespec req;
    struct timespec rem;
    req.tv_sec = microseconds / 1000000;
    req.tv_nsec = (microseconds % 1000000) * 1000;
    nanosleep(&req, &rem);
}

std::string GetCurrentTime() {
    struct tm nowtime;
    struct timeval tv;
    char time_now[128];
    gettimeofday(&tv, NULL);
    localtime_r(&tv.tv_sec, &nowtime);
    sprintf(time_now, "%d-%d-%d %d:%d:%d.%03d ", nowtime.tm_year + 1900, nowtime.tm_mon + 1, nowtime.tm_mday, nowtime.tm_hour, nowtime.tm_min, nowtime.tm_sec, (int)(tv.tv_usec / 1000));
    std::string strtime_now = std::string((char *)time_now);
    return strtime_now;
}

tm *get_current_date() {
    time_t t = time(NULL);
    struct tm *tm_info = localtime(&t);
    int iyear = 0;
    int imonth = 0;
    int day = 0;
    iyear = tm_info->tm_year + 1900;
    imonth = tm_info->tm_mon + 1;
    day = tm_info->tm_mday;
    zlog_info(zct, "year = %d,month = %d,day = %d", iyear, imonth, day);
    return tm_info;
}

int system_custom(const char *cmd, char *buf) {
    FILE *fp;
    int res;
    char temp[1024] = {0};
    if (cmd == NULL) {
        zlog_error(zct, "cmd is NULL");
        return -1;
    }

    if ((fp = popen(cmd, "r")) == NULL) {
        zlog_error(zct, "popen error");
        return -1;
    } else {
        buf[0] = '\0';
        while (fgets(temp, sizeof(temp), fp)) {
            strcat(buf, temp);
        }
        res = pclose(fp);
    }

    char *p;
    int pos = 0;
    p = strstr(buf, "\n");
    if (p != NULL) {
        pos = p - buf;
        buf[pos] = '\0';
    }

    return res;
}

std::string GetDayDate() {
    time_t t = time(0);
    char tmp[64];
    strftime(tmp, sizeof(tmp), "%Y-%m-%d", localtime(&t));
    std::string data = std::string((char *)tmp);
    return data;
}

void GetTimeNet(char *timebuf, int type) {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    int millisecond = tv.tv_usec / 1000;
    if (type == 0) {
        sprintf(timebuf, "%ld%03d", tv.tv_sec, millisecond);
    } else {
        sprintf(timebuf, "%ld", tv.tv_sec);
    }
}

std::string GetRTC(char *timestamp, int &millisecond) {
    time_t rtc_timestamp;
    struct tm tm;
    struct timespec ts;
    char rtcTime[100] = {0x00};
    int fd = open("/dev/rtc0", O_RDONLY);
    if (fd < 0) {
        zlog_error(zct, "fail to open /dev/rtc0");
        return "";
    } 
    struct rtc_time rtc_tm;
    if (ioctl(fd, RTC_RD_TIME, &rtc_tm) < 0) {
        zlog_error(zct, "fail to ioctl RTC_RD_TIME");
        return "";
    } 
    clock_gettime(CLOCK_REALTIME, &ts);
    millisecond = (int)(ts.tv_nsec / 1000000);
    printf("RTC date/time is %d-%d-%d, %02d:%02d:%02d\n", rtc_tm.tm_year + 1900, rtc_tm.tm_mon + 1, rtc_tm.tm_mday, rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
    sprintf(rtcTime, "%d-%d-%d, %02d:%02d:%02d", rtc_tm.tm_year + 1900, rtc_tm.tm_mon + 1, rtc_tm.tm_mday, rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);

    // 闂備浇顕х换鎰崲閹版澘鏋侀柛宥囧发_time缂傚倸鍊搁崐鐑芥倿閿曞倸绠板┑鐘崇閸婂灚銇勯弽銊р姇濠殿垱鎸抽弻鐔煎箲閹板灚缍堢紓浣风贰閸ｏ綁寮婚悢鐑樺珰闁斥晛鍟扮粣鏃堟煟閻樺啿濮夐柛鏂跨┘me_t闂傚倷绀侀幖顐﹀疮椤愶附鍋夐柣鎾冲濞戙垹閿ゆ俊銈傚亾缂佺媴缍侀弻銊╂偆閸屾稑顏�
    tm.tm_year = rtc_tm.tm_year;
    tm.tm_mon = rtc_tm.tm_mon;
    tm.tm_mday = rtc_tm.tm_mday;
    tm.tm_hour = rtc_tm.tm_hour;
    tm.tm_min = rtc_tm.tm_min;
    tm.tm_sec = rtc_tm.tm_sec;
    tm.tm_isdst = -1; // 婵犵數鍋為崹鍫曞箰閸濄儳鐭撻柧蹇ｅ亞缁犻箖鏌涢妷顔煎闁稿鍔戦弻鏇熺箾閸喖濮跺┑鈥冲级閸庢娊婀侀梺缁橈供閸犳牠鍩€椤掍胶澧い顏勫暣閺佹捇鏁撻敓锟�

    rtc_timestamp = mktime(&tm);

    if (rtc_timestamp == -1) {
        zlog_error(zct, "fail to mktime");
        return "";
    }
    printf("RTC timestamp is %ld,millisecond = %d\n", rtc_timestamp, millisecond);
    sprintf(timestamp, "%ld", rtc_timestamp);   
    close(fd);
    return std::string(rtcTime);
}

void GetTime_(char time_buff[], TIME_SIZE len) {
    int i = sizeof(time_buff);
    memset(time_buff, 0, i);
    time_t timep;
    time(&timep);
    strcpy(time_buff, ctime(&timep));
    std::string strtemp = time_buff;
    strtemp = strtemp.substr(11, len);
    memset(time_buff, 0, strlen(time_buff));
    strcpy(time_buff, strtemp.c_str());
}

std::string ReadStrByOpt(std::string filename, std::string config, std::string option) {
    boost::mutex::scoped_lock lock(s_config_mu);
    Json::Value root;
    Json::Reader reader;
    std::string value;
    std::fstream is;
    is.open(filename.c_str(), std::ios::in);
    if (reader.parse(is, root)) {
        value = root[config]["option"][option].asString();
    }
    is.close();
    return value;
}

std::vector<DataNodeUpdate> ReadStrUpdate(std::string filename) {
    boost::mutex::scoped_lock lock(s_config_mu);
    Json::Value root, hwVersion;
    Json::Reader reader;
    std::vector<std::string> value;
    std::vector<DataNodeUpdate> vecDataNodeUpdate;
    DataNodeUpdate datanodeUpdate;
    std::fstream is;
    is.open(filename.c_str(), std::ios::in);
    if (reader.parse(is, root)) {
        zlog_info(zbt, "root = %d", root.size());
        for (size_t i = 0; i < root.size(); i++) {
            hwVersion = root[i]["hw_vesion"];
            for (size_t j = 0; j < hwVersion.size(); j++) {
                datanodeUpdate.hwVersion.push_back(hwVersion[j].asString());
            }
            datanodeUpdate.strUpdataFileName = root[i]["fw_name"].asString();
            datanodeUpdate.strSoftVersion = root[i]["sf_vesion"].asString();
            zlog_info(zbt, "strUpdataFileName = %s, strSoftVersion = %s", datanodeUpdate.strUpdataFileName.c_str(), datanodeUpdate.strSoftVersion.c_str());
            vecDataNodeUpdate.push_back(datanodeUpdate);
        }
    }
    is.close();

    return vecDataNodeUpdate;
}

void ReadStrConfig(std::string filename) {
    Json::Value root, gateWay, dataNode;
    std::fstream is;
    Json::Reader reader;
    is.open(filename.c_str(), std::ios::in);
    std::string zigbeeChannel;
    if (reader.parse(is, root) == 0) {
        zlog_error(zbt, "fail to parse file:%s", filename.c_str());
        return;
    }
    gateWay = root["gateWay"];
    dataNode = root["dataNodeArray"];
    zlog_info(zbt, "dataNode = %d", dataNode.size());
    for (size_t i = 0; i < dataNode.size(); i++) {
        std::string softVersion = dataNode[i]["softVersion"].asString();
        std::string bpNo = dataNode[i]["bpNo"].asString();
        std::string wakeupTime = dataNode[i]["wakeupTime"].asString();
        int viff = dataNode[i]["viff"].asInt();
        std::string StaticTime = dataNode[i]["StaticTime"].asString();
        int configFlag = dataNode[i]["configFlag"].asInt();
        int rangeValue = dataNode[i]["range"].asInt();
        int updateValue = dataNode[i]["update"].asInt();
        std::string zigbeeLongAddr = dataNode[i]["zigbeeLongAddr"].asString();
        int accFlag = dataNode[i]["accFlag"].asInt();
        int temTopFlag = dataNode[i]["temTopFlag"].asInt();
        std::string startBrands = dataNode[i]["startBrands"].asString();
        int waveInterVal = dataNode[i]["waveInterVal"].asInt();
        std::string zigbeePanId = dataNode[i]["zigbeePanId"].asString();
        int waveTime = dataNode[i]["waveTime"].asInt();
        int zigbeePower = dataNode[i]["zigbeePower"].asInt();
        int zigbeeRetry = dataNode[i]["zigbeeRetry"].asInt();
        std::string stopBrands = dataNode[i]["stopBrands"].asString();
        int featureInterVal = dataNode[i]["featureInterVal"].asInt();
        int zigbeeFlag = dataNode[i]["zigbeeFlag"].asInt();
        std::string zigbeeDesAddr = dataNode[i]["zigbeeDesAddr"].asString();
        int ZigbeeRetryGap = dataNode[i]["zigbeeRetryGap"].asInt();
        std::string dataNodeNo = dataNode[i]["dataNodeNo"].asString();
        int initFlag = dataNode[i]["initFlag"].asInt();
        std::string faultFrequency = dataNode[i]["faultFrequency"].asString();
        int temBotFlag = dataNode[i]["temBotFlag"].asInt();
        std::string bateryV = dataNode[i]["bateryV"].asString();
        int ACCSampleTime = dataNode[i]["ACCSampleTime"].asInt();
        std::string firstPowerTime = dataNode[i]["firstPowerTime"].asString();
        std::string serialNo = dataNode[i]["serialNo"].asString();
        std::string zigbeeAddr = dataNode[i]["zigbeeAddr"].asString();
        std::string productNo = dataNode[i]["productNo"].asString();
        std::string timeStamp = dataNode[i]["timeStamp"].asString();
        zigbeeChannel = dataNode[i]["zigbeeChannel"].asString();
        int RSSI = dataNode[i]["RSSI"].asInt();
        std::string hardVersion = dataNode[i]["hardVersion"].asString();
        std::string envelopeBandPass = dataNode[i]["envelopeBandPass"].asString();
        int samplingRate = dataNode[i]["samplingRate"].asInt();
        std::string dataNodeName = dataNode[i]["dataNodeName"].asString();
        int status = dataNode[i]["status"].asInt();
        int EquipSta = dataNode[i]["equipSta"].asInt();
        char insertSql[1024] = {0};
        char whereCon[100] = {0x00};
        sprintf(whereCon, "dataNodeNo = '%s'", dataNodeNo.c_str());
        int rows = sqlite_db_ctrl::instance().GetTableRows(T_SENSOR_INFO(TNAME), whereCon);
        if (rows > 0) continue;
        sprintf(insertSql, "'%s','%s','%d','%d','%d','%d','%d','%d',\
                    '%s','%s','%s','%s','%s','%d',\
                    '%d','%d','%d','%s','%d','%s',\
                    '%s','%d','%d','%d','%s','%d','%s','%s',\
                    '%s','%d','%s','%s','%s',\
                    '%d','%d','%d','%d','%d','%s','%d','%d','%d','0','0,0'",
                dataNodeNo.c_str(), dataNodeName.c_str(), initFlag, accFlag, zigbeeFlag, temTopFlag, temBotFlag, EquipSta, hardVersion.c_str(), softVersion.c_str(), bpNo.c_str(), serialNo.c_str(), firstPowerTime.c_str(), atoi(wakeupTime.c_str()), atoi(StaticTime.c_str()),
                waveTime, atoi(bateryV.c_str()), productNo.c_str(), configFlag, startBrands.c_str(), stopBrands.c_str(), featureInterVal, waveInterVal, samplingRate, "", rangeValue, envelopeBandPass.c_str(), faultFrequency.c_str(), zigbeePanId.c_str(),
                atoi(zigbeeChannel.c_str()), zigbeeAddr.c_str(), zigbeeLongAddr.c_str(), zigbeeDesAddr.c_str(), zigbeePower, zigbeeRetry, ZigbeeRetryGap, ACCSampleTime, status, timeStamp.c_str(), viff, RSSI, updateValue);
        int res = sqlite_db_ctrl::instance().InsertData(T_SENSOR_INFO(TNAME), insertSql);
        if (res != 0)
        {
            zlog_error(zbt, "res:%d", res);
        }
        
    }
   
    is.close();
}

void ImportConfig(std::string filename) {
    Json::Value root, gateWay, dataNode;
    std::fstream is;
    Json::Reader reader;
    int res = 0;
    is.open(filename.c_str(), std::ios::in);
    if (!is.is_open()) {
        zlog_error(zbt, "fail to open:%s", filename.c_str());
        return;
    }

    if (reader.parse(is, root) == 0) {
        zlog_error(zbt, "fail to parse:%s", filename.c_str());
        return;
    }
    std::string zigbeeChannel;
    Json::Value jsSystemSetting, jsonValnet, jsonValnet1, jsSystemInfo, jsonValZigbee, jsondataNodeArray;    
    
    jsSystemInfo = root["SystemInfo"];
    jsonValZigbee = root["zigbee"];
    jsonValnet1 = root["eth1"];
    jsonValnet = root["eth0"];
    jsSystemSetting = root["ServerConfig"];
    jsondataNodeArray = root["dataNodeArray"];
    char insertSql[1024] = {0};
    for (size_t i = 0; i < jsondataNodeArray.size(); i++) {
        Json::Value valNode = jsondataNodeArray[i];
        std::vector<std::string> vecDataNode;
        for (size_t j = 0; j < valNode.size(); j++) {
            vecDataNode.push_back(std::string(valNode[j].asString()));
        }
        char dataNodeName[100] = {0x00};
        hexToAscii(vecDataNode[1].c_str(), dataNodeName);
        memset(insertSql, 0, 1024);
        sprintf(insertSql, "'%s','%s','%s','%s','%s','%s','%s','%s',\
                    '%s','%s','%s','%s','%s','%s',\
                    '%s','%s','%s','%s','%s','%s',\
                    '%s','%s','%s','%s','%s','%s','%s','%s',\
                    '%s','%s','%s','%s','%s',\
                    '%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s'",
                vecDataNode[0].c_str(), dataNodeName, vecDataNode[2].c_str(), vecDataNode[3].c_str(), 
                vecDataNode[4].c_str(), vecDataNode[5].c_str(), vecDataNode[6].c_str(), 
                vecDataNode[7].c_str(), vecDataNode[8].c_str(), vecDataNode[9].c_str(), vecDataNode[10].c_str(),
                vecDataNode[11].c_str(), vecDataNode[12].c_str(), vecDataNode[13].c_str(), vecDataNode[14].c_str(),
                vecDataNode[15].c_str(), vecDataNode[16].c_str(), vecDataNode[17].c_str(), vecDataNode[18].c_str(),
                vecDataNode[19].c_str(), vecDataNode[20].c_str(),
                vecDataNode[21].c_str(), vecDataNode[22].c_str(), vecDataNode[23].c_str(), vecDataNode[24].c_str(),
                vecDataNode[25].c_str(), vecDataNode[26].c_str(), vecDataNode[27].c_str(), vecDataNode[28].c_str(), 
                vecDataNode[29].c_str(), vecDataNode[30].c_str(),
                vecDataNode[31].c_str(), vecDataNode[32].c_str(), vecDataNode[33].c_str(), vecDataNode[34].c_str(), 
                vecDataNode[35].c_str(), vecDataNode[36].c_str(), vecDataNode[37].c_str(), vecDataNode[38].c_str(), 
                vecDataNode[39].c_str(), vecDataNode[40].c_str(),
                vecDataNode[41].c_str(), vecDataNode[42].c_str(), vecDataNode[43].c_str(), vecDataNode[44].c_str());
        res = sqlite_db_ctrl::instance().InsertData(T_SENSOR_INFO(TNAME), insertSql);
        if (res != 0){
            zlog_error(zbt, "res:%d", res);
        }
    }

    WriteStr2Config(SERVERCONFIG, "Server", "localServerIpAddress", jsSystemSetting["ServerIpAddress"].asString());
    WriteStr2Config(SERVERCONFIG, "Server", "localServerPort", jsSystemSetting["ServerPort"].asString());
    WriteStr2Config(SERVERCONFIG, "Server", "CommMode", "2");
    WriteStr2Config(SERVERCONFIG, "Server", "UserName", jsSystemSetting["UserName"].asString());
    WriteStr2Config(SERVERCONFIG, "Server", "Password", jsSystemSetting["Password"].asString());
    WriteStr2Config(SERVERCONFIG, "Server", "APN", jsSystemSetting["APN"].asString());
    char APN[100] = {0x00};
    std::string apn = jsSystemSetting["APN"].asString();
    sprintf(APN, "sed -i '15c \t\t\t\t/opt/quectel-CM/quectel-CM -s %s > /dev/null &' /etc/init.d/S95check5G", apn.c_str());
    system(APN);

    WriteStr2Config(ZIGBEECONFIG, "Zigbee", "channel", jsonValZigbee["channel"].asString());
    WriteStr2Config(ZIGBEECONFIG, "Zigbee", "PanID", jsonValZigbee["PanID"].asString());

    WriteStr2Config(SYSTEMINFOFILE, "Version", "GateWayVersion", jsSystemInfo["GateWayVersion"].asString());
    WriteStr2Config(SYSTEMINFOFILE, "Version", "SystemVersion", jsSystemInfo["SystemVersion"].asString());
    WriteStr2Config(SYSTEMINFOFILE, "Version", "WebVersion", jsSystemInfo["WebVersion"].asString());
    WriteStr2Config(SYSTEMINFOFILE, "Version", "GateWayHwVesion", jsSystemInfo["GateWayHwVesion"].asString());
    WriteStr2Config(SYSTEMINFOFILE, "Version", "GateWayProduct", jsSystemInfo["GateWayProduct"].asString());    
}

int UpdataDataNodeConfig(std::string filename) {
    std::vector<DataNodeInfo> vecDataNode; //婵犵數濮伴崹鐟帮耿鏉堛劍娅犳俊銈傚亾閸楅亶鏌熺€电ǹ浠ч柍缁樻閺屽秷顧侀柛鎾存皑缁瑦寰勯幇鍨櫆闂佸憡娲﹂崢浠嬪箟閼姐倗纾藉ù锝堫嚃濞堬絿绱撻崒娑欑殤闁硅弓鍗冲畷鍗炩槈濡晝鏇㈡⒑绾懏褰х紒鐘冲灥閳诲秹鏁撻敓锟�
    //婵犵數鍋涢顓熸叏娴兼潙纾块柟缁㈠櫘閺佸霉閸忓吋缍戠紒鈧崒鐐寸厪濠㈣埖鐩顕€鏌ｉ幘瀵告噮闁逞屽墯椤旀牠宕伴弽顐ｅ床闁瑰鍋炲▍鐘绘煥閺囨浜惧銈嗘穿缂嶄線宕洪埀顒併亜閹烘垵顏╂俊顐ｏ耿閺屾盯濡烽鐐搭€嶅銈嗗姧閹凤拷
    std::ifstream csv_data(filename, std::ios::in);
    int iRet = 0;
    if (!csv_data.is_open()) {
        zlog_error(zbt, "UpdataDataNodeConfig fail to open:%s", filename.c_str());
        return -1;
    } 
    std::string line;
    std::vector<std::string> words; //婵犵數濮伴崹鐟帮耿鏉堛劍娅犳俊銈傚亾閸楅亶鏌熺€电ǹ浠ч柍缁樻閺屽秷顧侀柛鎾存皑缁瑦寰勯幇鍨櫆闂佸憡娲﹂崢浠嬪箟閼姐倗纾藉ù锝堫嚃濞堬絿绱撻崒娑欑殤闁硅弓鍗冲畷鍗炩槈濡晝鏇㈡⒑绾懏褰х紒鐘冲灥閳诲秹鏁撻敓锟�
    std::string word;

    DataNodeInfo dataNode;
    // ------------闂備浇宕垫慨鏉懨洪埡鍜佹晪鐟滄垿濡甸幇鏉跨倞妞ゆ巻鍋撻柡瀣╃窔閺岋絽螖閳ь剟鎮ч崱娆戠焾闁跨噦鎷�-----------------
    // 闂備浇宕垫慨鏉懨洪埡鍜佹晪鐟滄垿濡甸幇鏉跨倞妞ゆ巻鍋撻柛鎰ㄥ亾闂備焦鎮堕崕娲礈閿曞倸姹叉い鏍仦閸嬬姵绻涢幋锝嗙彧閻庢熬鎷�
    getline(csv_data, line);

    std::istringstream sin;
    // 闂傚倷绀佸﹢杈ㄧ仚濡炪倧闄勬繛濠囧Υ娓氣偓楠炲鎮╅崘鑼酱闂佽崵濮村ú锕併亹閸愵亜绶ら柛褎顨嗛悡娑樏归敐鍛儓妞わ綀鍋愰埀顒冾潐閹碱偊骞忛敓锟�
    while (getline(csv_data, line)) {
        words.clear();
        sin.clear();
        sin.str(line);
        while (getline(sin, word, ',')) {           
            words.push_back(word);
        }
        std::string mac = words[1];
        if (mac != GlobalConfig::MacAddr_G) {
            iRet = -2;
            break;
        }
        dataNode.ZigbeeLongAddr = words[7];
        dataNode.FeatureInterVal = atoi(words[16].c_str());
        dataNode.WaveInterVal = atoi(words[17].c_str());
        dataNode.SamplingRate = atoi(words[18].c_str());        

        if (words[19].find("8g") != std::string::npos) {
            dataNode.Range = 0;
        } else if (words[19].find("16g") != std::string::npos) {
            dataNode.Range = 1;
        } else if (words[19].find("32g") != std::string::npos) {
            dataNode.Range = 2;
        } else if (words[19].find("64g") != std::string::npos) {
            dataNode.Range = 3;
        } else if (words[19].find("50g") != std::string::npos) {
            dataNode.Range = 0;
        }

        dataNode.ACCSampleTime = atoi(words[20].c_str());
        dataNode.VIntegralFilterFrequency = atoi(words[21].c_str());
        dataNode.ZigbeePower = atoi(words[22].c_str());
        dataNode.ZigbeeRetry = atoi(words[23].c_str());
        int update = atoi(words[24].c_str());
        if (update == 1) vecDataNode.push_back(dataNode);
    }
    csv_data.close();    
    if (vecDataNode.size() == 0) {
        iRet = -3;
        zlog_error(zbt, "UpdataDataNodeConfig vecDataNode is 0");
        return iRet;
    }    
    
    char whereCon[1024] = {0};
    char updateSql[1024] = {0};    
    for (size_t i = 0; i < vecDataNode.size(); i++) {
        sprintf(updateSql, "featureInterVal='%d',waveInterVal='%d',range='%d',samplingRate='%d',AccSampleTime = '%d',viff ='%d' ,ZigbeePower = '%d',ZigbeeRetry = '%d',UpdateFlag = 0", vecDataNode[i].FeatureInterVal, vecDataNode[i].WaveInterVal, vecDataNode[i].Range,
                vecDataNode[i].SamplingRate, vecDataNode[i].ACCSampleTime, vecDataNode[i].VIntegralFilterFrequency, vecDataNode[i].ZigbeePower, vecDataNode[i].ZigbeeRetry);
        sprintf(whereCon, "dataNodeNo='%s'", vecDataNode[i].ZigbeeLongAddr.c_str());

        iRet = sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
        if (iRet != 0) {
            zlog_error(zbt, "UpdataDataNodeConfig UpdateTableData fail");
            return -4;
        }
        memset(whereCon, 0x00, sizeof(whereCon));
        memset(updateSql, 0x00, sizeof(updateSql));
    }     
    iRet = vecDataNode.size();   
    return iRet;
}

int WriteStr2Config(std::string filename, std::string config, std::string option, std::string value, bool listable) {
    boost::mutex::scoped_lock lock(s_config_mu);
    Json::Value root;
    Json::Value subroot;
    Json::Value list;
    Json::Value op;
    Json::Reader reader;
    std::fstream is;
    is.open(filename.c_str(), std::ios::in);
    if (!is.is_open()) {
        zlog_error(zct, "fail to open: %s", filename.c_str());
        return 1;
    }
    if (reader.parse(is, root) == 0) {
        zlog_error(zct, "fail to parse: %s", filename.c_str());
        return 2;
    }
   
    subroot = root[config];
    if (listable) {
        list = root[config]["list"];
    } else {
        op = root[config]["option"];
    }
    
    is.close();

    if (listable) {
        list[option].append(Json::Value(value));
        subroot["list"] = list;
    } else {
        op[option] = Json::Value(value);
        subroot["option"] = op;
    }
    root[config] = subroot;
    Json::StyledWriter sw;
    std::ofstream os;
    os.open(filename.c_str());
    os << sw.write(root);
    os.close();
    return 0;
}

std::string GetLocalMac(const char *net) {
    int sock_mac;
    struct ifreq ifr_mac;
    char mac_addr[30];
    sock_mac = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_mac == -1) {
        zlog_error(zct, "[GetLocalMac] fail to create socket");
        return "";
    }
    memset(&ifr_mac, 0, sizeof(ifr_mac));
    strncpy(ifr_mac.ifr_name, net, sizeof(ifr_mac.ifr_name) - 1);
    if ((ioctl(sock_mac, SIOCGIFHWADDR, &ifr_mac)) < 0) {
        zlog_error(zct, "mac ioctl error");
        return "";
    }
    sprintf(mac_addr, "%02x%02x%02x%02x%02x%02x", (unsigned char)ifr_mac.ifr_hwaddr.sa_data[0], (unsigned char)ifr_mac.ifr_hwaddr.sa_data[1], (unsigned char)ifr_mac.ifr_hwaddr.sa_data[2], (unsigned char)ifr_mac.ifr_hwaddr.sa_data[3], (unsigned char)ifr_mac.ifr_hwaddr.sa_data[4],
            (unsigned char)ifr_mac.ifr_hwaddr.sa_data[5]);
    zlog_info(zbt, "net :%s, local mac:%s", net, mac_addr);
    close(sock_mac);
    return std::string(mac_addr);
}

std::string GetGwIp_(const char *eth_name) {
    int sockfd;
    char gwip_[16] = {0};
    if (-1 == (sockfd = socket(PF_INET, SOCK_STREAM, 0))) {
        zlog_error(zct, "[GetGwIp_] fail to create socket");
        return "";
    }
    struct ifreq req;
    struct sockaddr_in *host;

    bzero(&req, sizeof(struct ifreq));
    strcpy(req.ifr_name, eth_name);
    ioctl(sockfd, SIOCGIFADDR, &req);
    host = (struct sockaddr_in *)&req.ifr_addr;
    close(sockfd);
    if (host) {
        strcpy(gwip_, inet_ntoa(host->sin_addr));
    }
    return std::string(gwip_);
}

std::string IpAddrInit() {
    const char *WLAN2 = "wlan2";
    const char *WLAN0 = "wlan0";
    const char *ETH0 = "eth0";
    const char *USB0 = "usb0";
    const char *WWAN0 = "wwan0";
    const char *ETH1 = "eth1";
    const char *ETH2 = "eth2";
    std::string strip = "";
    strip = GetGwIp_(WLAN0);
    if (strip.compare("0.0.0.0") != 0) {
        //zlog_info(zct, "[IpAddrInit] wlan0: %s", strip.c_str());
        return strip;
    }
    strip = GetGwIp_(WLAN2);
    if (strip.compare("0.0.0.0") != 0) {
        //zlog_info(zct, "[IpAddrInit] wlan2: %s", strip.c_str());
        return strip;
    }
    strip = GetGwIp_(ETH1);
    if (strip.compare("0.0.0.0") != 0 && strip.compare("192.168.188.188") != 0) {
        //zlog_info(zct, "[IpAddrInit] eth1: %s", strip.c_str());
        return strip;
    }
    strip = GetGwIp_(ETH2);
    if (strip.compare("0.0.0.0") != 0 && strip.compare("192.168.188.188") != 0) {
        //zlog_info(zct, "[IpAddrInit] eth2: %s", strip.c_str());
        return strip;
    }
    strip = GetGwIp_(ETH0);
    if (strip.compare("0.0.0.0") != 0) {
        //zlog_info(zct, "[IpAddrInit] eth0: %s", strip.c_str());
        return strip;
    }
    strip = GetGwIp_(USB0);
    if (strip.compare("0.0.0.0") != 0) {
        //zlog_info(zct, "[IpAddrInit] usb0: %s", strip.c_str());
        return strip;
    }
    strip = GetGwIp_(WWAN0);
    if (strip.compare("0.0.0.0") != 0) {
        //zlog_info(zct, "[IpAddrInit] wwan0: %s", strip.c_str());
        return strip;
    }
    zlog_warn(zct, "[IpAddrInit] ip: %s", strip.c_str());
    return strip;
}

std::string &ClearAllSpace(std::string &str) {
    size_t index = 0;
    if (!str.empty()) {
        while ((index = str.find(' ', index)) != std::string::npos) {
            str.erase(index, 1);
        }
    }
    return str;
}

std::string GetSysInfo() {
    const char *getCpuUse = "top -b -n 1 |grep Cpu | cut -d \",\" -f 1 | cut -d \":\" -f 2 |tr -d ' us'";
    char chRes[100] = {0};
    system_custom(getCpuUse, chRes);
    std::string CpuUse = std::string(chRes);

    const char *getCpuSys = "top -b -n 1 |grep Cpu | cut -d \",\" -f 2 |tr -d ' sy'";
    memset(chRes, 0, 100);
    system_custom(getCpuSys, chRes);
    std::string CpuSys = std::string(chRes);

    const char *getMemtotal = "cat /proc/meminfo | grep MemTotal | awk -F"
                              ":"
                              " '{print $2}' |tr -d ' kB'";
    memset(chRes, 0, 100);
    system_custom(getMemtotal, chRes);
    std::string MemTotal = std::string(chRes);

    const char *getMemFree = "cat /proc/meminfo | grep MemFree | awk -F"
                             ":"
                             " '{print $2}' |tr -d ' kB'";
    memset(chRes, 0, 100);
    system_custom(getMemFree, chRes);
    std::string MemFree = std::string(chRes);

    float a = atof(MemFree.c_str());
    float b = atof(MemTotal.c_str());
    float c = (1 - a / b) * 100;

    const char *getEmmcInfo = "df -h | grep /dev/root";
    memset(chRes, 0, 100);
    system_custom(getEmmcInfo, chRes);
    std::string Emmcinfo = std::string(chRes);
    std::size_t found = Emmcinfo.find("%");
    if (found != std::string::npos) {
        Emmcinfo = Emmcinfo.substr(found - 3, 3);
    }
    Emmcinfo = ClearAllSpace(Emmcinfo);

    char sysinfo[128] = {0};
    sprintf(sysinfo, "%-13s%-13s%-13s%-13s ", std::to_string(c).substr(0, 4).c_str(), CpuSys.c_str(), CpuUse.c_str(), Emmcinfo.c_str());
    return std::string(sysinfo);
}

int SetTime(unsigned long seconds, int milliseconds) {
    struct timeval tv;
    time_t timep = (time_t)seconds;
    tv.tv_sec = timep;
    tv.tv_usec = milliseconds * 1000;
    return settimeofday(&tv, NULL);
}

void ZoneConfig(std::string zoneid) {
    int a = 0;
    std::string zonelists[] = {"UTC+12", "UTC+11", "UTC+10", "UTC+9", "UTC+8", "UTC+7", "UTC+6", "UTC+5", "UTC+4", "UTC+3", "UTC+2", "UTC+1", "UTC+0", "UTC-1", "UTC-2", "UTC-3", "UTC-4", "UTC-5", "UTC-6", "UTC-7", "UTC-8", "UTC-9", "UTC-10", "UTC-11"};
    for (size_t i = 0; i < sizeof(zonelists); i++) {
        if (zoneid.compare(zonelists[i]) == 0) {
            a = i;            
            zlog_info(zbt, "[ZoneConfig] zoneid:%s, a: %d", zoneid.c_str(), a);
            break;
        }
    }
    switch (a) {
        case 0: zoneid = "GMT-12"; break;
        case 1: zoneid = "GMT-11"; break;
        case 2: zoneid = "GMT-10"; break;
        case 3: zoneid = "GMT-9"; break;
        case 4: zoneid = "GMT-8"; break;
        case 5: zoneid = "GMT-7"; break;
        case 6: zoneid = "GMT-6"; break;
        case 7: zoneid = "GMT-5"; break;
        case 8: zoneid = "GMT-4"; break;
        case 9: zoneid = "GMT-3"; break;
        case 10: zoneid = "GMT-2"; break;
        case 11: zoneid = "GMT-1"; break;
        case 12: zoneid = "GMT-0"; break;
        case 13: zoneid = "GMT+1"; break;
        case 14: zoneid = "GMT+2"; break;
        case 15: zoneid = "GMT+3"; break;
        case 16: zoneid = "GMT+4"; break;
        case 17: zoneid = "GMT+5"; break;
        case 18: zoneid = "GMT+6"; break;
        case 19: zoneid = "GMT+7"; break;
        case 20: zoneid = "GMT+8"; break;
        case 21: zoneid = "GMT+9"; break;
        case 22: zoneid = "GMT+10"; break;
        case 23: zoneid = "GMT+11"; break;
    }
    char cmd[256] = {0};
    memset(cmd, 0, 256);
    sprintf(cmd, "sudo ln -sf /usr/share/zoneinfo/Etc/%s  /etc/localtime", zoneid.c_str());
    system(cmd);
    zlog_info(zbt, "change timezone success!");
}

std::string GetFileContent(std::string filename, int line) {
    std::string strFileContent("");
    std::ifstream ifileOut(filename.c_str());
    if (!ifileOut.is_open()) {
        zlog_error(zct, "fail to open:%s", filename.c_str());
        return strFileContent;
    }
    
    int i = 1;
    while (!ifileOut.eof()) {
        if (line == 0) {
            std::string strTemp("");
            getline(ifileOut, strTemp);
            strFileContent += strTemp;
            strFileContent += "\r\n";
        } else {
            std::string strTemp("");
            getline(ifileOut, strTemp);
            if (line == i) {
                strFileContent = strTemp;
                break;
            }
        }
        ++i;
    }
    ifileOut.close();    
    return strFileContent;
}

// BOOST闂傚倷鑳堕崕鐢稿磻閹捐绀夌€广儱顦介弫鍡樼節婵犲倻澧曠紒鈧崱妯肩闁糕剝锚缁旈箖鏌嶈閸撴瑩宕姘肩劷闊洦绋戠粻姘辨喐韫囨洘鍏滈柍褜鍓氭穱濠囧Χ閸ヮ灝銏ゆ煟椤撴繄绐旈柟顖欑劍缁诲懘鎯囬弴銏♀拺闂傚牃鏅犲顔界節閵忊埗顏堚€﹂崶顒€绀冩い鏃囧琚濋梻浣稿閸嬪棝宕伴幘璇参ラ柨鐕傛嫹
bool CheckIP(const char *ip) {
    boost::xpressive::cregex reg_ip =
        boost::xpressive::cregex::compile("(25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])[.](25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])[.](25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])[.](25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])");
    return boost::xpressive::regex_match(ip, reg_ip);
}

bool IsValidMask(std::string mask) {
    int iRet = -1;

    // 闂備浇顕х换鎰崲閹版澘绠查柛鎴︿憾濮婃椽妫冮埡鍛€嶅┑鐘灪閿氭い顓炴喘瀹曟﹢顢欓挊澶夌紦闂備胶鎳撻崥鈧悹浣圭叀瀹曟垿骞橀弬銉ョ墯闂佸憡渚楅崢娲礌閺嶎厽鈷戦柛娑橈工缁楁帗淇婇锝庢當闁伙絿鍏樺畷鐔碱敆娴ｉ攱鍞夋繝鐢靛仦閸ㄥ爼鏁嬮梺缁樻尰閸ㄥ潡寮诲澶娢ㄩ柨鏂垮⒔閻ｆ儳鈹戦悙瀛樼稇婵☆偅绻堥悰顕€骞嬮敃鈧～鍛存煃閵夈儳锛嶅ù婊愭嫹 闂傚倷鑳堕崑銊╁磿閼碱剙鍨濋柛顐犲灱婵娊鏌嶉崫鍕偓瑙勭閵堝棛绠鹃柟瀵镐紳椤忓牊鍋傞柟杈鹃檮閻撴稑霉閿濆懏鎲搁柟鐣屽█閺岋繝宕卞▎蹇旂亪闂佹悶鍔戠粻鏍极閹剧粯鏅搁柨鐕傛嫹
    struct in_addr s;
    iRet = inet_pton(AF_INET, mask.c_str(), &s);

    // 闂備礁鎼ˇ閬嶅磿閹版澘绀堟慨姗嗗墰閺嗭箓鏌＄仦璇插姎缂佺媴缍侀弻鐔兼焽閿曗偓婢ь喗銇勯銈呪枅鐎殿喖鐖奸崺锟犲磼濞戞艾寮虫繝鐢靛仩椤曟粓骞忛敓锟�1闂傚倷鐒︾€笛呯矙閹达附鍎楀〒姘ｅ亾妞ゃ垺宀搁崺锟犲川椤撶偛鎸ら梺鐟板悑閻ｎ亪宕归搹鍦噮闂傚倷绀侀幖顐︽偋閸℃蛋鍥ㄥ閺夋垹鏌ч梺闈涱槴閺呮粓宕曞澶嬬厱闁规惌鍘介惁浠嬫⒒娓氣偓濞煎姊介崟顐唵婵☆垯璀﹂悞浠嬫煥閻曞倹瀚�
    if (iRet == 1) {
        // 婵犵數鍋涢顓熸叏閺夋嚚瑙勵槹鎼达絿顦繝銏ｆ硾閻偐澹曢崗鑲╃瘈濠电姴鍊搁弳鐔兼煙閻ｅ苯鏋涢柡灞诲€濆畷顐﹀礋椤愮喎浜鹃柛褎顨呰繚闁瑰吋鐣崹娲磿閻旇偐鍙撻柛銉ｅ妿椤ｈ尙绱掓笟鍥ф珝闁哄瞼鍠撻幏鐘诲焺閸愵亞鐛㈤梺鑽ゅУ閸旀宕伴幇顔剧煓濠㈣泛鐬肩壕鍏间繆椤栨繂鍚归柣銊ヮ煼閺岋絾鎯旈姀鈶╁濡炪們鍔岄ˇ鐗堢┍婵犲浂鏁囬柣鏃傜節缁ㄥ姊洪崨濠勭畵閻庢凹鍠氶崰濠囨晸閿燂拷
        unsigned int addr = ntohl(s.s_addr);

        // 闂備礁鎼ˇ閬嶅磿閹版澘绀堟慨姗嗗墰閺嗭箓鏌涘▎蹇ｆШ闁崇粯妫冨鍫曟倷閺夋埈妫嗛梺璋庡啰鐒哥€殿喖鐖奸崺锟犲磼濠х偓顫嶉梻浣虹《閺呮粓銆冮崼銉ョ劦妞ゆ帊鑳堕埊鏇熴亜閵娿儳澧︽い銏＄墬閹峰懘宕烽娑欑亙闂備浇娉曢崳锕傚箯閿燂拷
        std::bitset<32> b((int)addr);
        std::string strMask = b.to_string();

        // 闂傚倷绀侀幖顐ゆ偖椤愶箑纾块柛娆忣槺閻濊埖淇婇婵嗗惞妞も晞灏欓埀顒€鍘滈崑鎾绘煕閹板吀绨芥い鏃€甯″娲川婵犲倻顑勫┑鐐差槹閻╊垶骞冩ウ娆炬Ь缂備緡鍣崣鍐极閸岀偞鍤勬い鏍电稻閼哥懓鈹戦悙鏉戠仸闁瑰皷鏅犲畷銏ゅ箚瑜夐弸鏃堟煥閻曞倹瀚�"01"闂傚倷鐒︾€笛呯矙閹达附鍤愭い鏍亼閳ь剙鎳撻ˇ鍦偓娈垮枤鏋顏冨嵆閸┾偓妞ゆ帒鍊荤粻鏂款熆鐠哄搫顦柛瀣尭閳藉鈻嶉褌绨婚柨鏇樺灲椤㈡棃宕奸悢鍛婄彨闁诲骸鍘滈崑鎾绘煕閹邦厼鍔ゆ繛鍫灦濮婃椽宕崟顐患闁诲孩绋堥弲娑樺祫闂佸綊妫跨粈浣衡偓姘槸椤法鎹勬笟顖氬壉濠电偛鎳庣换姗€寮婚敐澶娢╅柕澶堝労娴犲ジ姊洪悜鈺佸⒉闁荤啙鍛潟闁哄啫鐗嗙粻锝夋煟閹邦垰钄肩紒鈧€ｎ喗鈷戞繛鑼额嚙濞呮瑩鏌熼崙銈嗗
        return (strMask.find("01") == std::string::npos);
    }

    return false;
}

double GetHardDiskFree() {
    char hardName[32];
    char hardTotal[32];
    char hardUse[32];
    char hardFree[32];
    char rateHardUse[32];
    const char *getEmmcInfo = "df -h | grep /opt";
    char chRes[100];
    memset(chRes, 0, 100);
    system_custom(getEmmcInfo, chRes);
    sscanf(chRes, "%s%s%s%s%s", hardName, hardTotal, hardUse, hardFree, rateHardUse);
    std::string strhardTotal(hardTotal);
    std::string strhardFree(hardFree);
    std::string strrateHardUse(rateHardUse);
    double freeDisk = atof(strhardFree.substr(0, strhardFree.length() - 1).c_str());
    return freeDisk;
}

int getSysIntValue(char *key) {
    if (key == NULL) {
        zlog_error(zct, "key is NULL");
        return 0;
    }
    FILE *fp = NULL;
    int value = 0;  
    fp = fopen(key, "r");
    if (fp == NULL) {
        zlog_error(zct, "could not open %s file", key);
        return 1;
    }

    fscanf(fp, "%d", &value);
    fclose(fp);
    return value;
}

std::string GetSysStatus() {
    long mem_used = -1;
    long mem_free = -1;
    long mem_total = -1;
    long mem_cached = -1;
    char name1[20];
    std::string strMemTotal = GetFileContent("/proc/meminfo", 1);
    std::string strMemFree = GetFileContent("/proc/meminfo", 2);
    std::string strMemCache = GetFileContent("/proc/meminfo", 5);

    sscanf(strMemTotal.c_str(), "%s%ld", name1, &mem_total);
    sscanf(strMemFree.c_str(), "%s%ld", name1, &mem_free);
    sscanf(strMemCache.c_str(), "%s%ld", name1, &mem_cached);
    mem_used = mem_total - mem_free;
    float fMemRate = 1.0 * mem_used / mem_total;

    char name[8];
    double cpu_sys = -1;
    double cpu_user = -1;
    double cpu_total = -1;
    long int user, nice, sys, idle, iowait, irq, softirq;
    std::string strCpu1 = GetFileContent("/proc/stat", 1);
    sscanf(strCpu1.c_str(), "%s%ld%ld%ld%ld%ld%ld%ld", name, &user, &nice, &sys, &idle, &iowait, &irq, &softirq);
    sleep(1);
    long int userNext, niceNext, sysNext, idleNext, iowaitNext, irqNext, softirqNext;
    std::string strCpu2 = GetFileContent("/proc/stat", 1);
    sscanf(strCpu2.c_str(), "%s%ld%ld%ld%ld%ld%ld%ld", name, &userNext, &niceNext, &sysNext, &idleNext, &iowaitNext, &irqNext, &softirqNext);
    cpu_total = (userNext + niceNext + sysNext + idleNext + iowaitNext + irqNext + softirqNext) - (user + nice + sys + idle + iowait + irq + softirq);
    cpu_user = userNext - user;
    cpu_sys = sysNext - sys;
    float rateUser = cpu_user * 100.0 / cpu_total;
    float rateSys = cpu_sys * 100.0 / cpu_total;
    if (rateUser > 95) {
        rateUser = 92;
    }
    char hardTotal[32];
    char hardFree[32];
    char rateHardUse[32];
    char chRes[100];
    memset(chRes, 0, 100);
#ifdef IMX6UL_GATEWAY
    char hardName[32];
    char hardUse[32];
    const char *getEmmcInfo = "df -h | grep /opt";
    system_custom(getEmmcInfo, chRes);
    sscanf(chRes, "%s%s%s%s%s", hardName, hardTotal, hardUse, hardFree, rateHardUse);
#endif
#ifdef G2UL_GATEWAY
    getDiskInfo(hardTotal, hardFree);
#endif

    std::string strhardTotal(hardTotal);
    std::string strhardFree(hardFree);
    std::string strrateHardUse(rateHardUse);

    char key[128] = {0};
    memset(key, 0, sizeof(key));
    sprintf(key, "/sys/class/thermal/thermal_zone0/temp");
    int temp = getSysIntValue(key);

    Json::Value jsData;
    Json::FastWriter fw;
    jsData["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsData["cpuUserUse"] = rateUser;
    jsData["memoryTotal"] = (int)mem_total;
    jsData["memoryFree"] = (int)mem_free;
    jsData["memoryUse"] = fMemRate * 100;
    jsData["hardDiskTotal"] = atof(strhardTotal.substr(0, strhardTotal.length() - 1).c_str());
    jsData["hardDiskFree"] = atof(strhardFree.substr(0, strhardFree.length() - 1).c_str());
    jsData["temperature"] = temp / 1000.0;
    jsData["temperatureNR5G"] = atoi(GlobalConfig::NR5GTemp.c_str());

    float total = atof(strhardTotal.substr(0, strhardTotal.length() - 1).c_str());
    float free = atof(strhardFree.substr(0, strhardFree.length() - 1).c_str());
    float use = ((total - free) / total) * 100;
    jsData["hardDiskUse"] = use;
    jsData["cpuSystemUse"] = rateSys;

    char localtimestamp[32] = {0};
    GetTimeNet(localtimestamp, 1);
    std::string nowTimetamp = std::string(localtimestamp);
    jsData["updateTime"] = nowTimetamp;
    std::string strJson = fw.write(jsData);
    return strJson;
}

// 闂備浇顕х换鎰崲閹邦儵娑樜旈埀顒勬偩閻戣姤鍋勯柛婵勫劗閺嬫牠姊虹捄銊ユ珢闁瑰嚖鎷�16闂備礁鎼ˇ顐﹀疾濠婂懐鐭欓柟杈剧畱閺勩儲淇婇妶鍛殜闁稿鎸搁埥澶娾枎濡崵鏆俊鐐€栭崹鎶芥倿閿曗偓椤洭顢旈崼顐ｆ櫌婵炶揪绲挎灙缂併劊鍎茬换娑㈠箣閻愭潙纰嶉梺鍦拡閸嬪﹪銆佸棰濇晩闁兼亽鍎遍崝鍛存⒑閸濆嫬鏆欓柛濠傜秺閹箖鏌嗗鍡椻偓鍨箾閹寸偟鎳愭繛鍫熺懃閳规垿鍩ラ崱妤€绫嶉悗瑙勬礃閸旀瑩寮幘缁樻櫢闁跨噦鎷�
unsigned char hexCharToByte(char c) {
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    return 0; // 闂備浇顕уù鐑藉极婵犳艾鐒垫い鎺嶈兌閵嗘帡鏌よぐ鎺旂暫闁哄矉绻濆畷姗€顢旈崟鎴秮閺岋繝宕ㄩ銏犲Е闂佽鍨伴崯鏉戠暦閻旂⒈鏁冮柕鍫濇閸犳洜绱撻崒娆戝妽妞ゃ劍鍔楅幏瀣晲閸ヮ煈娼熷┑鐘绘涧濞诧附绂嶉妶澶嬬厸闁稿本绋戦婊呯磼閳ь剟鍩€閿燂拷0
}

// 闂備浇顕х换鎰殽韫囨稑绠柨鐕傛嫹16闂備礁鎼ˇ顐﹀疾濠婂懐鐭欓柟杈剧畱閺勩儲淇婇妶鍛殜闁稿鎸搁埥澶娾枎濡崵鏆俊鐐€栭崹鎶芥倿閿斿墽鐭欏鑸靛姈閸ゆ垿鏌ら崫銉︽毄闁靛牜鍣ｅ铏规兜閸滀礁娈愬┑鐘噰閸嬫捇鏌ｉ悩鍐插闁哥姵鎹囬崺鈧い鎺嶈兌閳洘銇勯妸銉Ч濞ｅ洤锕、姗€濮€閻樺磭鈧剟姊虹憴鍕靛晱闁哥姵宀搁幆宀勬晸閿燂拷
int hexStringToBytes(const char *hexStr, unsigned char *bytes, size_t bytesSize) {
    size_t hexLen = strlen(hexStr);
    if (hexLen % 2 != 0) {
        zlog_error(zct, "hexLen:%d is odd", hexLen);
        return -1; // Hex闂備浇顕х€涒晝绮欓幒妞尖偓鍐醇閵夘喗鏅炴繛杈剧到濠€閬嶅煝閺冨牊鐓涢悘鐐额嚙閸旀粍鎱ㄩ敐鍡楀妤犵偞鐗楀蹇涘礈瑜忛弳鐘电磽娴ｉ潧濮€閻忓繑鐟╅獮蹇涙偐鐠囧弬銊╂煥閺傚灝寤洪柨鏇炲€归悡鏇㈡倵閿濆骸骞栭柣鎾村姍閺岋繝宕遍鐔奉伓
    }
    if (bytesSize < hexLen / 2) {
        zlog_error(zct, "bytesSize:%d < hexLen:%d", bytesSize, hexLen);
        return -1; // 闂備浇顕х€涒晝绮欓幒妞尖偓鍐╁緞鐎ｂ晝绠氬銈嗘尪閸ㄥ綊寮告笟鈧弻鐔封枔閸喗鐏撻梺娲诲幖椤戝寮婚敐澶娢╅柕澶堝労娴犲ジ姊洪棃娑欐悙婵炲眰鍔嶇粋宥咁潰瀹€鈧悿鈧柟鑹版彧缁插潡骞夎ぐ鎺撶厽闁斥晛鍟粭鎺楁煕濡崵澧紒鍌氱Ч楠炴帡寮崫鍕闂佽崵鍠撴晶妤冩嫻閿熺姵鐓欓柟顖嗗啯鍊┑鐐碘拡娴滎亪銆佸Δ浣瑰缂佸娉曢崫搴ㄦ⒒娴ｅ憡鍟為柤瑙勫劤闇夌€瑰嫭澹嬮弸鏃堟煙鐎电ǹ袥闁稿鎸搁埥澶娾枎濡崵鏆┑鐘殿暯濡插嫰骞忛敓锟�
    }

    for (size_t i = 0; i < hexLen; i += 2) {
        unsigned char highNibble = hexCharToByte(hexStr[i]);
        unsigned char lowNibble = hexCharToByte(hexStr[i + 1]);
        bytes[i / 2] = (highNibble << 4) | lowNibble;
    }

    return 0; // 闂傚倷鑳堕幊鎾绘偤閵娾晛绀夐柡鍥╁枑閸欏繘鏌ㄩ悤鍌涘
}

void stringToHex(const char *str, char *hexStr) {
    while (*str) {
        sprintf(hexStr, "%02x", (unsigned char)*str);
        hexStr += 2;
        str++;
    }
    *hexStr = '\0';
}

void hexToAscii(const char *hexStr, char *asciiStr) {
    int len = strlen(hexStr);
    int i, j = 0;

    for (i = 0; i < len; i += 2) {
        // 闂備浇宕垫慨鏉懨洪埡鍜佹晪鐟滄垿濡甸幇鏉跨倞闁靛ě鈧弸鏍⒑闂堟稓澧曢悗姘嵆瀹曠數鈧綆鍠楅崐鍨箾閹寸偟鎳愭繛鍫熒戦妵鍕箣濠婂懐鐛㈤梺缁樹緱閸犳岸骞戦崟顖涙優閻熸瑥瀚烽崯鍫ユ⒒娴ｅ懙鍦崲閹达箑纾块柣鎾崇瘍瑜版帒骞㈡繛鎴烆焽椤斿顪冮妶搴′航闁告瑢鍋撶紓浣插亾閻庯綆鍠楅悡娑樏归敐鍛喐闁圭晫濞€閺岋繝宕遍鐔奉伓
        int byte;
        sscanf(&hexStr[i], "%2x", &byte);
        // 闂備浇顕х换鎰崲閹邦儵娑樷枎閹捐櫕杈堥梺鎸庣箓椤︻垶寮告笟鈧弻鐔风暋閻楀牊鎷辩紓浣风贰閸ｏ綁寮婚悢鐑樺珰闁斥晛鍟扮粣鏃堟煟閻樺啿濮夐柛鐘虫崌閸┾偓妞ゆ帒鍊归弳鈺呮煙閾忣偅灏甸柤娲憾瀵濡烽敃鈧崜顓㈡⒑閸涘﹤鐏﹂柍鐟伴拤II闂備浇顕х€涒晝绮欓幒妞尖偓鍐醇閵夘喗鏅為梺璺ㄥ櫐閹凤拷
        asciiStr[j++] = (char)byte;
    }
    // 濠电姷鏁搁崕鎴犵礊閳ь剚銇勯弴鍡楀閸欏繘鏌ｉ幇顕呮毌闁稿鎸搁埥澶娾枎濡崵鏆俊鐐€栭崹鎶芥倿閿斿墽鐭欏鑸靛姈閸ゆ垶銇勯幒鎴濃偓鍦焊濠靛鈷戦柛婵嗗濡叉椽鏌涢悩铏磳妞ゃ垺鐗犻弫鎾绘晸閿燂拷
    asciiStr[j] = '\0';
}

unsigned char ch2hex(char ch) {
    static const char *hex = "0123456789ABCDEF";
    for (unsigned char i = 0; i != 16; ++i)
        if (ch == hex[i]) return i;
    return 0;
}


char *solve(char *dest, const char *src) {
    int i = 0;
    int cnt = 0;
    unsigned char *d = (unsigned char *)dest;
    while (*src) {
        if (i & 1) {
            d[cnt++] |= ch2hex(*src);
        } else {
            d[cnt] = ch2hex(*src) << 4;
        }
        src++;
        i++;
    }
    return dest;
}

void swap(char *data) {
    int tmp;
    tmp = data[1];
    data[1] = data[0];
    data[0] = tmp;
}

int OpenWatchDog() {
    int fd = -1;
    InitGpio(GlobalConfig::GPIO_G.hardWatchDog, 1);
    gpio_set(GlobalConfig::GPIO_G.hardWatchDog, 1); //婵犲痉鏉库偓鏇㈠磹瑜版巻鈧箓宕堕鈧弸渚€鏌熼梻纾嬪厡鐎规挷绶氶弻褑绠涢敐鍛凹缂備胶濮电敮锟犲蓟閳╁啰鐟瑰┑鐘插暙椤忥拷
    if (0 > (fd = open("/dev/watchdog", O_WRONLY))) {
        zlog_error(zbt, "fail to open /dev/watchdog");
    }
    return fd;
}

int WriteWatchDog(int fd) {
    if (1 != write(fd, "0", 1)) {
        zlog_error(zbt, "fail to feed watchdog");
        return 1;
    }
    return 0;
}

std::string TrimStringLeft(const char *szData, const char *szTargets) {
    std::string strData = szData;
    int nPos = 0;
    nPos = strData.find(szTargets);
    while (nPos == 0) {
        strData.erase(nPos, 1);
        nPos = strData.find(szTargets);
    }
    return strData;
}

std::string TrimStringRight(const char *szData, const char *szTargets) {
    std::string strData = szData;
    int nPos = 0;
    nPos = strData.rfind(szTargets);
    while ((nPos == (int)(strData.size() - 1)) && (nPos >= 0)) {
        strData.erase(nPos, 1);
        nPos = strData.rfind(szTargets);
    }
    return strData;
}

std::string GetOneContent(const char *szData, int nRow, const char *szSeparate) {
    std::string strParam = "";
    std::string strTemp = szData;
    int nFirstPos = -1;
    for (int i = 0; i < nRow; i++) {
        nFirstPos = strTemp.find(szSeparate, nFirstPos + 1);
        if (nFirstPos < 0) return strParam.c_str();
    }

    int nSecondPos = strTemp.find(szSeparate, nFirstPos + 1);
    if (nSecondPos < 0) {
        strParam = strTemp.substr(nFirstPos + 1);
    } else {
        strParam = strTemp.substr(nFirstPos + 1, nSecondPos - nFirstPos - 1);
    }
    
    strParam = TrimStringRight(strParam.c_str(), " ");
    strParam = TrimStringLeft(strParam.c_str(), " ");  
    return strParam.c_str();
}

int set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop) {
    zlog_info(zbt, "[set_opt] speed:%d, bits:%d, event:%c, stop:%d", nSpeed, nBits, nEvent, nStop);
    struct termios newtio, oldtio;
    if (tcgetattr(fd, &oldtio) != 0) { //濠电姷顣藉Σ鍛村磻閳ь剟鏌涚€ｎ偅灏扮紒缁樼洴瀵爼骞嬮鐐插闂佽崵鍠愬ú鏍涘┑鍡欐殾闁挎繂顦伴弲鏌ユ煕閳╁喚鐒洪柨鏇炲€归悡鏇熸叏濡搫鈷旈柣锝堜含閹叉悂鎮ч崼銏犲绩闂佽鍠曠划娆撳极閹剧粯鏅搁柨鐕傛嫹
        zlog_error(zbt, "tcgetattr fail");
        return -1;
    }
    bzero(&newtio, sizeof(newtio));
    newtio.c_cflag |= CLOCAL | CREAD;
    newtio.c_cflag &= ~CSIZE;

    switch (nBits) {
        case 7: newtio.c_cflag |= CS7; break;
        case 8: newtio.c_cflag |= CS8; break;
        default:
            zlog_error(zbt, "invalid nbits:%d", nBits);
            break;
    }

    switch (nEvent) {
        case 'O':
            newtio.c_cflag |= PARENB;
            newtio.c_cflag |= PARODD;
            newtio.c_iflag |= (INPCK | ISTRIP);
            break;
        case 'E':
            newtio.c_iflag |= (INPCK | ISTRIP);
            newtio.c_cflag |= PARENB;
            newtio.c_cflag &= ~PARODD;
            break;
        case 'N': newtio.c_cflag &= ~PARENB; break;
        default:
            zlog_error(zbt, "invalid event:%c", nEvent);
            break;
    }

    switch (nSpeed) //闂備浇宕垫慨宕囩矆娴ｈ娅犲ù鐘差儐閸嬵亪鏌涢埄鍐︿粶闁哄鐗犻弻鏇＄疀鐎ｎ亞浠煎銈冨劜椤ㄥ﹪寮婚敐鍛牚闁归偊鍘奸锟�
    {
        case 2400:
            cfsetispeed(&newtio, B2400);
            cfsetospeed(&newtio, B2400);
            break;
        case 4800:
            cfsetispeed(&newtio, B4800);
            cfsetospeed(&newtio, B4800);
            break;
        case 9600:
            cfsetispeed(&newtio, B9600);
            cfsetospeed(&newtio, B9600);
            break;
        case 115200:
            cfsetispeed(&newtio, B115200);
            cfsetospeed(&newtio, B115200);
            break;
        case 460800:
            cfsetispeed(&newtio, B460800);
            cfsetospeed(&newtio, B460800);
            break;
        default:
            cfsetispeed(&newtio, B9600);
            cfsetospeed(&newtio, B9600);
            zlog_error(zbt, "invalid speed:%d, use B9600", nSpeed);
            break;
    }
    if (nStop == 1) //闂備浇宕垫慨宕囩矆娴ｈ娅犲ù鐘差儐閸嬵亪鏌涢埄鍐槈缁惧墽绮换婵囩節閸屾凹浼岄梺鍛婃尰閸庢娊婀侀梺鎸庣箓缁绘垹鈧熬鎷�
        newtio.c_cflag &= ~CSTOPB;
    else if (nStop == 2)
        newtio.c_cflag |= CSTOPB;
    newtio.c_cc[VTIME] = 0;
    newtio.c_cc[VMIN] = 0;
    tcflush(fd, TCIFLUSH);
    if ((tcsetattr(fd, TCSANOW, &newtio)) != 0) {
        zlog_error(zbt, "tcsetattr fail");
        return -1;
    }
    return 0;
}

int getcsq() {
    int ret = 0;
    char csq[128] = {0};
    int fd = 0;

    if ((fd = open("/dev/ttyUSB2", O_RDWR | O_NOCTTY | O_NDELAY)) < 0) {
        zlog_error(zct, "fail to open /dev/ttyUSB2");
        return 1;
    } else {
        set_opt(fd, 9600, 8, 'N', 1);
    }
    set_opt(fd, 115200, 8, 'N', 1);

    ret = write(fd, "AT+CSQ", 6);
    if (ret < 0) {
        zlog_error(zct, "fail to write AT+CSQ");
        close(fd);
        return 1;
    }
    sleep(1);
    unsigned char rbuf[128] = {0x00};
    int len = read(fd, rbuf, sizeof(rbuf)); // 闂傚倷绶氬鑽ゆ嫻閻旂厧绀夐悗锝庡墯閸熸椽鏌涢埄鍐槈闁活厽顨婇弻銊モ攽閸℃瑥鈷堥梺鎼炲€戦崹浠嬪蓟濞戞粎鐤€閻庯綆浜滄慨搴ㄦ⒑閻戔晛顫掗柛娑卞灣閻ｅ爼姊洪幐搴㈩梿闁稿骸顭烽妴鍛存晸閿燂拷
    close(fd);
    zlog_info(zct, "rbuf = %s,len = %d", rbuf, len);
    sleep(1);
    if (len < 0) {
        zlog_error(zct, "Can't get /dev/ttyUSBx Serial Port data!");
        return 1;
    }

    const char *str2 = "+QENG: ";
    char *pdata = strstr((char *)rbuf, str2);
    if (pdata)
        strncpy(csq, pdata + 7, sizeof(csq));
    else {
        zlog_error(zct, "fail to find +QENG: ");
        return -1;
    }
    GlobalConfig::NetStatus = GetOneContent(csq, 1, ",");
    std::string signal = GetOneContent(csq, 13, ",");
    GlobalConfig::NetSignal = atoi(signal.c_str());
    zlog_info(zct, "NetStatus = %s,NetSignal = %d", GlobalConfig::NetStatus.c_str(), GlobalConfig::NetSignal); 
    return atoi(signal.c_str());    
}

void IniReadValue(const char *section, const char *key, char *val, const char *file) {
    FILE *fp;
    int i = 0;
    int lineContentLen = 0;
    int position = 0;
    char lineContent[LINE_CONTENT_MAX_LEN];
    bool bFoundSection = false;
    bool bFoundKey = false;
    fp = fopen(file, "r");
    if (fp == NULL) {
        zlog_error(zbt, "fail to open %s", file);
        return;
    }

    while (feof(fp) == 0) {
        memset(lineContent, 0, LINE_CONTENT_MAX_LEN);
        fgets(lineContent, LINE_CONTENT_MAX_LEN, fp);
        if ((lineContent[0] == ';') || (lineContent[0] == '\0') || (lineContent[0] == '\r') || (lineContent[0] == '\n')) {
            continue;
        }

        // check section
        if (strncmp(lineContent, section, strlen(section)) == 0) {
            bFoundSection = true;
            // printf("Found section = %s\n", lineContent);
            while (feof(fp) == 0) {
                memset(lineContent, 0, LINE_CONTENT_MAX_LEN);
                fgets(lineContent, LINE_CONTENT_MAX_LEN, fp);
                // check key
                if (strncmp(lineContent, key, strlen(key)) == 0) {
                    bFoundKey = true;
                    lineContentLen = strlen(lineContent);
                    // find value
                    for (i = strlen(key); i < lineContentLen; i++) {
                        if (lineContent[i] == '=') {
                            position = i + 1;
                            break;
                        }
                    }
                    if (i >= lineContentLen) break;
                    strncpy(val, lineContent + position, strlen(lineContent + position));
                    lineContentLen = strlen(val);
                    for (i = 0; i < lineContentLen; i++) {
                        if ((lineContent[i] == '\0') || (lineContent[i] == '\r') || (lineContent[i] == '\n')) {
                            val[i] = '\0';
                            break;
                        }
                    }
                } else if (lineContent[0] == '[') {
                    break;
                }
            }
            break;
        }
    }
    fclose(fp);
    if (!bFoundSection) {
        zlog_error(zbt, "No section = %s", section);
    } else if (!bFoundKey) {
        zlog_error(zbt, "No key = %s", key);
    }    
}

int readStringValue(const char *section, const char *key, char *val, const char *file) {
    zlog_info(zct, "section = %s, key = %s, file = %s", section, key, file);
    if (section == NULL || key == NULL || val == NULL || file == NULL) {
        zlog_error(zct, "input parameter, section:%s, key:%s, val:%s, file:%s exist NULL", section, key, val, file);
        return -1;
    }
    char sect[SECTION_MAX_LEN];
    memset(sect, 0, SECTION_MAX_LEN);
    sprintf(sect, "[%s]", section);
    IniReadValue(sect, key, val, file);
    return 0;
}

int readIntValue(const char *section, const char *key, const char *file) {
    char strValue[STRVALUE_MAX_LEN];
    memset(strValue, '\0', STRVALUE_MAX_LEN);
    if (readStringValue(section, key, strValue, file) != 0) {        
        return 0;
    }
    return (atoi(strValue));
}

void IniWriteValue(const char *section, const char *key, char *val, const char *file) {
    FILE *fp;
    char lineContent[LINE_CONTENT_MAX_LEN];
    char strWrite[LINE_CONTENT_MAX_LEN];
    bool bFoundSection = false;
    bool bFoundKey = false;
    int err = 0;
    memset(lineContent, '\0', LINE_CONTENT_MAX_LEN);
    memset(strWrite, '\0', LINE_CONTENT_MAX_LEN);
    sprintf(strWrite, "%s=%s\n", key, val);
    fp = fopen(file, "r+");
    if (fp == NULL) {
        zlog_error(zct, "fail to open:%s", file);
        return;
    }

    while (feof(fp) == 0) {
        memset(lineContent, 0, LINE_CONTENT_MAX_LEN);
        fgets(lineContent, LINE_CONTENT_MAX_LEN, fp);
        if ((lineContent[0] == ';') || (lineContent[0] == '\0') || (lineContent[0] == '\r') || (lineContent[0] == '\n')) {
            continue;
        }
        // check section
        if (strncmp(lineContent, section, strlen(section)) == 0) {
            bFoundSection = true;
            while (feof(fp) == 0) {
                memset(lineContent, 0, LINE_CONTENT_MAX_LEN);
                fgets(lineContent, LINE_CONTENT_MAX_LEN, fp);
                // check key
                if (strncmp(lineContent, key, strlen(key)) == 0) {
                    bFoundKey = true;
                    printf("%s: %s=%s\n", __func__, key, val);
                    fseek(fp, (0 - strlen(lineContent)), SEEK_CUR);
                    err = fputs(strWrite, fp);
                    if (err < 0) {
                        printf("%s err.\n", __func__);
                    }
                    break;
                } else if (lineContent[0] == '[') {
                    break;
                }
            }
            break;
        }
    }
    fclose(fp);
    if (!bFoundSection) {
        zlog_error(zct, "No section = %s", section);
    } else if (!bFoundKey) {
        zlog_error(zct, "No key = %s", key);
    }    
}

int writeStringVlaue(const char *section, const char *key, char *val, const char *file) {
//    char sect[SECTION_MAX_LEN];
    zlog_debug(zct, "section = %s, key = %s, file = %s", section, key, file);
    if (section == NULL || key == NULL || val == NULL || file == NULL) {
        zlog_error(zct, "input parameter(s) is NULL!");
        return -1;
    }
//    memset(sect, 0, SECTION_MAX_LEN);
//    sprintf(sect, "[%s]", section);
    IniWriteValue(section, key, val, file);
    return 0;
}

int writeIntValue(const char *section, const char *key, int val, const char *file) {
    char strValue[STRVALUE_MAX_LEN];
    memset(strValue, 0, STRVALUE_MAX_LEN);
    sprintf(strValue, "%d", val);
    writeStringVlaue(section, key, strValue, file);
    return 0;
}

int getDiskInfo(char *diskTotal, char *diskFree) {
    DISK diskInfo;    
    /* 1.闂傚倷绀侀崥瀣磿閹惰棄搴婇柤鑹扮堪娴滃綊鏌ㄩ悤鍌涘/home/婵犵數鍋為崹鍫曞箰閹间緡鏁勫璺衡看閻掕棄霉閻撳海鎽犻柛搴＄Ч閺屾盯寮撮妸銉ュ箣闂佺ǹ顑嗛幐楣冨箯閻樺樊鍟呮い鏂垮悑濞呭秹姊婚崒娆愮グ妞ゆ洘绮撻獮蹇涙晸閿燂拷 */
    statfs("/", &diskInfo);
    unsigned long long blocksize = diskInfo.f_bsize;
    unsigned long long totalsize = blocksize * diskInfo.f_blocks; 
                                                                  

    /* 2.闂傚倷绀侀崥瀣磿閹惰棄搴婇柤鑹扮堪娴滃綊鏌涢妷锝呭闁崇粯妫冮弻宥堫檨闁告挻姘ㄧ划娆愬緞鐏炵ǹ浜鹃柨婵嗙凹缁ㄥ鏌嶉柨瀣ⅹ闂囧鏌ㄥ┑鍡橆棤闁瑰啿鎳橀弻宥囨喆閸曨厼鈷屽┑顔硷工椤嘲顕ｉ崼鏇炵闁绘劕妯婃导鍛存⒒娴ｅ憡鍟為柣鐕佸灦瀹曞綊骞庨挊澶嬬€梺闈涚墕濞层劑鎯屽顓犵鐎瑰壊鍠曠花濂告煥濞戞艾鏋涢柡宀嬬秮婵℃悂濡烽妷顔绘偅闂備線娼уú銈吤洪妸锔绢洸闁归棿鐒﹂弲鎼佹煥閻曞倹瀚� */
    unsigned long long freeDisk = diskInfo.f_bfree * blocksize;       //闂傚倷绀侀幉锟犲箰閹绢喖鐤炬繛鍡樺灩缁€濠囨煙鐎电ǹ啸闁活厽纰嶇换娑橆啅椤旇崵鍑归梺鎸庣〒閸犳牠寮婚敐澶娢╅柕澶堝労娴犲ジ姊洪棃娑欐悙婵炲眰鍔嶇粋宥夊箹娴ｈ娅㈤梺璺ㄥ櫐閹凤拷
//    unsigned long long availableDisk = diskInfo.f_bavail * blocksize; //闂傚倷绀侀幉锟犳偡椤栫偛鍨傞柟鎯版閺嬩線鏌曢崼婵囧窛闁活厽纰嶇换娑橆啅椤旇崵鍑归梺鎸庣〒閸犲酣鈥﹂崸妤€閱囬柛鈩冾殔閺嗙喐鎱ㄩ敐蹇斿
    
    sprintf(diskTotal, "%llu", totalsize >> 20);
    sprintf(diskFree, "%llu", freeDisk >> 20);
    return 1;
}

unsigned short cal_chksum(unsigned short *addr, int len) {
    int nleft = len;
    int sum = 0;
    unsigned short *w = addr;
    unsigned short answer = 0;
    while (nleft > 1) {
        sum += *w++;
        nleft -= 2;
    }
    if (nleft == 1) {
        *(unsigned char *)(&answer) = *(unsigned char *)w;
        sum += answer;
    }
    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);
    answer = ~sum;
    return answer;
}

int socketHeart(const char *pSendData) {
    zlog_info(zct, "socketHeart");
    int sockfd;                       // Socket闂傚倷绀侀幖顐﹀磹缁嬫５娲晲閸涱亝鐎婚梺闈涚箞閸婃洜绮婚悽鍝ュ彄闁搞儯鍔忔竟姗€鏌ｅΔ浣圭殤缂佽鲸甯掕灃閻庯綆鍋勯锟�
    struct sockaddr_in serverAddr {}; // Server闂傚倷绶氬濠氭⒔閸曨偒鐔嗘俊顖欒閻掍粙鏌涢幇鍏哥敖缁炬儳銈搁弻鐔煎箚瑜滈崵鐔兼煃瑜滈崜锕傚垂闁秴绠柛娑樼摠閺呮悂鏌ㄩ悤鍌涘

    // 闂傚倷绀侀幉锛勬暜濡ゅ啰鐭欓柟瀵稿Х绾句粙鏌熺紒妯肩潉cket
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        zlog_error(zct, "Failed to create socket.");
        return 1;
    }

    // 闂備浇宕垫慨宕囩矆娴ｈ娅犲ù鐘差儐閸嬵亪鏌涘┑鍫濈€瑀ver闂傚倷绶氬濠氭⒔閸曨偒鐔嗘俊顖欒閻掍粙鏌涢幇銊︽珖闁崇懓绉归弻宥夊煛娴ｅ憡娈ㄧ紓浣瑰敾閹凤拷
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(18393); // TCP婵犳鍠楃敮妤冪矙閹烘挾浠氭俊鐐€栭幑浣哥暦閻㈤潧鍨濋柍鍝勬媼閺佸秵鎱ㄥ鍡楀缂佸顦靛娲川婵犲嫭鍣┑鐐存尭濠€閬嶅箯瑜版帗鏅搁柨鐕傛嫹80
    inet_pton(AF_INET, "192.168.1.147", &serverAddr.sin_addr);

    // 闂備礁鎼ˇ顐﹀疾濠靛纾婚柣鎰仛閺嗘粓鏌熺紒銏犳灈缂佲偓閸℃稒鐓熺憸搴ｆ绾炬潳er
    if (connect(sockfd, reinterpret_cast<struct sockaddr *>(&serverAddr), sizeof(serverAddr)) == -1) {
        zlog_error(zct, "Failed to connect to the server.");
        close(sockfd);
        return 1;
    }

    // 闂傚倷绀侀幉锟犳偡閿曞倸鍨傞柛褎顨呴悞鍨亜閹达絾纭舵い锔煎缁辨帡宕崟顐熸寖闂佸湱鎳撶€氫即骞栬ぐ鎺濇晝闁挎繂妫崯鈧梻鍌欒兌椤㈠﹪顢氶弽顓炵獥闁哄稁鍋€閸嬫挾鍠婃径瀣伓

    ssize_t bytesSent = send(sockfd, pSendData, strlen(pSendData), MSG_NOSIGNAL);
    if (bytesSent == -1) {
        zlog_error(zct, "Failed to send heartbeat packet.");
        close(sockfd);
        return 1;
    } else if (static_cast<size_t>(bytesSent) != strlen(pSendData)) {
        zlog_error(zct, "Partially sent heartbeat packet.");
        close(sockfd);
        return 1;
    }

    // 闂傚倷鑳舵灙缂佺粯鍨剁换娑欑節閸嬭姤绋撻崰濠囧煛閻滅€攅t闂備礁鎼ˇ顐﹀疾濠靛纾婚柣鎰仛閺嗘粓鏌ㄩ悤鍌涘
    close(sockfd);
    return 0;
}

// Ping闂傚倷绀侀幉锟犲垂閸忓吋鍙忛柕鍫濐槸濮规煡鏌ｉ弬鍨倯闁哄拋鍓熼幃妤呭捶椤撶偘姘eout婵犵數鍋為崹鍫曞箲閸モ晝纾芥慨妯夸含閻捇鏌熺紒銏犳灈缂侇偄绉归弻銈囩矙鐠恒劋绮靛銇礁娲﹂埛鎺楁煕鐏炲墽绠栫憸鎶婂懐纾奸弶鍫涘妿缁犵偟鈧娲╃换婵嗩嚕閺夋埈娼╅弶鍫氭暕閵忋倖鈷戦柛婵嗗椤忣偅淇婇銈庢敵,10000 濠电姵顔栭崳顖滅礊閸℃稑纾婚柛鈩冨喕缂嶆牠鏌ㄩ悤鍌涘=10 缂傚倸鍊风粈渚€篓閳ь剟鏌熼崙銈嗗
//闂傚倷鑳堕幊鎾绘偤閵娾晛绀夐柡鍥╁枑閸欏繑绻涢幋娆忕仾闁哄拋鍓氶幈銊ノ熼搹鐧哥礊缂備胶濮甸悡锟犲蓟濞戙垹唯妞ゆ牗绋戦锟�0闂傚倷鐒︾€笛呯矙閹达附鍤愭い鏍仜妗呴梺鐟邦嚟婵數鈧艾顭烽弻鏇熷緞濡櫣浠紓浣瑰姈椤ㄥ﹤顕ｉ崼鏇炵厸闁稿本绋撻崣鍡椻攽閻愰鍤嬮柟鍑ゆ嫹1闂傚倷鑳堕、濠囧箵椤忓牆绠柨鐕傛嫹-1
int Ping(const char *ips, int timeout) {
    struct timeval *tval;
    int maxfds = 0;
    fd_set readfds;

    int iRet = 0;
    struct sockaddr_in addr;
    struct sockaddr_in from;
    // 闂備浇宕垫慨鎶芥倿閿曞倸纾块柟鎯板Г閸嬧晝绱撳搴㈡婵犵數鍎戠徊钘壝洪悩璇茬婵犻潧娲ら閬嶆煥閻曞倹瀚�
    bzero(&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr(ips);

    int sockfd;
    // 闂傚倷绀侀幉锟犳偡閿曞倹鍋嬮柡鍥╁У椤愪粙鏌ｉ鍛傛溈ket  闂傚倷绶氬褍螞閹绢喖绠柨鐕傛嫹  婵犵數濮烽。浠嬪焵椤掆偓閸熷潡鍩€椤掆偓缂嶅﹪骞冨Ο璇茬窞濠电偟鍋撻悡銏ゆ⒑閻愯棄鍔氶柛鐔锋健閿濈偤路缁犲垼o 闂備礁鎼ˇ顐﹀疾濠婂牊鍋￠柍鍝勬噹闂傤垶姊洪崹顕呭剰妞ゆ洝椴搁幈銊ヮ潨閸℃绠归悶姘哺濮婄粯鎷呯粙璺ㄦ闂佺懓鍤栭幏锟�
    sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
    if (sockfd < 0) {
        zlog_error(zct, "ip:%s,socket error", ips);
        return -1;
    }

    struct timeval timeo;
    // 闂備浇宕垫慨鎶芥倿閿曞倸纾块柟鎯板Г閸嬧晝绱撳鍥骏meOut闂傚倷绀侀幖顐﹀疮椤愶附鍋夐柣鎾冲濞戙垺鏅搁柨鐕傛嫹
    timeo.tv_sec = timeout / 1000;
    timeo.tv_usec = timeout % 1000;

    if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo)) == -1) {
        zlog_error(zct, "ip:%s,setsockopt error", ips);
        close(sockfd);
        return -1;
    }

    char sendpacket[2048];
    char recvpacket[2048];
    // 闂備浇宕垫慨鎶芥倿閿曞倸纾块柟鎯板Г閸嬧晝绱撳鍥х毇ng闂傚倷绀侀幉锟犳偋椤撱垹绠柨鐕傛嫹
    memset(sendpacket, 0, sizeof(sendpacket));

    pid_t pid;
    // 闂傚倷绀侀幉锟犳偡閿曞倹鍋嬮柡鍥╁У椤愪粙鏌ｉ埡濠冿紬D闂傚倷鐒︾€笛呯矙閹寸偟闄勯柡鍐ㄥ€荤粈濠囨煛閸愶絽浜剧紓浣割儏椤﹀崬顕ｈ閵嗘帗鍒婂濠囨⒒娴ｅ湱婀介柛鏂跨焸瀹曠敻鎮悥宄秂nce ID
    pid = getpid();

    struct ip *iph;
    struct icmp *icmp;

    icmp = (struct icmp *)sendpacket;
    icmp->icmp_type = ICMP_ECHO; //闂傚倷鐒﹂幃鍫曞磿閹惰棄纾婚柣鎰棘閻旂ǹ绶為悘鐐村劤閻濅即姊绘担鍝ヤ虎妞ゆ垵娲ら敃銏ゆ晸閿燂拷
    icmp->icmp_code = 0;
    icmp->icmp_cksum = 0;
    icmp->icmp_seq = 0;
    icmp->icmp_id = pid;
    tval = (struct timeval *)icmp->icmp_data;
    gettimeofday(tval, NULL);
    icmp->icmp_cksum = cal_chksum((unsigned short *)icmp, sizeof(struct icmp)); //闂傚倷绀侀幖顐ょ矙閸曨厽宕叉繝闈涱儐閸嬫﹢鏌ㄩ悤鍌涘

    int n = sendto(sockfd, (char *)&sendpacket, sizeof(struct icmp), 0, (struct sockaddr *)&addr, sizeof(addr));
    if (n < 1) {
        zlog_error(zct, "ip:%s,sendto error", ips);
        close(sockfd);
        return -1;
    }

    // 闂傚倷娴囬～澶嬬娴犲纾块弶鍫亖娴滃綊鏌ㄩ悤鍌涘
    // 闂傚倷鐒﹂惇褰掑垂绾懌浜瑰璺虹焷婵櫕銇勯幒鎴濐仼闁活厽顨嗛妵鍕冀閵娧呯暤闂佸憡蓱閹告娊寮婚悢鐓庣畳闁圭儤鍨垫慨搴ㄦ偡濠婂嫭绶查柣妤佹尭閻ｅ嘲顫濈捄铏归獓闂佸壊鐓堥崰鏍椤撶喓绠鹃悗鐢登规牎濠电姭鍋撴い锝呯礆g闂傚倷鐒﹂惇褰掑礉瀹€鈧埀顒佸嚬閸撴盯鎳為柆宥嗗殤妞ゆ帒鍊块埞蹇涙⒑閸濆嫬鏆婇柛瀣尵缁辨帗寰勭仦钘夊箣濡ょ姷鍋樼欢姘躲€佸☉銏犖ч柛銉㈡櫓濡茬兘姊绘担鍛婅础妞わ絼绮欏畷鎴﹀箻鐡掍礁缍婇幃鈺咁敊閻撳骸袚缂傚倷鑳剁划顖炴偋閻樿钃熼悘鐐垫櫕閺嗗棝鏌涢幇顔间壕闁活厽顨婂娲倻閳轰椒澹曢梺鍛婃煥閻倿鐛崱妯肩瘈闁搞儯鍔屾禒銏ゆ⒑鐠恒劌娅愰柟鍑ゆ嫹
    int cnt = 0;
    while (1) {
        // 闂備浇宕垫慨鎶芥倿閿曞倸纾块柟鎯板Г閸嬧晝绱撳鍥骏meOut闂傚倷绀侀幖顐﹀疮椤愶附鍋夐柣鎾冲濞戙垹閿ゆ俊銈勭劍濞呮牠鎮楅崗澶婁壕闂佸憡鍔︽禍鐐侯敊閹邦兘鏀介柣鎰级椤ユ垿鏌涢幘瀵哥畺闁哄懎鐖奸幃鈺冩嫚閹绘帒鎸ゆ俊鐐€栭悧妤冨垝瀹ュ鏄ラ柛灞剧⊕閸欏繑绻濋崹顐ｅ暗缂佸鍓熼弻鐔兼儌閸濄儳蓱闂佺懓鍢查幊搴ㄣ偑娴兼潙宸濇い鏃囧Г椤撳綊姊绘担瑙勩仧闁绘挸顦甸獮蹇涙晸閿燂拷
        FD_ZERO(&readfds);
        FD_SET(sockfd, &readfds);
        maxfds = sockfd + 1;
        n = select(maxfds, &readfds, NULL, NULL, &timeo);
        if (n <= 0) {
            zlog_info(zct, "ip:%s,Time out error", ips);
            close(sockfd);
            iRet = -1;
            break;
        }

        // 闂傚倷娴囬～澶嬬娴犲纾块弶鍫亖娴滃綊鏌ㄩ悤鍌涘
        memset(recvpacket, 0, sizeof(recvpacket));
        int fromlen = sizeof(from);
        n = recvfrom(sockfd, recvpacket, sizeof(recvpacket), 0, (struct sockaddr *)&from, (socklen_t *)&fromlen);
        zlog_info(zct, "recvfrom Len:%d", n);
        if (n < 1) {
            close(sockfd);
            iRet = 1;
            break;
        }

        char *from_ip = (char *)inet_ntoa(from.sin_addr);
        // 闂傚倷绀侀幉锛勬暜閸ヮ剙纾归柡宥庡幖閽冪喖鏌涢妷顔煎闁告瑥锕ラ妵鍕冀閵娧屾殹闂佺ǹ楠搁敃顏堝蓟閿熺姴绀嬮梻鍫熺〒娴犳挳姊洪幖鐐测偓鏍垝瀹€鍕垫晩闊洦绋掗崕搴€亜閿曗偓缁辨闂傚倷鐒﹂惇褰掑礉瀹€鈧埀顒佸嚬閸撴瑧鍙呴梺鍝勭Р閸斿瞼娆㈤悙鐑樼叆闁绘洖鍊圭€氾拷
        if (strcmp(from_ip, ips) != 0) {
            zlog_info(zct, "NowPingip:%s Fromip:%s NowPingip is not same to Fromip,so ping wrong!", ips, from_ip);
            close(sockfd);
            iRet = 1;
            break;
        }

        iph = (struct ip *)recvpacket;
        icmp = (struct icmp *)(recvpacket + (iph->ip_hl << 2));

        zlog_info(zct, "ip:%s,icmp->icmp_type:%d,icmp->icmp_id:%d\n", ips, icmp->icmp_type, icmp->icmp_id);
        // 闂傚倷绀侀幉锛勬暜閸ヮ剙纾归柡宥庡幖閽冪喖鏌涢姀陇鎶梟g闂傚倷鐒﹂幃鍫曞磿閹惰棄纾绘繛鎴旀嚍閸ヮ剙钃熼柕澶堝劤椤﹂亶姊洪崨濠佺繁闁搞劑浜堕幃楣冩焼瀹ュ棛鍘藉┑鈽嗗灠閻忔繈鎮￠幇鐗堢厓鐟滄粓宕滈妸鈺佺闁跨噦鎷�
        if (icmp->icmp_type == ICMP_ECHOREPLY && icmp->icmp_id == pid) // ICMP_ECHOREPLY闂傚倷鐒﹂幃鍫曞磿閹惰棄纾婚柣鎰棘閻旂ǹ绶為悗锝庡亜閸斿懘姊洪崫鍕殭闁稿﹤顭烽獮妤呮晸閿燂拷
        {
            // 濠电姵顔栭崰妤冩崲閹邦喖绶ゅù鐘差儐閸嬪鏌涢幘鍙夘樂闁绘帒锕娲敆閳ь剛绮旈鈧畷鎴﹀箻鐠囪尙鍔﹀銈嗗笒鐎氼剛绮堥崟顖涚厱婵犻潧妫楅顏堟煕鎼淬垺绀嬮柡宀嬬到楗即骞囬鐑嗕紦
            zlog_info(zct, "icmp succecss .............  \n");
            break;
        } else if (cnt < 3) {
            // 闂傚倷绀侀幉锟犳偄椤掑倻涓嶉柟杈剧畱閸ㄥ倹銇勯弽銊х煂缁炬崘鍋愰幉姝岀疀濞戞瑥浠洪梺鐓庮潟閸婃銇欓幎鑺ョ叆闁绘洖鍊圭€氾拷
            cnt++;
            continue;
        } else {
            close(sockfd);
            iRet = -1;
            break;
        }
    }
    close(sockfd);
    return iRet;
}

int get_netlink_status(const char *if_name) {
    int skfd;
    struct ifreq ifr;
    struct ethtool_value edata;
    edata.cmd = ETHTOOL_GLINK;
    edata.data = 0;
    memset(&ifr, 0, sizeof(ifr));
    strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name) - 1);
    ifr.ifr_data = (char *)&edata;
    if ((skfd = socket(AF_INET, SOCK_DGRAM, 0)) == 0) return -1;
    if (ioctl(skfd, SIOCETHTOOL, &ifr) == -1) {
        zlog_error(zct, "ioctl failed, if_name:%s", if_name);
        close(skfd);
        return -1;
    }
    close(skfd);
    return edata.data;
}

// 闂備浇顕х换鎰崲閹邦儵娑樷槈濞嗘劖鐝峰┑掳鍊曢幊搴ｂ偓姘槹閵囧嫰骞掗崱妞惧闁荤喐绮嶆刊钘夆枖閺囥垹鐒垫い鎺嶈兌閳洘銇勯妸銉уⅵ妞ゃ垺鐗楅幏鍛村捶椤撴稒鐏冮梻浣告啞閻熴儵藝椤栫儐鏁侀柡鍥ュ灪閻撴洟鏌熼悜妯虹仸妞ゃ儲鐟╅幃褰掑箛椤斿吋鐏堥悗娈垮櫘閸嬪棝鍩€椤掍胶鈯曢拑杈ㄧ箾閸繂顣崇紒杈ㄦ尰閹峰懐绮欏▎鍙ョ棯闂備焦鎮堕崝宥呯暆閹间礁绠氶柛鎰靛枛缁€瀣亜閹板墎鍒伴柍褜鍓欓…宄邦潖閾忚瀚氱憸搴ｂ偓姘炬嫹
std::vector<int> splitVersion(const std::string &version) {
    std::vector<int> parts;
    std::stringstream ss(version);
    std::string part;

    // 闂傚倷鑳堕崕鐢稿磻閹捐绀夐幖娣妼绾惧鏌ㄥ┑鍡橆棡濠殿垰鐡ㄧ换婵囩箾閹傚闂佽崵濮甸崝妤呭窗閺嵮呮殾婵ǹ娉涢獮銏＄箾閹寸偟鎳愰柛姘焽缁辨挻鎷呯拠鈩冾吅闁荤姳绶ょ徊鍨ｉ幇顑芥斀閻庯綆浜為ˇ顐︽⒑缁洖澧叉い銊ユ嚇钘熼煫鍥ㄧ⊕閻撶喐淇婇妶鍌氫壕闂佺粯顨呴敃銈夋晝閵忊€愁嚤闁哄鍨归悡鎴︽⒑鐠恒劌娅愰柟鍑ゆ嫹
    while (std::getline(ss, part, '.')) {
        parts.push_back(std::stoi(part)); // 闂備浇顕х换鎰崲閹邦儵娑樜旈崨顓炵€柟鍏肩暘閸斿瞼绮堥崼銉︾厵缂備焦锚缁楁岸鏌涙繝鍕毈闁哄矉缍佹俊鎼佸Ψ閵夘喕绱旈梻浣呵圭€涒晠骞愰崘鑼殾婵ǹ娉涢獮銏℃叏濮楀棗骞橀柕鍫櫍濮婅櫣娑甸崪浣告異濠电姭鎳囬崑鎾绘煟閻樺啿濮夐柛鐘崇墪椤曪綁顢曢妶鍌氫壕婵炴垶顏伴幋婵冩灁闁跨噦鎷�
    }

    return parts;
}

// 濠电姵顔栭崳顖滃緤閹灛娑欐媴閻戞﹩鍋ㄥ┑鐘绘涧濞层劑鍩㈤弮鍫熺厪闁割偅绻傞顓㈡煕閵堝拋鍎旈柡宀嬬到铻栭柍褜鍓熼幃褎绻濋崒锕佲偓鍨归崗鍏肩稇闁活厽顨婇弻銊╂偆閸屾稑顏�
int compareVersions(const std::string &version1, const std::string &version2) {
    std::vector<int> v1 = splitVersion(version1);
    std::vector<int> v2 = splitVersion(version2);

    // 闂傚倷鑳堕幊鎾绘倶濮樿泛纾块柟鎯版閺勩儳鈧厜鍋撻柛鏇ㄥ亜閻濇﹢姊洪柅鐐茶嫰婢у瓨鎱ㄦ繝鍌涜础闁圭懓瀚版俊鎼佹晜閻愵剚顔忛梻鍌欒兌缁垶銆冮崨瀛樺亱濠电姴鍋婇懓鍨归崗鍏肩稇闁活厽顨婇弻锝夊箣閿濆棭妫勯梺鍛婃煟閸庣敻寮诲☉銏犵闁瑰鍎愬Λ锕傛⒑閸濆嫭顥″瀛樻倐楠炲棝寮崼鐔告闂佽法鍣﹂幏锟�
    size_t maxLength = std::max(v1.size(), v2.size());

    for (size_t i = 0; i < maxLength; ++i) {
        int num1 = i < v1.size() ? v1[i] : 0; // 婵犵數濮烽。浠嬪焵椤掆偓閸熷潡鍩€椤掆偓缂嶅﹪骞冨Ο璇茬窞闁归偊鍓濋幗鏇㈡⒑閸︻厼顣兼繝銏★耿瀹曟繈濡烽埡鍌滃幈闂佸湱鍎ら崹鍫曀夊▎鎴犵＜婵°倐鍋撴い锕備憾閸┾偓妞ゆ帊鑳堕埊鏇㈡煥濮橆厾绡€闁逞屽墴椤㈡棃宕奸悢鍛婄彨闁诲骸鍘滈崑鎾绘煕閹邦喖浜剧紓宥咃攻缁绘盯骞嬮悙瀛樺創闂佺懓鍤栭幏锟�0
        int num2 = i < v2.size() ? v2[i] : 0;

        if (num1 > num2) return 1;  // version1 婵犵數濮伴崹褰掓偉閵忋倕纾兼繝濠傛椤ワ拷 version2
        if (num1 < num2) return -1; // version1 闂備浇顕х换鎰崲閹邦喗宕查悗锝庡墲婵娊鏌ㄩ悤鍌涘 version2
    }

    return 0; // 闂傚倷鑳剁划顖炪€冮崨瀛樺亱濠电姴鍋婇懓鍨归崗鍏肩稇闁活厽顨呴—鍐偓锝庝簻椤掋垻绱掓担鍦弨闁哄本绋戦～婵嬫倷椤掆偓椤忥拷
}

void Binary_Bit(unsigned char *p_data, unsigned char position, int flag) {
    //婵犵數鍋涢悺銊у垝瀹€鍕剹濞达絿鍎ゅ畷鍙夋叏濡炶浜鹃悗瑙勬礃瀹€鎼佸箠濠婂牊鍋ㄩ梻鍫熺☉缁傚繐鈹戦悙鑸靛涧缂佽尙鏅划鏃堝醇閺囩喎浠鹃梺绯曞墲缁嬫帡鍩涢弽顓熺厾闁归棿鐒﹀☉褔鏌ｈ箛鏃戞疁闁哄被鍊濆鍫曞箰鎼粹剝顏熺紓鍌欑劍濡垿骞忛敓锟� position婵犵數鍋為崹鍫曞箲娴ｅ壊娴栭柕濞у懐顦梺鍛婄⊕濞兼瑩寮告笟鈧弻銊╂偆閸屾稑顏�(婵犵數鍋涢顓熷垔閹绢喖绠柨鐕傛嫹0 闂佽瀛╅鏍窗閹烘纾婚柟鐐灱閺€鑺ャ亜閺囩偞顥為悗姘炬嫹)
    if (flag) {
        *p_data |= 0x01 << (position);
    } else {
        *p_data &= ~(0x01 << (position));
    }
}