myvtm/DevAdapter/DeviceSimulator.h

//用于定义实现一些模拟器通用的函数功能
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <string>
#include <map>
#include "path.h"
#include "CommEntityRestful.hpp"
#include <SpBase.h>
#include "IHttpFunc.h"

#ifdef RVC_OS_WIN
#include <WinSock2.h>
#include <direct.h>
#define GetCurrentDir _getcwd
#else
#include <arpa/inet.h>  //ntohl
#include <unistd.h> // Linux系统中
#include <netdb.h>  
#include <net/if.h>  
#include <arpa/inet.h> 
#include <sys/ioctl.h>  
#include <sys/types.h>  
#include <sys/socket.h>
#include <netinet/in.h>
#define GetCurrentDir getcwd
#endif

#define REFLECTION(var) #var
using namespace std;

static void HttpsLogCallBack(const char* logtxt) {}

string GetCurrentDirectory() {
	char buff[256];
	GetCurrentDir(buff, 256);
	string  current_working_directory(buff);
	return current_working_directory;
}

//读取配置文件功能类
class iniReader
{
public:
	iniReader()
	{
	}
	~iniReader()
	{
	}
	bool ReadConfig(const string& filename)
	{
		settings_.clear();
		ifstream infile(filename.c_str());//构造默认调用open,所以可以不调用open
		//ifstream infile;
		//infile.open(filename.c_str());
		//bool ret = infile.is_open()
		if (!infile) {
			return false;
		}
		string line, key, value, section;
		map<string, string> k_v;
		map<string, map<string, string> >::iterator it;
		while (getline(infile, line))
		{
			if (AnalyseLine(line, section, key, value))
			{
				it = settings_.find(section);
				if (it != settings_.end())
				{
					k_v[key] = value;
					it->second = k_v;
				}
				else
				{
					k_v.clear();
					settings_.insert(make_pair(section, k_v));
				}
			}
			key.clear();
			value.clear();
		}
		infile.close();
		return true;
	}

	string ReadString(const char* section, const char* item, const char* default_value)
	{
		string tmp_s(section);
		string tmp_i(item);
		string def(default_value);
		map<string, string> k_v;
		map<string, string>::iterator it_item;
		map<string, map<string, string> >::iterator it;
		it = settings_.find(tmp_s);
		if (it == settings_.end())
		{
			//printf("111");
			return def;
		}
		k_v = it->second;
		it_item = k_v.find(tmp_i);
		if (it_item == k_v.end())
		{
			//printf("222");
			return def;
		}
		return it_item->second;
	}

	int ReadInt(const char* section, const char* item, const int& default_value)
	{
		string tmp_s(section);
		string tmp_i(item);
		map<string, string> k_v;
		map<string, string>::iterator it_item;
		map<string, map<string, string> >::iterator it;
		it = settings_.find(tmp_s);
		if (it == settings_.end())
		{
			return default_value;
		}
		k_v = it->second;
		it_item = k_v.find(tmp_i);
		if (it_item == k_v.end())
		{
			return default_value;
		}
		return atoi(it_item->second.c_str());
	}

	float ReadFloat(const char* section, const char* item, const float& default_value)
	{
		string tmp_s(section);
		string tmp_i(item);
		map<string, string> k_v;
		map<string, string>::iterator it_item;
		map<string, map<string, string> >::iterator it;
		it = settings_.find(tmp_s);
		if (it == settings_.end())
		{
			return default_value;
		}
		k_v = it->second;
		it_item = k_v.find(tmp_i);
		if (it_item == k_v.end())
		{
			return default_value;
		}
		return atof(it_item->second.c_str());
	}

private:
	bool IsSpace(char c)
	{
		if (' ' == c || '\t' == c)
			return true;
		return false;
	}

	bool IsCommentChar(char c)
	{
		switch (c)
		{
		case '#':
			return true;
		default:
			return false;
		}
	}

	void Trim(string& str)
	{
		if (str.empty())
		{
			return;
		}
		int i, start_pos, end_pos;
		for (i = 0; i < str.size(); ++i) {
			if (!IsSpace(str[i])) {
				break;
			}
		}
		if (i == str.size())
		{
			str = "";
			return;
		}
		start_pos = i;
		for (i = str.size() - 1; i >= 0; --i) {
			if (!IsSpace(str[i])) {
				break;
			}
		}
		end_pos = i;
		str = str.substr(start_pos, end_pos - start_pos + 1);
	}

	bool AnalyseLine(const string& line, string& section, string& key, string& value)
	{
		if (line.empty())
			return false;
		int start_pos = 0, end_pos = line.size() - 1, pos, s_startpos, s_endpos;
		if ((pos = line.find("#")) != -1)
		{
			if (0 == pos)
			{
				return false;
			}
			end_pos = pos - 1;
		}
		if (((s_startpos = line.find("[")) != -1) && ((s_endpos = line.find("]"))) != -1)
		{
			section = line.substr(s_startpos + 1, s_endpos - 1);
			return true;
		}
		string new_line = line.substr(start_pos, start_pos + 1 - end_pos);
		if ((pos = new_line.find('=')) == -1)
			return false;
		key = new_line.substr(0, pos);
		value = new_line.substr(pos + 1, end_pos + 1 - (pos + 1));
		Trim(key);
		if (key.empty()) {
			return false;
		}
		Trim(value);
		if ((pos = value.find("\r")) > 0)
		{
			value.replace(pos, 1, "");
		}
		if ((pos = value.find("\n")) > 0)
		{
			value.replace(pos, 1, "");
		}
		return true;
	}

private:
	//map<string, string> settings_;
	map<string, map<string, string> >settings_;
};

typedef struct SimulatorCommonReq : CHTTPReq {
	std::string ip;
	std::string entityName;
	std::string adapterInterName;

	string ToJson() {
		Json::Value value;
		value[REFLECTION(ip)] = ip;
		value[REFLECTION(entityName)] = entityName;
		value[REFLECTION(adapterInterName)] = adapterInterName;
		Json::FastWriter writer;
		string strData = writer.write(value);

		return strData;
	}
} SimulatorCommonReq;

typedef struct SimulatorCommonAns : CHTTPRet {
	DevCategoryInfo devCategoryInfo;
	bool success;
	bool result;
	int errNum;

	bool Parse(string strData) {
		Json::Value root;
		Json::Reader reader;
		reader.parse(strData, root, false);

		success = root[REFLECTION(success)].asBool();
		result = root["data"][REFLECTION(result)].asBool();
		errNum = root["data"][REFLECTION(errNum)].asInt();

		devCategoryInfo.eState = (DevStateEnum)root["data"][REFLECTION(eState)].asInt();
		devCategoryInfo.version.wBuild = root["data"][REFLECTION(wBuild)].asInt();
		devCategoryInfo.version.wMajor = root["data"][REFLECTION(wMajor)].asInt();
		devCategoryInfo.version.wMinor = root["data"][REFLECTION(wMinor)].asInt();
		devCategoryInfo.version.wRevision = root["data"][REFLECTION(wRevision)].asInt();
		strcpy(devCategoryInfo.szModel, root["data"][REFLECTION(szModel)].asString().c_str());
		strcpy(devCategoryInfo.szType, root["data"][REFLECTION(szType)].asString().c_str());
		strcpy(devCategoryInfo.szVendor, root["data"][REFLECTION(szVendor)].asString().c_str());

		return true;
	}
}SimulatorCommonAns;

//获取硬件模拟器地址
string GetSimulatorUrl()
{
	string depCfgPath = GetCurrentDirectory() + SPLIT_SLASH_STR + "dep" + SPLIT_SLASH_STR + "cmbsz.ini";
	iniReader iniRead;
	bool ret = iniRead.ReadConfig(depCfgPath);
	if (!ret)
	{
		return "";
	}

	string urlStr = iniRead.ReadString("server", "url", "");
	return urlStr;
}

//读取本地IP功能函数
string GetLocalIP()
{
#ifdef RVC_OS_WIN
	hostent* ent = gethostbyname(NULL);
	if (ent && ent->h_addr_list[0] != NULL)
	{
		int i = 0;
		for (; ent->h_addr_list[i] != NULL; ++i)
		{
			struct in_addr* in = (struct in_addr*)ent->h_addr_list[i];
			if (in->S_un.S_un_b.s_b1 == 99 || in->S_un.S_un_b.s_b1 == 10)
				break;
		}

		if (ent->h_addr_list[i] == NULL)
			i = 0;

		auto in = (struct in_addr*)ent->h_addr_list[i];
		char xIP[64] = {};
		sprintf(xIP, "%d.%d.%d.%d", in->S_un.S_un_b.s_b1, in->S_un.S_un_b.s_b2, in->S_un.S_un_b.s_b3, in->S_un.S_un_b.s_b4);
		//LOG4VTM(INFO, ("ip:%s", xIP));

		return string(xIP);
	}
	return "";
#else
	string re = "";
	int sfd, intr;
	struct ifreq buf[16];
	struct ifconf ifc;
	sfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sfd < 0)
		return "wrong 1: get ip socket failed";
	ifc.ifc_len = sizeof(buf);
	ifc.ifc_buf = (caddr_t)buf;
	if (ioctl(sfd, SIOCGIFCONF, (char*)&ifc))
		return "wrong 2: get ip ioctl failed";
	intr = ifc.ifc_len / sizeof(struct ifreq);
	while (intr-- > 0 && ioctl(sfd, SIOCGIFADDR, (char*)&buf[intr]));
	close(sfd);
	unsigned long ip = ntohl(((struct sockaddr_in*)(&buf[intr].ifr_addr))->sin_addr.s_addr);

	char* str = new char[1024];
	sprintf(str, "%u.%u.%u.%u", ip >> 24 & 0xFF, ip >> 16 & 0xFF, ip >> 8 & 0xFF, ip >> 0 & 0xFF);
	re = str;
	return re;
#endif
}


string GetValueFromIni(const string& filePath, const string& section, const string& key) {
	ifstream file(filePath);
	string line;
	string value;
	bool sectionFound = false;

	while (getline(file, line)) {
		if (!sectionFound && line == "[" + section + "]") {
			sectionFound = true;
		}
		else if (sectionFound) {
			size_t found = line.find(key);
			if (found != string::npos) {
				size_t equalsPos = line.find("=");
				value = line.substr(equalsPos + 1);
				break;
			}
		}
	}

	return value;
}


int StrBuf2HexBuf(LPCTSTR strBuf, PBYTE* hexBuf)
{
	int len = strlen(strBuf);
	if (len == 0 || len % 2 != 0)
		return 0;
	BYTE* buf = new BYTE[len / 2];
	if (buf == NULL)
		return 0;
	int j = 0;
	for (int i = 0; i < len;)
	{
		int tmpVal;
		sscanf(strBuf + i, "%2X", &tmpVal);
		buf[j] = tmpVal;
		//buf[j] = char2int(strBuf[i])*16 + char2int(strBuf[i+1]);
		i += 2;
		j++;
	}
	//memcpy(buf,strBuf,len);
	*hexBuf = buf;
	return j;
}

int HexBuf2StrBuf(PBYTE hexBuf, char** strBuf, DWORD len)
{
	char* tmpStr = *strBuf;
	int count = 0;
	for (int i = 0; i < len; ++i)
	{
		sprintf(tmpStr + count, "%0.2X", hexBuf[i]);
		count += 2;
	}
	return 0;
}

template <typename T>
ErrorCodeEnum SimulatorHttpFunction(string entityName, string devFuncName, T& obj)
{
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	SimulatorCommonReq simulatorCommonReq;
	simulatorCommonReq.ip = GetLocalIP();
	simulatorCommonReq.entityName = entityName;
	simulatorCommonReq.adapterInterName = devFuncName;
	simulatorCommonReq.m_url = GetSimulatorUrl();

	ErrorCodeEnum err = Error_NotImpl;

	bool ret = client->Post(simulatorCommonReq, obj);
	if (ret) {
		if (!obj.success)
		{
			return Error_NotImpl;
		}
		else
		{
			err = (ErrorCodeEnum)obj.errNum;
		}
	}
	else
	{
		return Error_NotImpl;
	}

	return err;
}