wirelessgateway/common/SH_CommonFunc.cpp

#include <time.h>
#include <sys/time.h>
#include "SH_global.h"
#include "SH_CommonFunc.hpp"
#include <boost/xpressive/xpressive_dynamic.hpp>
#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 <linux/rtc.h>
#include "../dbaccess/SH_SqlDB.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;
Mutex g_tDbMutex;
string GetLocalTimeWithMs(void)
{
    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(const std::exception& e)
    {
        return defaultTime;
    }
    catch (...)
    {
        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)
        return -1;

    memset(outbuf, 0, outlen);

    if ((int)iconv(cd, pin, &inlen, pout, &outlen) == -1)
    {
        iconv_close(cd);
        return -1;
    }
    iconv_close(cd);
    *pout = '\0';

    return 0;
}

int u2g(char *inbuf, size_t inlen, char *outbuf, size_t outlen) {
    return code_convert("utf-8", "gb2312", inbuf, inlen, outbuf, outlen);
}

int g2u(char *inbuf, size_t inlen, char *outbuf, size_t outlen) {
    return code_convert("gb2312", "utf-8", inbuf, inlen, outbuf, outlen);
}

std::string GBKToUTF8(const std::string& strGBK)
{
    int length = strGBK.size()*2+1;

    char *temp = (char*)malloc(sizeof(char)*length);

    if(g2u((char*)strGBK.c_str(),strGBK.size(),temp,length) >= 0)
    {
        std::string str_result;
        str_result.append(temp);
        free(temp);
        return str_result;
    }else
    {
        free(temp);
        return "";
    }
}

std::string UTFtoGBK(const char* utf8)
{
    int length = strlen(utf8);

    char *temp = (char*)malloc(sizeof(char)*length);

    if(u2g((char*)utf8,length,temp,length) >= 0)
    {
        std::string str_result;
        str_result.append(temp);
        free(temp);

        return str_result;
    }else
    {
        free(temp);
        return "";
    }
}
std::string convertEncoding(const std::string& input, const char* fromEncoding, const char* toEncoding) {
    iconv_t conv = iconv_open(toEncoding, fromEncoding);
    if (conv == (iconv_t)-1) {
        throw std::runtime_error("iconv_open failed");
    }

    size_t inBytesLeft = input.size();
    size_t outBytesLeft = inBytesLeft * 2; // GBK may require up to twice the space of UTF-8
    char* inBuf = const_cast<char*>(input.c_str());
    char* outBuf = new char[outBytesLeft];
    char* outPtr = outBuf;

    if (iconv(conv, &inBuf, &inBytesLeft, &outPtr, &outBytesLeft) == (size_t)-1) {
        delete[] outBuf;
        iconv_close(conv);
        throw std::runtime_error("iconv failed");
    }

    std::string result(outBuf, outPtr);
    delete[] outBuf;
    iconv_close(conv);
    return result;
}

void InitGpio(unsigned int gpioN,unsigned int inout)
{
	int fd = 0;
	char tmp[100] = {0};
	//打开gpio设备文件
	fd = open("/sys/class/gpio/export", O_WRONLY);
	if(-1 == fd)
	{
	    printf("[%s]:[%d] open gpio export file error\r\n", __FUNCTION__, __LINE__);
	}
	//申请gpio
	sprintf(tmp,"%d",gpioN);
	if(write(fd, tmp, strlen(tmp)) < 0)
	{
	    printf("write file operation error %s\r\n",tmp);

	}
	close(fd);
	sleep(1);
	//配置gpio方向
#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);
#else if IMX6UL_GATEWAY
	sprintf(tmp,"/sys/class/gpio/gpio%d/direction",gpioN);
#endif

	print_info("open GPIO = %s\n",tmp);
	fd = open(tmp, O_WRONLY);
	if(-1 == fd)
	{
	    printf("[%s]:[%d] open gpio direction file error\r\n", __FUNCTION__, __LINE__);
        close(fd);
	}

	if(inout == 0)
	{
		print_info("=====InitGpio=====in\n");
		if(-1 == write(fd, "in", sizeof("in")))
		{
			print_info("[%s]:[%d] [%d]write operation direction error\r\n", __FUNCTION__, __LINE__,gpioN);
		   close(fd);
		}
	}
	else if( inout == 1)
	{
		print_info("=====InitGpio=====out\n");
		if(-1 == write(fd, "out", sizeof("out")))
		{
			print_info("[%s]:[%d] [%d]write operation direction error\r\n", __FUNCTION__, __LINE__,gpioN);
			close(fd);
		}
	}
	close(fd);
//	printf("gpio%d init %d\r\n",gpioN,inout);
}
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);
#else if IMX6UL_GATEWAY
	sprintf(tmp,"/sys/class/gpio/gpio%d/value",gpioN);
#endif
//	printf("%s\r\n",tmp);
	//print_info("set GPIO = %s\n",tmp);
	//打开gpio value文件
	fd = open(tmp, O_WRONLY);
	if(-1 == fd)
    {
		print_red("[%s]:[%d][%s] open gpio export file error\r\n", __FUNCTION__, __LINE__,tmp);
        close(fd);
       return (-1);//exit(1);
	}
	//设置电平
	if(x)
	{
		if(-1 == write(fd, "1", sizeof("1")))
		{
			print_red("[%s]:[%d] %d write operation value error\r\n", __FUNCTION__, __LINE__,gpioN);
		   close(fd);
		   return (-1);//exit(1);
		}
	}
	else
	{
		if(-1 == write(fd, "0", sizeof("0")))
		{
			print_red("[%s]:[%d] %d write operation value error\r\n", __FUNCTION__, __LINE__,gpioN);
		   close(fd);
		   return (-1);//exit(1);
		}
	}
//	printf("gpio%d set %d ok\r\n",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);
#else if IMX6UL_GATEWAY
	sprintf(tmp,"/sys/class/gpio/gpio%d/value",gpioN);
#endif
	//打开gpio value文件
	fd = open(tmp, O_RDONLY);
	if(-1 == fd)
    {
		print_red("[%s]:[%d] %d open gpio export file error\r\n", __FUNCTION__, __LINE__,gpioN);
       return (-1);//exit(1);
	}
	//读取 value文件
	if(-1 == read(fd, &value, sizeof(value)))
    {
		print_red("[%s]:[%d] %d read gpiovalue is fail\r\n", __FUNCTION__, __LINE__,gpioN);
        close(fd);
        return (-1);//exit(1);
    }
	 close(fd);
	//printf("gpio%d get %d\r\n",gpioN,value);
	return value;
}

int CheckFileVersion(int argc, char** argv)
{
    std::string strVersion = GlobalConfig::Version;
    int optionchar;             /*选项字<E9A1B9>??*/
    if (argc >= 2) {
        if (strcmp(argv[1], "--debugmode") == 0){
            GlobalConfig::RUN_MODE = 1;
            return 0;
        }
        optionchar = getopt(argc, argv, "vVhH?");
        switch (optionchar) {
        case 'v':
        case 'V':
            GlobalConfig::RUN_MODE = 1;
            print_debug("Compile time:%s %s\n", __DATE__, __TIME__);
            print_debug("The internal version is:%s.\n", strVersion.c_str());
            break;
        case 'h':
        case 'H':
        case '?':
            printf("Please input -v or -V to get the file version.\n");
            break;
        default:
            break;
        }
        return 1;
    }
    return 0;
}
int config_uart(const char* Port,speed_t speed)
{
	int iFd  = open(Port,O_RDWR | O_NOCTTY);
	if(iFd < 0) {
	     return -1;
	}
    struct termios opt;
    tcgetattr(iFd, &opt);
    cfsetispeed(&opt, speed);
    cfsetospeed(&opt, speed);
    if (tcgetattr(iFd, &opt)<0) {
            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) {
        return -1;
    }
    tcflush(iFd,TCIOFLUSH);

	return iFd;
}

int write_data(int fd, char *buff, int len)
{
    int ret;
	char buf[100];
	ret = write(fd, buff, len);
    if (ret < 0) {
        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) {
	//			printf("zigbee doesn't respond!\n");
				return ret;
			}
		}
	 	// if (ioctl(fd, FIONREAD, &len) == -1) {
        // 	return -1;
    	// }

		ret = read(fd,buff,len);
		if(ret < 0) {
			perror("read_data");
			return -1;
		}
		buff[ret] = '\0';
		return ret;
}
int ModifyMac(char* buff)
{
	FILE *fp = fopen("/opt/system/mac", "w");
	fprintf(fp, buff);
	fprintf(fp, "\n");
	fclose(fp);
	system("cp /opt/system/mac /opt/system/macbak");
	system("/opt/Cidn/init.sh");
}
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;int hour = 0;
    iyear = tm_info->tm_year + 1900;
    imonth = tm_info->tm_mon + 1;
    day = tm_info->tm_mday;
    hour = tm_info->tm_hour;
    print_info("year = %d,month = %d,day = %d\n",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) {
        return -1;    
    }

    if ((fp = popen(cmd, "r") ) == NULL) {
        print_error("popen error\n");
        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);
    }

}
// 获取RTC时间
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) {
        perror("open /dev/rtc0");
    } else {
        struct rtc_time rtc_tm;
        if (ioctl(fd, RTC_RD_TIME, &rtc_tm) < 0) {
            perror("ioctl RTC_RD_TIME");
        } else {
	    	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);

			// 将rtc_time结构体转换为time_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) {
				perror("mktime");
			}
			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)) {
    	print_info("root = %d\n",root.size());
    	for(int i = 0; i < root.size();i++){
    		hwVersion = root[i]["hw_vesion"];
    		for(int i = 0; i < hwVersion.size();i++){
    			datanodeUpdate.hwVersion.push_back(hwVersion[i].asString());
    		}
    		datanodeUpdate.strUpdataFileName = root[i]["fw_name"].asString();
    		datanodeUpdate.strSoftVersion = root[i]["sf_vesion"].asString();
    		print_info("strUpdataFileName = %s,strSoftVersion = %s\n",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);
	string zigbeeChannel;
	if (reader.parse(is, root)) {
		gateWay = root["gateWay"];
		dataNode = root["dataNodeArray"];
		print_info("dataNode = %d\n",dataNode.size());
		for(int i = 0; i < dataNode.size();i++){
		    string softVersion = dataNode[i]["softVersion"].asString();
		    string bpNo = dataNode[i]["bpNo"].asString();
		    print_info("bpNo = %s\n",bpNo.c_str());
		    string wakeupTime = dataNode[i]["wakeupTime"].asString();
		    int viff = dataNode[i]["viff"].asInt();
		    string StaticTime = dataNode[i]["StaticTime"].asString();
		    int configFlag = dataNode[i]["configFlag"].asInt();
		    int rangeValue = dataNode[i]["range"].asInt();
		    int updateValue = dataNode[i]["update"].asInt();
		    string zigbeeLongAddr = dataNode[i]["zigbeeLongAddr"].asString();
		    int accFlag = dataNode[i]["accFlag"].asInt();
		    print_info("accFlag = %d\n",accFlag);
		    int temTopFlag = dataNode[i]["temTopFlag"].asInt();
		    string startBrands = dataNode[i]["startBrands"].asString();
		    int waveInterVal = dataNode[i]["waveInterVal"].asInt();
		    string zigbeePanId = dataNode[i]["zigbeePanId"].asString();
		    int waveTime = dataNode[i]["waveTime"].asInt();
		    int zigbeePower = dataNode[i]["zigbeePower"].asInt();
		    int zigbeeRetry = dataNode[i]["zigbeeRetry"].asInt();
		    string stopBrands = dataNode[i]["stopBrands"].asString();
		    int featureInterVal = dataNode[i]["featureInterVal"].asInt();
		    int zigbeeFlag = dataNode[i]["zigbeeFlag"].asInt();
		    string zigbeeDesAddr = dataNode[i]["zigbeeDesAddr"].asString();
		    print_info("zigbeeDesAddr = %s\n",zigbeeDesAddr.c_str());
		    int ZigbeeRetryGap = dataNode[i]["zigbeeRetryGap"].asInt();
		    string dataNodeNo = dataNode[i]["dataNodeNo"].asString();
		    int initFlag = dataNode[i]["initFlag"].asInt();
		    string faultFrequency = dataNode[i]["faultFrequency"].asString();
		    int temBotFlag = dataNode[i]["temBotFlag"].asInt();
		    string bateryV = dataNode[i]["bateryV"].asString();
		    int ACCSampleTime = dataNode[i]["ACCSampleTime"].asInt();
		    print_info("ACCSampleTime = %d\n",ACCSampleTime);
		    string firstPowerTime = dataNode[i]["firstPowerTime"].asString();
		    string serialNo = dataNode[i]["serialNo"].asString();
		    string zigbeeAddr = dataNode[i]["zigbeeAddr"].asString();
		    string productNo = dataNode[i]["productNo"].asString();
		    string timeStamp = dataNode[i]["timeStamp"].asString();
		    zigbeeChannel = dataNode[i]["zigbeeChannel"].asString();
		    int RSSI = dataNode[i]["RSSI"].asInt();
		    print_info("RSSI = %d\n",RSSI);
		    string hardVersion = dataNode[i]["hardVersion"].asString();
		    string envelopeBandPass = dataNode[i]["envelopeBandPass"].asString();
		    int samplingRate = dataNode[i]["samplingRate"].asInt();
		    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 = sql_ctl->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);
		        sql_ctl->InsertData(T_SENSOR_INFO(TNAME), insertSql);
		}

		/*WriteStr2Config(SERVERCONFIG, "Server", "localServerIpAddress", gateWay["Server"]["localServerIpAddress"].asString());
		WriteStr2Config(SERVERCONFIG, "Server", "localServerPort", gateWay["Server"]["localServerPort"].asString());
		WriteStr2Config(SERVERCONFIG, "Server", "CommMode", gateWay["Server"]["CommMode"].asString());
		WriteStr2Config(SERVERCONFIG, "Server", "UserName", gateWay["Server"]["UserName"].asString());
		WriteStr2Config(SERVERCONFIG, "Server", "Password", gateWay["Server"]["Password"].asString());

		WriteStr2Config(NETWORKCONFIG, "Net", "dnsName", gateWay["Net"]["dnsName"].asString());
		WriteStr2Config(NETWORKCONFIG, "Net", "networkPortStatus", gateWay["Net"]["networkPortStatus"].asString());
		WriteStr2Config(NETWORKCONFIG, "Net", "gateway", gateWay["Net"]["gateway"].asString());
		WriteStr2Config(NETWORKCONFIG, "Net", "subnetMask", gateWay["Net"]["subnetMask"].asString());
		WriteStr2Config(NETWORKCONFIG, "Net", "ipAddress", gateWay["Net"]["ipAddress"].asString());
		WriteStr2Config(NETWORKCONFIG, "Net", "hostName", gateWay["Net"]["hostName"].asString());

		WriteStr2Config(ZIGBEECONFIG, "Zigbee", "channel", zigbeeChannel);*/
	}else{
		print_info("parse error\n");
	}
	is.close();
}
void ImportConfig(std::string filename)
{
    Json::Value root,gateWay,dataNode;
	std::fstream is;
	Json::Reader reader;
	is.open(filename.c_str(), std::ios::in);
	string zigbeeChannel;
    
    Json::Value jsSystemSetting,jsonValnet,jsonValnet1,jsSystemInfo,jsonValZigbee,jsondataNodeArray; 
	if (reader.parse(is, root)) {
        jsSystemInfo = root["SystemInfo"];
        jsonValZigbee = root["zigbee"];
        jsonValnet1 = root["eth1"];
        jsonValnet = root["eth0"];
        jsSystemSetting = root["ServerConfig"];
        jsondataNodeArray = root["dataNodeArray"];
        char insertSql[1024] = { 0 };
        for(int i = 0; i < jsondataNodeArray.size();i++){
            Json::Value valNode = jsondataNodeArray[i];
            vector<string> vecDataNode;
            for (size_t j = 0; j < valNode.size(); j++)
            {
                vecDataNode.push_back(string(valNode[j].asString()));
            }
            char dataNodeName[100]={0x00};
			hexToAscii(vecDataNode[1].c_str(),dataNodeName);
            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());
		        sql_ctl->InsertData(T_SENSOR_INFO(TNAME), insertSql);
        }

        WriteStr2Config(SERVERCONFIG, "Server", "localServerIpAddress", jsSystemSetting["ServerIpAddress"].asString()); 
        WriteStr2Config(SERVERCONFIG, "Server", "localServerPort", jsSystemSetting["ServerPort"].asString()); 
        WriteStr2Config(SERVERCONFIG, "Server", "CommMode", /*param.mCommMode*/"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};
        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());

    }
    //system("reboot");
}
int UpdataDataNodeConfig(std::string filename)
{
	vector<DataNodeInfo> vecDataNode; //声明一个字符串向量
	//以读入方式打开文件
	ifstream csv_data(filename, ios::in);
	int iRet = 0;
	if (!csv_data.is_open())
	{
		cout << "Error: opening file fail" << endl;
		return  -1;
	}
	else {
		string line;

		vector<string> words; //声明一个字符串向量
		string word;

		DataNodeInfo dataNode;
		// ------------读取数据-----------------
		// 读取标题行
		getline(csv_data, line);


		istringstream sin;
		// 按行读取数据
		while (getline(csv_data, line))
		{
			words.clear();
			sin.clear();
			sin.str(line);
			while (getline(sin, word, ','))
			{
				cout << word << endl;
				words.push_back(word);

			}
			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());
			print_info("words[17] = %s\n",words[19].c_str());

			if(words[19].find("8g") != string::npos){
				dataNode.Range = 0;
			}else if(words[19].find("16g") != string::npos){
				dataNode.Range = 1;
			}else if(words[19].find("32g") != string::npos){
				dataNode.Range = 2;
			}else if(words[19].find("64g") != string::npos){
				dataNode.Range = 3;
			}else if(words[19].find("50g") != 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();
	}

	char whereCon[1024] = {0};
	char updateSql[1024] = { 0 };
	if(vecDataNode.size() > 0){
		for(int 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());

			int iRet = sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
			memset(whereCon,0x00,sizeof(whereCon));
			memset(updateSql,0x00,sizeof(updateSql));
		}
		iRet = vecDataNode.size() ;
	}else{
		iRet = -3;
	}
	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 (reader.parse(is, root)) {
        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) {  
        perror("create socket falise...mac/n");  
        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) {  
        printf("mac ioctl error/n");  
        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]);
    printf("local mac:%s /n",mac_addr);      
    close( sock_mac );  
    LOG_INFO("net : %s,mac:%s\n",net,mac_addr);
    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))) {
        perror_info("socket");
        return "";
    }
    struct ifreq req;
    struct sockaddr_in *host;

    bzero(&req, sizeof(struct ifreq));
    strcpy(req.ifr_name, eth_name);
    //print_info("eth_name = %s\n",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) {
    	return strip;
    }
    strip = GetGwIp_(WLAN2);
    if (strip.compare("0.0.0.0") != 0) {
        return strip;
    }
    strip = GetGwIp_(ETH1);
	if (strip.compare("0.0.0.0") != 0 && strip.compare("192.168.188.188") != 0) {
		return strip;
	}
	strip = GetGwIp_(ETH2);
	if (strip.compare("0.0.0.0") != 0 && strip.compare("192.168.188.188") != 0) {
		return strip;
	}
    strip = GetGwIp_(ETH0);
    if (strip.compare("0.0.0.0") != 0) {
    	return strip;
    }
    strip = GetGwIp_(USB0);
    if (strip.compare("0.0.0.0") != 0) {
    	return strip;
    }
    strip = GetGwIp_(WWAN0);
	if (strip.compare("0.0.0.0") != 0) {
		return strip;
	}
    //return strip;
}

std::string GetWorkNic()
{
    const char *WLAN0 = "wlan0";
    const char *ETH0 = "eth0";
    std::string strip;
    strip = GetGwIp_(WLAN0);
    if (strip.compare("0.0.0.0") != 0) {
        return std::string(WLAN0);
    }
    strip = GetGwIp_(ETH0);
    if (strip.compare("0.0.0.0") != 0) {
        return std::string(ETH0);
    }
    return std::string(ETH0);
}

std::string& ClearAllSpace(std::string &str)
{
    int index = 0;
    if( !str.empty()) {
        while( (index = str.find(' ',index)) != 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 ", to_string(c).substr(0,4).c_str(), CpuSys.c_str(), CpuUse.c_str(), Emmcinfo.c_str());
    return std::string(sysinfo);
}

void StartWriteToDat()
{
    print_info("start writetoDat\n");
}


float * ReSample(int WaveDataLength, int N, int *NewWaveDataLength, std::vector<float> & WaveData)
{
    if (N <= 0)
        return NULL;
    int NewLength = (int)WaveDataLength / N;
    float * _OutputData = new float[NewLength];
    for(int i = 0; i < NewLength; i++) {
        _OutputData[i] = WaveData[i * N];
    }
    *NewWaveDataLength = NewLength;
    return _OutputData;
}


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 RemoveConfig()
{
    char cmd[32] = { 0 };
    sprintf(cmd, "rm /CIDW/config/*");
    system(cmd);
    exit(0); 
}

extern 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 (int i = 0;i < sizeof(zonelists);i++)
    {
        if (zoneid.compare(zonelists[i]) == 0) {
            a = i;
            cout << "a = " << a << endl;
            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 };
    // sprintf(cmd, "rm /etc/localtime");
    // system(cmd);
    memset(cmd, 0, 256);
    sprintf(cmd, "sudo ln -sf /usr/share/zoneinfo/Etc/%s  /etc/localtime", zoneid.c_str());
    system(cmd);
    print_info("change timezone success!\n");
}

std::string GetFileContent(std::string filename, int line)
{
    std::string strFileContent("");
    std::ifstream ifileOut(filename.c_str());
    if(ifileOut.is_open()) { //文件打开
        int i = 1;
        while (!ifileOut.eof()) {
            if (line == 0) {
                std::string strTemp("");
                getline(ifileOut, strTemp);
                strFileContent += strTemp;
                strFileContent += "\r\n";
            } 
            if (line != 0) {
                std::string strTemp("");
                getline(ifileOut, strTemp);
                if (line == i) {
                    strFileContent = strTemp;
                    break;
                }
            }
            ++i;
        }
        ifileOut.close();
    }
    return strFileContent;
}


//BOOST用正则表达式验证ip地址合法
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;

    // 将IP地址由“点分十进制”转换成 “二进制整数”
    struct in_addr s;
    iRet = inet_pton(AF_INET, mask.c_str(), &s);

    // 转换成功返回1，说明是有效的IP地址
     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;
}
// int StatusPub()
// {
//     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;

//     float fCpuRate;
//     char name[8]; 
//     double cpu_idle = -1;
//     double cpu_sys = -1;
//     double cpu_user = -1;
//     double cpu_total = -1;
//     double cpu_wait = -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%d",name,&user,&nice,&sys,&idle,&iowait,&irq,&softirq);
//     boost::this_thread::sleep(boost::posix_time::seconds(2));
//     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%d",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;
//     cpu_wait = iowaitNext - iowait;
//     cpu_idle = idleNext - idle;  
//     fCpuRate = 1.0*(cpu_total - cpu_idle) / cpu_total;
//     float rateUser = cpu_user *100.0/cpu_total;
//     float rateSys = cpu_sys * 100.0/cpu_total;

//     if (rateUser > 95) {
//         rateUser = 92;
//     }

//     /*获取温度 */
//     std::string tempRaw = GetFileContent(TEMPER_RAW, 1);
//     std::string temperOffset = GetFileContent(TEMPER_OFFSET, 1);
//     std::string temperScale = GetFileContent(TEMPER_SCALE, 1);
//     float temperature = ((boost::lexical_cast<float>(tempRaw) + boost::lexical_cast<float>(temperOffset)) * boost::lexical_cast<float>(temperScale))/1000;

//     char hardName[32];
//     char hardTotal[32];
//     char hardUse[32];
//     char hardFree[32];
//     char rateHardUse[32]; 
//     const char * getEmmcInfo = "df -h | grep /dev/root";
//     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);

//     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));
//     jsData["hardDiskFree"] = atof(strhardFree.substr(0,strhardFree.length() - 1));
    
//     double total = atof(strhardTotal.substr(0,strhardTotal.length() - 1));
//     double free = atof(strhardFree.substr(0,strhardFree.length() - 1));
//     double use = ((total - free) / free) * 100;
//    // jsData["hardDiskUse"] = atof(strrateHardUse.substr(0,strrateHardUse.length() - 1));
//     jsData["hardDiskUse"] = use;
//     jsData["cpuSystemUse"] = rateSys;
//     jsData["temperature"] = temperature;

//     char localtimestamp[32] = { 0 };
//     GetTimeNet(localtimestamp, 1);
//     std::string nowTimetamp = std::string(localtimestamp);	
//     jsData["updateTime"] = nowTimetamp;
//     std::string strJson = fw.write(jsData);
//     data_publish(strJson.c_str(), GlobalConfig::Topic_G.mPubStatus.c_str());

//     std::string strInfo = "mem:"+boost::lexical_cast<std::string>(fMemRate * 100) + "tem:"+boost::lexical_cast<std::string>(temperature);


//     return 0;
// }

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)
{
    FILE *fp = NULL;
    int value = 0;
    if(key == NULL)return 0;

    fp = fopen(key, "r");
    if (fp == NULL) {
        printf("Error: could not open %s file\n",key);
        return 1;
    }

    fscanf(fp, "%d", &value);
    fclose(fp);fp = NULL;
    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;

    float fCpuRate;
    char name[8]; 
    double cpu_idle = -1;
    double cpu_sys = -1;
    double cpu_user = -1;
    double cpu_total = -1;
    double cpu_wait = -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%d",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%d",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;
    cpu_wait = iowaitNext - iowait;
    cpu_idle = idleNext - idle;  
    fCpuRate = 1.0*(cpu_total - cpu_idle) / cpu_total;
    float rateUser = cpu_user *100.0/cpu_total;
    float rateSys = cpu_sys * 100.0/cpu_total;
    if (rateUser > 95) {
        rateUser = 92;
    }

    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);
#ifdef IMX6UL_GATEWAY
    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);

    print_info("rateUser = %f,mem_total = %d,mem_free = %d,fMemRate = %f\n",rateUser,mem_total,mem_free,fMemRate);
    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());
    
    double total = atof(strhardTotal.substr(0,strhardTotal.length() - 1).c_str());
    double free = atof(strhardFree.substr(0,strhardFree.length() - 1).c_str());
    double use = ((total - free) / total) * 100;
   // jsData["hardDiskUse"] = atof(strrateHardUse.substr(0,strrateHardUse.length() - 1));
    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) {
        return -1; // Hex字符串长度应该是偶数
    }
    if (bytesSize < hexLen / 2) {
        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);
        // 将整数转换为对应的ASCII字符
        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;
}
string tohex(const string& str)
{
    string ret;
    static const char *hex="0123456789ABCDEF";
    for(int i=0;i!=str.size();++i)
    {
        ret.push_back(hex[(str[i]>>4)&0xf]);
        ret.push_back( hex[str[i]&0xf]);
    }
    return ret;
}
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))){
		print_info("Failed:Open /dev/watchdog");
	}
	return fd;

}
int WriteWatchDog(int fd)
{
	if(1 != write(fd,"0",1)){
		print_info("Failed:feeding watchdog");
	}
}
int CloseWatchDog(int fd)
{
	close(fd);
}
string TrimStringLeft(const char* szData, const char* szTargets)
{
	string strData = szData;
	int nPos = 0;
	nPos = strData.find(szTargets);
	while (nPos == 0)
	{
		strData.erase(nPos, 1);
		nPos = strData.find(szTargets);
	}
	return strData;
}

string TrimStringRight(const char* szData, const char* szTargets)
{
	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;
}
string GetOneContent(const char* szData, int nRow, const char* szSeparate)
{
	string strParam = "";
	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)
{
	struct termios newtio,oldtio;
	if  ( tcgetattr( fd,&oldtio)  !=  0) {  //检测串口是否可用
		perror("SetupSerial 1");
		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;
	}

	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;
	}

	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);
			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) //设置串口参数
	{
		perror("com set error");
		return -1;
	}
	return 0;
}

int getcsq()
{
	/*int fd = config_uart("/dev/ttyUSB2",115200);
		print_info("fd = %d\n",fd);
		if(fd < 0){
			printf("config_uart error\n");
	}
	int len = write_data(fd,"AT+QENG=\"servingcell\"\r\n",27);

	sleep(1);
	unsigned char rbuf[128]={0x00};
	len = read_data(fd,(char*)rbuf,100,10);
	if(len < 0) {
			print_info("Can't get /dev/ttyUSBx Serial Port data!\n");
	}
	print_info("rbuf = %s\n",(char*)rbuf);
	close(fd);*/

	int ret = 0;
	char csq[128] = {0};

	int fd = 0, sig = 0;

	if((fd = open("/dev/ttyUSB2", O_RDWR | O_NOCTTY | O_NDELAY))<0){

	    //LOG_ERROR("open %s is FAILED\n\n","/dev/ttyUSB2");
	}
	else{
	    set_opt(fd, 9600, 8, 'N', 1);
	}
	set_opt(fd, 115200, 8, 'N', 1);

	//write(fd,"AT+QENG=\"servingcell\"\r\n",27);//开启定位
	write(fd,"AT+CSQ",6);
	sleep(1);
	unsigned char rbuf[128]={0x00};
	int len = read(fd, rbuf, sizeof(rbuf));  // 在串口读入字符串

	print_info("rbuf = %s,len = %d\n",rbuf,len);
	sleep(1);
	if(len < 0) {
		print_info("Can't get /dev/ttyUSBx Serial Port data!\n");
	}

	const char *str2 = "+QENG: ";
	char *pdata = strstr((char*)rbuf, str2);
    if(pdata)
	    strncpy(csq, pdata+7, sizeof(csq));
    else {
        return  -1;
    }
	 //printf("SIM-CSQ: %s\n", csq);
	 GlobalConfig::NetStatus = GetOneContent(csq,1,",");
	 string  signal  = GetOneContent(csq,13,",");
	 GlobalConfig::NetSignal = atoi(signal.c_str());
	 print_info("NetStatus = %s,NetSignal = %d\n",GlobalConfig::NetStatus.c_str(),GlobalConfig::NetSignal);
	// ret = csq
    close(fd);
	/*if(csq[0] == ',')
		ret = 0;
	else if(csq[1] == ',')
		ret = (int)csq[0] - '0';
	else if(csq[2] == ',')
		ret = ((int)csq[0] - '0')*10 + (int)csq[1] - '0';

		 print_info("sig = %d\n", ret);*/
		return atoi(signal.c_str());

/*
    int level;
    char *str = NULL;
	if (strstr(csq, "99,") || strstr(csq, "199,") ){
		printf("No signal ..\n");
		level = 0;
	}
	else {
		char rssi_str[4];
		int rssi;
		memset(rssi_str, 0, sizeof(rssi_str));
		if (*(csq+2) == ',') {
			rssi_str[0] = *(csq+0+0);
			rssi_str[1] = *(csq+0+1);
		}
		else if (isdigit(*(csq+2)) && isdigit(*(csq+3) == ',')) {
			rssi_str[0] = *(csq+0+0);
			rssi_str[1] = *(csq+0+1);
			rssi_str[2] = *(csq+0+2);
		}
		rssi = atoi(rssi_str);

printf("rssi = %d\n", rssi);

		int signal = -113 + (2 * rssi);
		if(signal > -91)
			level = 5;
		else if (signal <= -91 && signal > -101)
			level = 4;
		else if(signal <= -101 && signal > -103)
			level = 3;
		else if(signal <= -103 && signal > -107)
			level = 2;
		else if(signal <= -107 && signal > -113)
			level = 1;
		else
			level = 0;
		printf("level = %d, signal: %d\n", rssi, signal);
		}
*/

}
void IniReadValue(char* section, 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)
    {
        printf("%s: Opent file %s failed.\n", __FILE__, 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;
        }
    }
    if(!bFoundSection){printf("No section = %s\n", section);}
    else if(!bFoundKey){printf("No key = %s\n", key);}
    fclose(fp);
}

int readStringValue(const char* section, char* key, char* val, const char* file)
{
    char sect[SECTION_MAX_LEN];
    //printf("section = %s, key = %s, file = %s\n", section, key, file);
    if (section == NULL || key == NULL || val == NULL || file == NULL)
    {
        printf("%s: input parameter(s) is NULL!\n", __func__);
        return -1;
    }

    memset(sect, 0, SECTION_MAX_LEN);
    sprintf(sect, "[%s]", section);
    //printf("reading value...\n");
    IniReadValue(sect, key, val, file);

    return 0;
}

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

void IniWriteValue(const char* section, char* key, char* val, const char* file)
{
    FILE* fp;
    int i = 0, n = 0, err = 0;
    int lineContentLen = 0;
    int position = 0;
    char lineContent[LINE_CONTENT_MAX_LEN];
    char strWrite[LINE_CONTENT_MAX_LEN];
    bool bFoundSection = false;
    bool bFoundKey = false;

    memset(lineContent, '\0', LINE_CONTENT_MAX_LEN);
    memset(strWrite, '\0', LINE_CONTENT_MAX_LEN);
    n = sprintf(strWrite, "%s=%s\n", key, val);
    fp = fopen(file, "r+");
    if(fp == NULL)
    {
        printf("%s: Opent file %s failed.\n", __FILE__, 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;
        }
    }
    if(!bFoundSection){printf("No section = %s\n", section);}
    else if(!bFoundKey){printf("No key = %s\n", key);}
    fclose(fp);
}

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

int writeIntValue(const char* section, 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);
}

int getDiskInfo(char* diskTotal,char* diskFree)
{
	DISK diskInfo;
//	pDISK pDiskInfo;
//    char dpath[100]="/";//设置默认位置
//    int flag=0;
//    if(NULL!=path)
//    {
//            strcpy(dpath,path);
//    }
//    if(-1==(flag=statfs("/tmp",pDiskInfo)))//获取包含磁盘空间信息的结构体
//    {
//            perror("getDiskInfo statfs fail");
//            return 0;
//    }
//    unsigned long long total=0,avail=0,free=0,blockSize=0;
//
//    blockSize=pDiskInfo->f_bsize;//每块包含字节大小
//    total=pDiskInfo->f_blocks*blockSize;//磁盘总空间
//    avail=pDiskInfo->f_bavail*blockSize;//非超级用户可用空间
//    free=pDiskInfo->f_bfree*blockSize;//磁盘所有剩余空间
//    //字符串转换
//    char diskTotal[30],diskAvail[30],diskFree[30];
//    flag=sprintf(diskTotal,"%llu",total>>20);
//    flag=sprintf(diskAvail,"%llu",avail>>20);
//    flag=sprintf(diskFree,"%llu",free>>20);
//    print_info("diskTotal = %s,diskAvail = %s,diskFree = %s\n",diskTotal,diskAvail,diskFree);
//    if(-1==flag)
//    {
//       return 0;
//    }
	/* 1.获取/home/下面的总容量 */
	statfs("/", &diskInfo);
	unsigned long long blocksize = diskInfo.f_bsize;    //每个block里包含的字节数
	unsigned long long totalsize = blocksize * diskInfo.f_blocks;//总的字节数，f_blocks为block的数目
	//printf("Total_size=%llu B =%llu KB =%llu MB = %llu GB\n",\
	            totalsize,totalsize>>10,totalsize>>20, totalsize>>30);

	     /* 2.获取一下剩余空间和可用空间的大小 */
    unsigned long long freeDisk = diskInfo.f_bfree * blocksize;  //剩余空间的大小
    unsigned long long availableDisk = diskInfo.f_bavail * blocksize; //可用空间大小
	//printf("Disk_free=%llu MB =%llu GB Disk_available=%llu MB = %llu GB\n",\
	           freeDisk>>20,freeDisk>>30,availableDisk>>20, availableDisk>>30);
	sprintf(diskTotal,"%llu",totalsize>>20);
	sprintf(diskFree,"%llu",freeDisk>>20);
    return 1;
}
bool NetIsOk()
{

	double rtt;
	struct hostent *host;
	struct protoent *protocol;
	int i,recv_status;

#ifdef _USE_DNS //如果定义该宏，则可以使用域名进行判断网络连接，例如www.baidu.com
	/* 设置目的地址信息 */
	char hostname[32];
	sprintf(hostname,"%s","www.baidu.com")
	bzero(&dest_addr, sizeof(dest_addr));
	dest_addr.sin_family = AF_INET;

	if((host=gethostbyname(hostname))==NULL)
	{
		LOG_ERROR("[NetStatus]  error : Can't get serverhost info!\n");
		return false;
	}

	bcopy((char*)host->h_addr,(char*)&dest_addr.sin_addr,host->h_length);
#else //如果不使用域名，则只能用ip地址直接发送icmp包，
	dest_addr.sin_addr.s_addr = inet_addr(GlobalConfig::ServerIP.c_str());
#endif


	if ((sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0)
	{	/* 创建原始ICMP套接字 */
		LOG_ERROR("[NetStatus]  error : socket %d\n",sockfd);
		return false;
	}

	int iFlag;
	if(iFlag = fcntl(sockfd,F_GETFL,0)<0)
	{
		LOG_ERROR("[NetStatus]  error : fcntl(sockfd,F_GETFL,0)");
		_CloseSocket();
		return false;
	}
	iFlag |= O_NONBLOCK;
	if(iFlag = fcntl(sockfd,F_SETFL,iFlag)<0)
	{
		LOG_ERROR("[NetStatus]  error : fcntl(sockfd,F_SETFL,iFlag )");
		_CloseSocket();
		return false;
	}
	print_info("================NetIsOk check=============\n");
	pid=getpid();
	for(i=0;i<MAX_NO_PACKETS;i++)
	{

		if(send_packet(i,sendpacket)<0)
		{
			LOG_ERROR("[NetStatus]  error : send_packet");
			_CloseSocket();
			return false;
		}

		if(recv_packet(i,recvpacket)>0)
		{
			_CloseSocket();
			return true;
		}

	}
	_CloseSocket();
	return false;
}



int send_packet(int pkt_no,char *sendpacket)
{
	int packetsize;
	packetsize=pack(pkt_no,sendpacket);
	gettimeofday(&tvsend,NULL);
	print_info("================NetIsOk send_packet=============\n");
	if(sendto(sockfd,sendpacket,packetsize,0,(struct sockaddr *)&dest_addr,sizeof(dest_addr) )<0)
	{
		LOG_ERROR("[NetStatus]  error : sendto error");
		return -1;
	}
	return 1;
}


int pack(int pkt_no,char*sendpacket)
{
	int i,packsize;
	struct icmp *icmp;
	struct timeval *tval;
	icmp=(struct icmp*)sendpacket;
	icmp->icmp_type=ICMP_ECHO;   //设置类型为ICMP请求报文
	icmp->icmp_code=0;
	icmp->icmp_cksum=0;
	icmp->icmp_seq=pkt_no;
	icmp->icmp_id=pid;			//设置当前进程ID为ICMP标示符
	packsize=ICMP_HEADSIZE+sizeof(struct timeval);
	tval= (struct timeval *)icmp->icmp_data;
	gettimeofday(tval,NULL);
	icmp->icmp_cksum=cal_chksum( (unsigned short *)icmp,packsize);
	return packsize;
}


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)		//把ICMP报头二进制数据以2字节为单位累加起来
	{
		sum+=*w++;
		nleft-=2;
	}
	if( nleft==1)		//若ICMP报头为奇数个字节,会剩下最后一字节.把最后一个字节视为一个2字节数据的高字节,这个2字节数据的低字节为0,继续累加
	{
		*(unsigned char *)(&answer)=*(unsigned char *)w;
		sum+=answer;
	}
	sum=(sum>>16)+(sum&0xffff);
	sum+=(sum>>16);
	answer=~sum;
	return answer;
}


int recv_packet(int pkt_no,char *recvpacket)
{
	int n;
	fd_set rfds;
	FD_ZERO(&rfds);
	FD_SET(sockfd,&rfds);
	signal(SIGALRM,timeout);
	unsigned int fromlen=sizeof(recv_addr);
	alarm(MAX_WAIT_TIME);
	print_info("================NetIsOk recv_packet=============\n");
	while(1)
	{
		select(sockfd+1, &rfds, NULL, NULL, NULL);
		if (FD_ISSET(sockfd,&rfds))
		{
			if( (n=recvfrom(sockfd,recvpacket,PACKET_SIZE,0,(struct sockaddr *)&recv_addr,&fromlen)) <0)
    		{
				print_info("================NetIsOk recvfrom=============errno = %d\n",errno);
				if(errno==EINTR){
					return -1;
					LOG_ERROR("recvfrom error");
					return -2;
				}
      		}
		}
		gettimeofday(&tvrecv,NULL);
		if(unpack(pkt_no,recvpacket,n)==-1)
			continue;
		return 1;
	}
}

int unpack(int cur_seq,char *buf,int len)
{
	int iphdrlen;
	struct ip *ip;
	struct icmp *icmp;
	ip=(struct ip *)buf;
	iphdrlen=ip->ip_hl<<2;		//求ip报头长度,即ip报头的长度标志乘4
	icmp=(struct icmp *)(buf+iphdrlen);		//越过ip报头,指向ICMP报头
	len-=iphdrlen;		//ICMP报头及ICMP数据报的总长度
	if( len<8)
		return -1;
	if( (icmp->icmp_type==ICMP_ECHOREPLY) && (icmp->icmp_id==pid) && (icmp->icmp_seq==cur_seq))
		return 0;
	else return -1;
}


void timeout(int signo)
{
	LOG_ERROR("Request Timed Out\n");
	_CloseSocket();
}

void tv_sub(struct timeval *out,struct timeval *in)
{
	if( (out->tv_usec-=in->tv_usec)<0)
	{
		--out->tv_sec;
		out->tv_usec+=1000000;
	}
	out->tv_sec-=in->tv_sec;
}

void _CloseSocket()
{
	close(sockfd);
	sockfd = 0;
}

int socketHeart(const char* pSendData)
{
	print_info("socketHeart\n");
	int sockfd; // Socket文件描述符
	struct sockaddr_in serverAddr{}; // Server地址结构体

	// 创建Socket
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		std::cerr << "Failed to create socket." << std::endl;
		return 1;
	}

	// 设置Server地址信息
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons(18393); // TCP默认端口号为80
	inet_pton(AF_INET, /*GlobalConfig::ServerIP.c_str()*/"192.168.1.147", &serverAddr.sin_addr);

	// 连接到Server
	if (connect(sockfd, reinterpret_cast<struct sockaddr*>(&serverAddr), sizeof(serverAddr)) == -1) {
		std::cerr << "Failed to connect to the server." << std::endl;
		close(sockfd);
		return 1;
	}

	// 发送心跳数据包
	const char heartbeat[] = "Heartbeat";
	ssize_t bytesSent = send(sockfd, pSendData, strlen(pSendData), MSG_NOSIGNAL);
	if (bytesSent == -1) {
		std::cerr << "Failed to send heartbeat packet." << std::endl;
		close(sockfd);
		return 1;
	} else if (static_cast<size_t>(bytesSent) != strlen(pSendData)) {
		std::cerr << "Partially sent heartbeat packet." << std::endl;
		close(sockfd);
		return 1;
	}

	// 关闭Socket连接
	close(sockfd);

	return 0;
}
//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;
//}

// Ping函数，timeout为超时时间，单位是ms,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;
    // 设定Ip信息
    bzero(&addr,sizeof(addr));
    addr.sin_family = AF_INET;

    addr.sin_addr.s_addr = inet_addr(ips);

    int sockfd;
    // 取得socket  。  如果没加sudo 这里会报错
    sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
    if (sockfd < 0)
    {
    	print_error("ip:%s,socket error\n",ips);
        return -1;
    }

    struct timeval timeo;
    // 设定TimeOut时间
    timeo.tv_sec = timeout / 1000;
    timeo.tv_usec = timeout % 1000;

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

    char sendpacket[2048];
    char recvpacket[2048];
    // 设定Ping包
    memset(sendpacket, 0, sizeof(sendpacket));

    pid_t pid;
    // 取得PID，作为Ping的Sequence 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)
    {
    	print_error("ip:%s,sendto error\n",ips);
		close(sockfd);
        return -1;
    }

    // 接受
    // 由于可能接受到其他Ping的应答消息，所以这里要用循环
    int cnt=0;
    while(1)
    {
        // 设定TimeOut时间，这次才是真正起作用的
        FD_ZERO(&readfds);
        FD_SET(sockfd, &readfds);
        maxfds = sockfd + 1;
        n = select(maxfds, &readfds, NULL, NULL, &timeo);
        if (n <= 0)
        {
        	print_info("ip:%s,Time out error\n",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);
        print_info("recvfrom Len:%d\n",n);
        if (n < 1)
    	{
    		close(sockfd);
    		iRet =  1;
    		break;
        }

        char *from_ip = (char *)inet_ntoa(from.sin_addr);
        // 判断是否是自己Ping的回复
        if (strcmp(from_ip,ips) != 0)
        {
        	print_info("NowPingip:%s Fromip:%s NowPingip is not same to Fromip,so ping wrong!\n",ips,from_ip);
		   close(sockfd);
		   iRet = 1;
		   break;

        }

        iph = (struct ip *)recvpacket;

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

        print_info("ip:%s,icmp->icmp_type:%d,icmp->icmp_id:%d\n",ips,icmp->icmp_type,icmp->icmp_id);
        // 判断Ping回复包的状态
        if (icmp->icmp_type == ICMP_ECHOREPLY && icmp->icmp_id == pid)   //ICMP_ECHOREPLY回显应答
        {
            // 正常就退出循环
        	print_info("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)
    {
        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));
	}
}

static const char* JSON_FIELD_CMD = "cmd";//协议:    命令字段
static const char* JSON_FIELD_NAME = "dataWatchName";//协议: 终端名称
static const char* JSON_FIELD_dataNodeGatewayNo = "dataNodeGatewayNo";
static const char* JSON_FIELD_ASSETID = "dataWatchAssetId";//协议:    资产编号  字段
static const char* JSON_FIELD_ADDEDBY = "dataWatchAddedBy";//协议:    添加人  字段
static const char* JSON_FIELD_DEVICETYPE = "deviceType";
static const char* JSON_FIELD_ADDEDDATE = "dataWatchAddedDate";
static const char* JSON_FIELD_IPADDRESS = "dataWatchIpAddress";
static const char* JSON_FIELD_SN = "serialNumber";
static const char* JSON_FIELD_VERSION = "softVersion";
static const char* JSON_FIELD_TIMEZONE = "timezone";