1788 lines
68 KiB
C++
1788 lines
68 KiB
C++
#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 <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); // 闂佺娉涢敃銈囨闁秴绀嗛柟娈垮枟閻ｉ亶鏌涙繝鍕付闁宦板姂瀹曟濡烽妶鍜佹Щ闂佸搫鍟冲▔娑㈠垂鎼淬劍鐓€鐎广儱娲﹂悾閬嶆煕閹邦剚鍣归柣掳鍔嶇粙澶愵敇閵娧咁槷缂備焦宕樺▔鏇㈠煝閼测斁鍋撻悷閭︽Ц闁告瑱鎷<E791B1>
|
||
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_warn(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_warn(zct, "iconv_open failed");
|
||
return -1;
|
||
}
|
||
|
||
memset(outbuf, 0, outlen);
|
||
if ((int)iconv(cd, pin, &inlen, pout, &outlen) == -1) {
|
||
zlog_warn(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};
|
||
// 闂佺懓鐏氶幐鍝ユ閹辩倍io闁荤姳鐒﹂崕鎶剿囬鍕闁搞儻闄勯锟<EE9495>
|
||
fd = open("/sys/class/gpio/export", O_WRONLY);
|
||
if (-1 == fd) {
|
||
zlog_warn(zbt, "open gpio export file error");
|
||
return 1;
|
||
}
|
||
// 闂佹眹鍨归悿鍥敋閻炵棷io
|
||
sprintf(tmp, "%d", gpioN);
|
||
if (write(fd, tmp, strlen(tmp)) < 0) {
|
||
zlog_warn(zbt, "write file operation error:%s", tmp);
|
||
close(fd);
|
||
return 2;
|
||
}
|
||
|
||
close(fd);
|
||
sleep(1);
|
||
// 闂備焦婢樼粔鍫曟偪閸炲兎io闂佸搫鍊婚幊鎾诲箖閿燂拷
|
||
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);
|
||
|
||
zlog_info(zbt, "open GPIO = %s", tmp);
|
||
fd = open(tmp, O_WRONLY);
|
||
if (-1 == fd) {
|
||
zlog_warn(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_warn(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_warn(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};
|
||
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);
|
||
|
||
|
||
// 闂佺懓鐏氶幐鍝ユ閹辩倍io value闂佸搫鍊稿ú锝呪枎閿燂拷
|
||
fd = open(tmp, O_WRONLY);
|
||
if (-1 == fd) {
|
||
zlog_warn(zbt, "[%s] open gpio export file error", tmp);
|
||
close(fd);
|
||
return -1;
|
||
}
|
||
// 闁荤姳绀佹晶浠嬫偪閸℃稒鍋ㄩ梻鍫熺洴閹革拷
|
||
if (x) {
|
||
if (-1 == write(fd, "1", sizeof("1"))) {
|
||
zlog_warn(zbt, "%d write operation value error", gpioN);
|
||
close(fd);
|
||
return -2;
|
||
}
|
||
} else {
|
||
if (-1 == write(fd, "0", sizeof("0"))) {
|
||
zlog_warn(zbt, "%d write operation value errorn", gpioN);
|
||
close(fd);
|
||
return -3;
|
||
}
|
||
}
|
||
close(fd);
|
||
return 0;
|
||
}
|
||
|
||
int gpio_read(unsigned int gpioN) {
|
||
int fd = 0;
|
||
char value;
|
||
|
||
char tmp[100] = {0};
|
||
|
||
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);
|
||
|
||
// 闂佺懓鐏氶幐鍝ユ閹辩倍io value闂佸搫鍊稿ú锝呪枎閿燂拷
|
||
fd = open(tmp, O_RDONLY);
|
||
if (-1 == fd) {
|
||
zlog_warn(zbt, "%d open gpio export file error", gpioN);
|
||
return -1;
|
||
}
|
||
// 闁荤姴娲╅褑銇愰敓锟<E69593> value闂佸搫鍊稿ú锝呪枎閿燂拷
|
||
if (-1 == read(fd, &value, sizeof(value))) {
|
||
zlog_warn(zbt, "%d read gpiovalue is fail", gpioN);
|
||
close(fd);
|
||
return -2;
|
||
}
|
||
close(fd);
|
||
return value;
|
||
}
|
||
|
||
int config_uart(const char *port, int speed) {
|
||
int fd = open(port, O_RDWR | O_NOCTTY);
|
||
if (fd < 0) {
|
||
zlog_warn(zbt, "open port:%s failed", port);
|
||
return -1;
|
||
}
|
||
struct termios opt;
|
||
tcgetattr(fd, &opt);
|
||
cfsetispeed(&opt, speed);
|
||
cfsetospeed(&opt, speed);
|
||
if (tcgetattr(fd, &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(fd, TCSANOW, &opt) < 0) {
|
||
zlog_error(zbt, "tcsetattr failed");
|
||
return -2;
|
||
}
|
||
tcflush(fd, TCIOFLUSH);
|
||
return fd;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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; // 婵炴垶鎸哥粔铏箾閸ヮ剚鍋ㄩ柕濞垮労濡叉儳霉閻橆喖鈧牕顪冮敓锟<E69593>
|
||
|
||
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);
|
||
}
|
||
|
||
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; // 婵犮垹婀辨晶妤€危閹寸偟鈻旈柍褜鍓氱粙澶愵敂閸曨厽鎲荤紓浣诡殣缂傛氨鎲伴崱娑樿Е闁硅揪绠戝▍锟<E2968D>
|
||
// 婵炲濮伴崕鎾敋娴兼潙绀傞柕澶涢檮閻撴瑧鈧鍠栫换鎴炴櫠閿曗偓椤曪綁鍩€椤掑嫬妫橀柛銉檮椤愶拷
|
||
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; // 婵犮垹婀辨晶妤€危閹寸偟鈻旈柍褜鍓氱粙澶愵敂閸曨厽鎲荤紓浣诡殣缂傛氨鎲伴崱娑樿Е闁硅揪绠戝▍锟<E2968D>
|
||
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;
|
||
}
|
||
|
||
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闂佺儵鍋撻崝宥夘敆濠婂牆绀嗘繛鍡樺竾閳ь剙鍟蹇涘箚瑜忕涵鈧俊銈囧Т閻線鎯佹繅鐪曢梺闈╅檮濠㈡ê顭囬崘顔艰Е闁割偆鍠撻妴锟<E5A6B4>
|
||
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;
|
||
|
||
// 闁诲繐绻愰幑鍑遍梺闈╅檮濠㈡ê顭囬崘顔藉仺闁瑰吀璁查崑鎾斥堪閸涱厺鍖栭梺鍛婂笒濡鐣烽崟顒佷氦婵炴垶锚閻撴垿鏌嶉妷锔剧畾婵炴潙妫濋獮鎴﹀閳ュ磭浜<E7A3AD> 闂佺偨鍎茬划鍫㈣姳閳哄倹浜ゆ繛鎴灻悡鎴︽煛娴ｅ摜鎽犻柡鍡欏枛閸ㄩ箖鏁撻敓锟<E69593>
|
||
struct in_addr s;
|
||
iRet = inet_pton(AF_INET, mask.c_str(), &s);
|
||
|
||
// 闁哄鍎愰崜姘暦閺屻儱绠ｉ柟閭﹀墮椤娀寮堕埡鍌涚叆婵炶鎷<EE879C>1闂佹寧绋戦惌渚€顢氶埡鍛強閹兼番鍨虹瑧闂佸搫鐗嗛ˇ浼村疾閵夆晜鍎嶉柛鎴瘽闂侀潻闄勫妯侯焽閿燂拷
|
||
if (iRet == 1) {
|
||
// 婵炲濮村ù椋庣礊婢跺瞼纾兼繝濠傚暟閹界喖鏌ら崫鍕偓鍧楀Υ鎼淬垺鍎熼煫鍥ㄧ缁侇噣鏌熺拠鈩冪窔閻犳劗鍠愮粙澶岀磼濡崵鐨婚柣搴㈢⊕椤ㄥ淇婇鐔翠簻闁告繂瀚喊锟<E5968A>
|
||
unsigned int addr = ntohl(s.s_addr);
|
||
|
||
// 闁哄鍎愰崜姘暦閸欏鈻旈弶鐐村閻у矂寮堕埡鍌溾槈闁糕晜顨堥埀顒佺⊕椤ㄥ牓顢栨担鍦枖闁跨噦鎷<E599A6>
|
||
std::bitset<32> b((int)addr);
|
||
std::string strMask = b.to_string();
|
||
|
||
// 闂佸搫琚崕鍙夌珶濡崵顩茬€光偓閸愵亞顔掗梺鍛婂笩濞夋盯鎮鸿缁參鏁傞懗顖ｆ船婵炴垶鎼╅崢鎯р枔閿燂拷"01"闂佹寧绋戦懟顖炪€呰瀵ǹ饪伴埀顒傜箔婢跺备鍋撳☉娅亜锕㈤鍫熸櫖鐎光偓閸愭儳娈梺鍝勫鐎涒晛危閹间礁瀚夊璺侯儐濞呭繘鏌ｉ妸銉ヮ仼闁烩剝鐟х槐鏃堝箣閻愯尪绀嬮梺娲诲櫙閹凤拷
|
||
return (strMask.find("01") == std::string::npos);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
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(Json::Value &jsData) {
|
||
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);
|
||
getDiskInfo(hardTotal, hardFree);
|
||
|
||
|
||
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::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;
|
||
}
|
||
int GetSysStatusCMT(int& cpu_use,int& mem_use,int& disk_remain,int& cpu_temp)
|
||
{
|
||
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);
|
||
getDiskInfo(hardTotal, hardFree);
|
||
std::string strhardFree(hardFree);
|
||
char key[128] = {0};
|
||
memset(key, 0, sizeof(key));
|
||
sprintf(key, "/sys/class/thermal/thermal_zone0/temp");
|
||
int temp = getSysIntValue(key);
|
||
cpu_use = rateUser;
|
||
mem_use = fMemRate * 100;
|
||
disk_remain = atoi(strhardFree.substr(0, strhardFree.length() - 1).c_str());
|
||
cpu_temp = temp / 1000.0;
|
||
}
|
||
// 闁诲繐绻愬Λ妤€鐣烽悢鍝モ枖闁跨噦鎷<E599A6>16闁哄鏅滅粙鎴﹀春濡ゅ啠鍋撳☉娆樻畼妞ゆ垳鐒﹀顏堫敆娴ｇǹ绨ユ繛鎴炴尭閹碱偊顢氶鑺ュ劅闁哄啫鍊归悾閬嶆倵濞戞瑯娈欏┑鈽嗗弮瀹曟劙鏁撻敓锟<E69593>
|
||
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; // 闁诲海鏁婚埀顒佺〒閼归箖鏌￠崘顏勑ｉ柡鍛劦閹啴宕熼銈嗘喕缂備焦顨愮拋锝囨濠靛洦浜ら柡鍌涘缁€鈧<E282AC>0
|
||
}
|
||
|
||
// 闁诲繐楠忛幏锟<E5B98F>16闁哄鏅滅粙鎴﹀春濡ゅ啠鍋撳☉娆樻畼妞ゆ垳鐒︾粙澶愭嚑閼哥數銈梺纭咁嚃濠⑩偓閻犳劗鍠撻埀顒佺⊕椤ㄥ淇婇銏犳瀬闁规鍠氶惌锟<E6838C>
|
||
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; // 闁诲孩绋掗〃澶嬩繆椤撱垹鏋侀柟娈垮枤閻鏌ｉ妸銉ヮ仼闁靛洤娲ㄦ禍姝岀疀鎼达絿鎲归柣鈩冨笒閸樻牗绂嶉幒鏂哄亾閻熺増璐￠柟鎯у悑濞碱亪顢楁担绋跨哎闂佸憡鑹惧ù宄扳枔閹寸姭鍋撳☉娆樻畽濠碘槄鎷<E6A784>
|
||
}
|
||
|
||
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;
|
||
}
|
||
// 濠电儑缍€椤曆勬叏閻愮鍋撳☉娆樻畼妞ゆ垳鐒︾粙澶愭嚑椤掑倹灏濋梺鍝勵槺閸犳捇顢栭敓锟<E69593>
|
||
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) { // 濠碘槅鍋€閸嬫挻绻涢弶鎴剮閻熸洖妫濆畷锝夋晲閸℃锕傛煕濮樺墽鐣辩憸鐗堢叀閹粙鏁撻敓锟<E69593>
|
||
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) { // 闁荤姳绀佹晶浠嬫偪閸℃稑纾绘繝濠傚閸撴儳霉閿濆繑瀚<E7B991>
|
||
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;
|
||
}
|
||
|
||
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_warn(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(sect, 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/婵炴垶鎸搁澶婎焽娴煎瓨鍎嶉柛鏇ㄥ厴閸嬫挾鎷犲顔兼櫍闂備浇顕滈幏锟<E5B98F>
|
||
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;
|
||
|
||
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;
|
||
}
|
||
|
||
// Ping闂佸憡鍨兼慨銈夊汲閻斿吋鏅悗鍦交meout婵炴垶鎹囩紓姘辩矓閹绢喖绫嶉柤绋跨仛椤ρ囨⒒閸屾繃褰х紒杈ㄧ箞瀹曪繝寮村杈┬㈤梺鍝勫濡,10000 濠殿噯缍嗛崑鍡涳綖閿燂拷=10 缂備礁顧€閹凤拷
|
||
// 闂佺懓鐡ㄩ崝鏇熸叏濞戙垺鏅慨妯虹－缁犳煡鏌涢妷顖涘0闂佹寧绋戦懟顖炲Φ閹寸姵瀚婚柕澶樺灣缁愭寮堕埡鍌涚叆婵炶鎷<EE879C>1闂佺鎻幏锟<E5B98F>-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;
|
||
sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
|
||
if (sockfd < 0) {
|
||
zlog_error(zct, "ip:%s,socket error", ips);
|
||
return -1;
|
||
}
|
||
|
||
struct timeval timeo;
|
||
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];
|
||
memset(sendpacket, 0, sizeof(sendpacket));
|
||
|
||
pid_t pid;
|
||
pid = getpid();
|
||
|
||
struct ip *iph;
|
||
struct icmp *icmp;
|
||
|
||
icmp = (struct icmp *)sendpacket;
|
||
icmp->icmp_type = ICMP_ECHO; // 闂佹悶鍎抽崑鐐参熸径灞惧珰闂佸灝顑囧﹢锟<EFB9A2>
|
||
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闂佹眹鍔岀€氼剛鑺遍懠顒傞┏闁哄啠鍋撶紒澶屽厴楠炰線顢涢妶鍥╊槷闂佸湱顣介崑鎾趁归悩顔煎姤缂佺粯鐗犻弻灞界暆閸愮偓鐭楅梺鐑╁亾閸斿矂骞嗘繝鍥ㄥ仢闁跨噦鎷<E599A6>
|
||
int cnt = 0;
|
||
while (1) {
|
||
// 闁荤姳鐒﹂崕鎶芥偩缂嶇棤meOut闂佸搫鍟悥鐓幬涢崸妤佹櫖鐎光偓閸愵亞顔愬┑鐐叉閸撴繃鏅堕悩璇插強妞ゆ牗绮嶉崺鍌涙叏濠垫挾绉柟鐧哥稻閹峰懎饪伴崨顔芥闂佹椿鐓夐幏锟<E5B98F>
|
||
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);
|
||
// 闂佸憡甯囬崐鏍蓟閸ヮ剙鍙婃い鏍ㄧ閸庡﹪鏌￠崟闈涚仴闁搞倖绮岄蹇涙儎椤﹀級g闂佹眹鍔岀€氼剙煤閺嶃劌绶為柨鐕傛嫹
|
||
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);
|
||
// 闂佸憡甯囬崐鏍蓟閸㈡迹ng闂佹悶鍎抽崑娑⑺囬弻銉ョ闁告侗鍨遍悾閬嶆煟濡灝鐓愰柍褜鍓ㄩ幏锟<E5B98F>
|
||
if (icmp->icmp_type == ICMP_ECHOREPLY && icmp->icmp_id == pid) {
|
||
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;
|
||
}
|
||
|
||
// 闁诲繐绻愬Λ娑欐櫠濡ゅ懎瀚夋い鎺嗗亾鐟滄媽娉曢埀顒佺⊕椤ㄥ牓顢栨担鍦枖闁告瑥顦鏇㈡煕閹烘垶顥欓悹鎰枛瀵偆鈧稒蓱濞堝墎绱撴担绋款仾闁搞劍宀搁幆鍐礋椤愶絽鈧姊虹拠褎瀚<E8A48E>
|
||
std::vector<int> splitVersion(const std::string &version) {
|
||
std::vector<int> parts;
|
||
std::stringstream ss(version);
|
||
std::string part;
|
||
|
||
// 闂佺儵鍋撻崝搴ㄥ磻閿濆棙濯存繝濞惧亾閻犳劗鍠栧畷姘跺幢濞戞瑯鍚樼紓浣诡殣鐠侊絿妲愬┑瀣闁糕剝顨呴ˉ蹇涙煟濡も偓閻楀﹤锕㈡导鏉戠煑闁跨噦鎷<E599A6>
|
||
while (std::getline(ss, part, '.')) {
|
||
parts.push_back(std::stoi(part)); // 闁诲繐绻愬Λ妤呭垂鎼淬劌绀堥柟缁樺笚閸婄敻鏌ｉ妸銉ヮ伃闁稿孩鎸冲畷姘跺幢濮橆厾銈梺纭咁嚃濠⑩偓閻犳劗鍠栧顐も偓娑櫳戝▓锟<E29693>
|
||
}
|
||
|
||
return parts;
|
||
}
|
||
|
||
// 姣旇緝涓や釜鐗堟湰鍙<E6B9B0>
|
||
int compareVersions(const std::string &version1, const std::string &version2) {
|
||
std::vector<int> v1 = splitVersion(version1);
|
||
std::vector<int> v2 = splitVersion(version2);
|
||
|
||
// 闁瑰灚鍎抽崺宀勫嫉閳ь剟姊圭捄銊︾暠闁绘鐗婂﹢浼村矗閻戣棄鍔ラ柛鎺戞閺嗚鲸鎯旈敓锟<E69593>
|
||
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) {
|
||
// 婵炲瓨绮岄惌浣烘崲濮椻偓瀹曟岸鎳滈悽闈涘福婵炶揪绲界粔鍫曟偪閸℃稒鈷栭柤鎼佹涧閻忔鏌ら弶鎸庡櫢缂佹棑鎷<E6A391> position婵炴垶鎹佸銊х礊閸涙潙鏋侀柨鐕傛嫹(婵炲濯撮幏锟<E5B98F>0 閻庢鍠掗崑鎾斥攽椤曞棙瀚<E6A399>)
|
||
if (flag) {
|
||
*p_data |= 0x01 << (position);
|
||
} else {
|
||
*p_data &= ~(0x01 << (position));
|
||
}
|
||
}
|
||
std::string get_file_md5(const std::string& file_path) {
|
||
// 使用 md5sum 命令计算文件的 MD5 值
|
||
std::string command = "md5sum " + file_path + " | awk '{ print $1 }'";
|
||
|
||
// 使用 popen 执行命令并获取输出
|
||
std::array<char, 128> buffer;
|
||
std::string result;
|
||
std::shared_ptr<FILE> pipe(popen(command.c_str(), "r"), pclose);
|
||
|
||
if (!pipe) {
|
||
std::cerr << "Error: Unable to run md5sum command" << std::endl;
|
||
return "";
|
||
}
|
||
|
||
// 从命令的输出流中读取数据
|
||
while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
|
||
result += buffer.data();
|
||
}
|
||
|
||
// 去除末尾的换行符
|
||
result.erase(result.find_last_not_of("\n") + 1);
|
||
|
||
return result;
|
||
} |