cameraHelper.h

#ifndef _CAMERA_HELPER_H
#define _CAMERA_HELPER_H

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include "include/include/ScTypeEx.h"
#include "include/include/mxml.h"

#include "include/app/trafficSDKHelper.h"
#include "include/app/characterCoder.h"
#include "include/app/trafficMxml.h"

//删除节点操作的宏
#define DEL_CONFIG_NODE       0


#define   DEBUG_SWITCH        0
#if  DEBUG_SWITCH
#define tc_printf_debug(fmt,args...) printf(fmt, ##args)
#else
#define tc_printf_debug(fmt,args...) /*do nothing */
#endif


int HexDecode(unsigned char * buf, const char * base64code, int src_len);

/*
 * 字符串中解析填充ScSystemTime结构体
 */
int tcString2Time(ScSystemTime *pScTime, char *pValue);



/*
 *从HSCConfig中取出Val的xml流,并将gbk的流转换为utf8的流，以便于浏览器显示
 */
int tcGetKeyXmlutf8(char *xmlString, int xmlLen);



/*
 *从HSCConfig中取出Att的xml流,并将gbk的流转换为utf8的流，以便于浏览器显示
 */
int tcGetValXmlutf8(char *xmlString, int xmlLen);



/*
 * 字符串分析，从形如"root//node1//node2//node3#0"的字符串中
 * 解析出key值"root//node1//node2//node3“和类型nValueType=2
 */
int tcAnalysisKeyTypeString(char *sourKeyString, char *outKey, int *valueType);



/*
 * 根据key值和类型nValueType来完成config参数的设置
 */
int tcSetValueByKeyType(char* szKey, void *pValue, int nValueType);



void tcTrafficResult(int nResultType, void* pResultData,long  nDataLen, unsigned int dwUser);


//封装后的注册回调函数
void tcRegisterCallback();



/*
 * 从xml流中删除已经在settingsConfig.xml中出现过的key值,并输出到outXmlBuf中
 */
int tcDelXmlNode(char *inXmlString, char *outXmlBuf, int bufLen, char *iniPath);


ScErr tcAddValueByReferer(const char *refererInfo, HttpConn* curConn);


ScErr tcAddAttributeByReferer(const char *refererInfo, HttpConn* curConn);





/*************************************************************************************************************************/

int HexDecode(unsigned char * buf, const char * base64code, int src_len) 
{   
	if (src_len == 0)
		src_len = strlen(base64code);
	int len = 0;
	char data[16] = {0};
	int i=0;
	for(i=0; i<src_len;)
	{
		data[0] = base64code[i];
		data[1] = base64code[i+1];

		sscanf(data, "%02X", &buf[len]);
		i += 2;
		len ++;
	}

	return len;
}
/*
 * 字符串中解析填充ScSystemTime结构体
 */
int tcString2Time(ScSystemTime *pScTime, char *pValue)
{
	if(pValue == NULL || pScTime == NULL)
		return SC_ErrParamerErr;
	//pValue的格式形如 Hour：Minute:Second(固定页面提交)，Hour：Minute(高级参数树提交)
	char pSrcTime[64] = "";
	char *itemTime = NULL;
	memcpy(pSrcTime, pValue, strlen(pValue));

	char *tmpPt = NULL;
	if((itemTime = strtok_r(pSrcTime, ":", &tmpPt)) != NULL)
	{
		pScTime->wHour = atoi(itemTime);
		if((itemTime = strtok_r(NULL, ":", &tmpPt)) != NULL)
		{
			pScTime->wMinute = atoi(itemTime);
			if((itemTime = strtok_r(NULL, ":", &tmpPt)) != NULL)
			{
				pScTime->wSecond = atoi(itemTime);
			}
		}
	}

	pScTime->wYear = 0;
	pScTime->wMonth = 0;
	pScTime->wDayOfWeek = 0;
	pScTime->wDay = 0;
	pScTime->wMilliseconds = 0;
	return SC_ErrSuccess;
}


/*
 *从HSCConfig中取出Val的xml流,并将gbk的流转换为utf8的流，以便于浏览器显示
 */
int tcGetKeyXmlutf8(char *xmlString, int xmlLen)
{
	HSCConfig pConfig = getHSCConfig();
	if(pConfig == NULL)
	{
		tc_printf_debug("!!!!!!!!!!!! WARNNING: getHSCConfig !!!!!!!!!!!!\n");
		return SC_ErrNoResources;
	}
	int nValLen = 0;
	char* xmlValStream = scCfgGetValStream(pConfig, &nValLen);
	if(xmlValStream == NULL)
	{
		tc_printf_debug("!!!!!!!!!!!! WARNNING: scCfgGetValStream !!!!!!!!!!!!\n");
		return SC_ErrUnknow;
	}

#if DEL_CONFIG_NODE
	/************************************转码操作*****************************************************/
	char utfXmlString[1024*256] = "";
	int utfXmlLen = sizeof(utfXmlString);
	if(gbk2utf(xmlValStream, strlen(xmlValStream), utfXmlString, utfXmlLen) != 0)
	{
		tc_printf_debug("!!!!!!!!!!!! WARNNING: gbk2uft !!!!!!!!!!!!\n");
		return SC_ErrUnknow;
	}

	tcDelXmlNode(utfXmlString, xmlString, xmlLen, NULL);

#else
	if(gbk2utf(xmlValStream, strlen(xmlValStream), xmlString, xmlLen) != 0)
	{
		tc_printf_debug("!!!!!!!!!!!! WARNNING: gbk2uft !!!!!!!!!!!!\n");
		return SC_ErrUnknow;
	}

#endif

	return SC_ErrSuccess;
}


/*
 *从HSCConfig中取出Att的xml流,并将gbk的流转换为utf8的流，以便于浏览器显示
 */
int tcGetValXmlutf8(char *xmlString, int xmlLen)
{
	HSCConfig pConfig = getHSCConfig();
	if(pConfig == NULL)
	{
		tc_printf_debug("!!!!!!!!!!!! WARNNING: getHSCConfig !!!!!!!!!!!!\n");
		return SC_ErrNoResources;
	}
	int nValLen = 0;
	char* xmlAttStream = scCfgGetAttStream(hConfig, &nValLen);
	if(xmlAttStream == NULL)
	{
		tc_printf_debug("!!!!!!!!!!!! WARNNING: scCfgGetAttStream !!!!!!!!!!!!\n");
		return SC_ErrUnknow;
	}

#if DEL_CONFIG_NODE
	/************************************转码操作*****************************************************/
	char utfXmlString[1024*256] = "";
	int utfXmlLen = sizeof(utfXmlString);
	if(gbk2utf(xmlAttStream, strlen(xmlAttStream), utfXmlString, utfXmlLen) != 0)
	{
		tc_printf_debug("!!!!!!!!!!!! WARNNING: gbk2uft !!!!!!!!!!!!\n");
		return SC_ErrUnknow;
	}

	tcDelXmlNode(utfXmlString, xmlString, xmlLen, NULL);

#else
	if(gbk2utf(xmlAttStream, strlen(xmlAttStream), xmlString, xmlLen) != 0)
	{
		tc_printf_debug("!!!!!!!!!!!! WARNNING: gbk2uft !!!!!!!!!!!!\n");
		return SC_ErrUnknow;
	}

#endif

	return SC_ErrSuccess;
}

/*
 * 字符串分析，从形如"root//node1//node2//node3#0"的字符串中
 * 解析出key值"root//node1//node2//node3“和类型nValueType=2
 */
int tcAnalysisKeyTypeString(char *sourKeyString, char *outKey, int *valueType)
{
	if((sourKeyString == NULL) || (outKey == NULL) || (valueType == NULL))
	{
		return SC_ErrParamerErr;
	}

	char *pShape = strrchr(sourKeyString, '#');
	if(pShape == NULL)
	{
		return SC_ErrParamerErr;
	}

	char intString[4] = "";
	memcpy(outKey, sourKeyString, pShape-sourKeyString);
	memcpy(intString, pShape+1, strlen(pShape));
	*valueType = atoi(intString);

	return SC_ErrSuccess;
}

/*
 * 根据key值和类型nValueType来完成config参数的设置
 */
int tcSetValueByKeyType(char* szKey, void *pValue, int nValueType)
{
	if(szKey == NULL || pValue == NULL)
		return SC_ErrParamerErr;

	HTrafficSDK pTrafficSDK = NULL;
	HSCConfig pConfig = NULL;
	if(((pTrafficSDK = getTrafficSDK()) == NULL) || ((pConfig = getHSCConfig()) == NULL))
		return SC_ErrNoResources;

	//utf8转gbk后再进行设置参数
	char gbkKey[256] = "";
	char gbkValue[256] = "";
	if((utf2gbk(szKey, strlen(szKey), gbkKey, sizeof(gbkKey)) != 0) ||
			(utf2gbk(pValue, strlen(pValue), gbkValue, sizeof(gbkValue)) != 0))
	{
		tc_printf_debug("----------转码失败---------\n");
	}

	if(nValueType == CT_INT || nValueType == CT_ENUM || nValueType == CT_BOOL)
	{
		int nInt = atoi((char*)gbkValue);
		return TrafficSDK_SetHSCConfigKeyValue(pTrafficSDK, pConfig, gbkKey, &nInt, sizeof(nInt), nValueType, NULL, 0);
	}
	else if(nValueType == CT_FLOAT)
	{
		float fFloat = atof((char*)gbkValue);
		return TrafficSDK_SetHSCConfigKeyValue(pTrafficSDK, pConfig, gbkKey, &fFloat, sizeof(fFloat), nValueType, NULL, 0);
	}
	else if(nValueType == CT_STRING)
	{
		return TrafficSDK_SetHSCConfigKeyValue(pTrafficSDK, pConfig, gbkKey, gbkValue, strlen(gbkValue), nValueType, NULL, 0);
	}
	else if(nValueType == CT_TIME)
	{
		ScSystemTime scTime;
		memset(&scTime, 0, sizeof(scTime));
		if(tcString2Time(&scTime, (char*)gbkValue) == SC_ErrSuccess)
		{
			return TrafficSDK_SetHSCConfigKeyValue(pTrafficSDK, pConfig, gbkKey, &scTime, sizeof(scTime), nValueType, NULL, 0);
		}
		return SC_ErrUnknow;
	}

	return SC_ErrUnknow;
}



void tcTrafficResult(int nResultType, void* pResultData,long  nDataLen, unsigned int dwUser)
{
	//转码操作gbk->utf8
	char outbuf[1024*5] = "";
	if(gbk2utf(pResultData, strlen(pResultData), outbuf, sizeof(outbuf)) != 0)
	{
		tc_printf_debug("----------转码失败---------\n");
	}

	EnQueue(&trafficQueue, outbuf);
	return;
}


/**
 * 从xml流中删除已经在settingsConfig.xml中出现过的key值,并输出到outXmlBuf中
 * 目前只是删除了"root/基础配置", "root/功能配置", "root/高级配置"
 */
int tcDelXmlNode(char *inXmlString, char *outXmlBuf, int bufLen, char *iniPath)
{
	mxml_node_t	*xmlRoot = mxmlSAXLoadString(NULL, inXmlString, NULL, NULL, NULL);

//	char *delNodeArray[] = {"root/基础配置", "root/功能配置", "root/高级配置"};
	char *delNodeArray[] = {"root/基础配置/"};
	int nIndex = 0;
	int nIndexSize = sizeof(delNodeArray)/sizeof(delNodeArray[0]);
	for(nIndex = 0; nIndex < nIndexSize; nIndex++)
	{
			mxml_node_t *tmpNode = mxmlFindPath(xmlRoot, delNodeArray[nIndex]);
			if(tmpNode == NULL)
			{
			//	printf("------Could not found node: %s------\n", szKey);
				continue;
			}
			printf("------DEL node: %s------\n", delNodeArray[nIndex]);
			mxmlDelete(tmpNode);
	}

	mxmlSaveString(xmlRoot, outXmlBuf, bufLen, NULL);
	return SC_ErrSuccess;
}


ScErr tcAddValueByReferer(const char *refererInfo, HttpConn* curConn)
{
	HTrafficSDK pTrafficSDK = NULL;
	HSCConfig pConfig = NULL;

	if( ((pTrafficSDK = getTrafficSDK()) == NULL) ||
			((pConfig = getHSCConfig()) == NULL) )
	{
		return SC_ErrNoResources;
	}

	mxml_node_t *pTrafficMxml = NULL;
	if((pTrafficMxml = getTrafficMxml()) == NULL)
	{
		return SC_ErrUnknow;
	}

    mxml_node_t *refererNode = NULL;
    mxml_node_t *itemConfigNode = NULL;
    if((refererNode = mxmlFindElement(pTrafficMxml, pTrafficMxml, refererInfo, NULL, NULL, MXML_DESCEND)) != NULL)
	{
    	itemConfigNode = mxmlGetFirstChild(refererNode);
	}

    while(itemConfigNode != NULL)
    {
		if(mxmlGetType(itemConfigNode) == MXML_ELEMENT)
		{
			 const char *keyId = mxmlElementGetAttr(itemConfigNode, "keyId");
			 const char *keyName = mxmlElementGetAttr(itemConfigNode, "keyName");
			 const char *valueType = mxmlElementGetAttr(itemConfigNode, "valueType");
			 const char *keySource = mxmlElementGetAttr(itemConfigNode, "keySource");

			 if((keyId != NULL) && (keyName != NULL) && (valueType != NULL) && (keySource != NULL))
			 {
				if(strcmp(keySource, "SDK") != 0)
				{
					//mxmlLoadFile操作gbk格式的文件，会返回空，所以暂时只能自己转码
					char gbkKey[256] = "";
					char szKey[256] = "";
					memcpy(szKey, keyName, strlen(keyName));
					if(utf2gbk(szKey, strlen(szKey), gbkKey, sizeof(gbkKey)) == 0) //utf转gbk转码成功
					{
						int nValueType = atoi(valueType);
						if(nValueType == CT_INT)
						{
							int nInt = 0;
							if(scCfgGetAttribValue_int(pConfig, gbkKey, &nInt) == SC_ErrSuccess ||
									scCfgGetAttribDefault_int(pConfig, gbkKey, &nInt) == SC_ErrSuccess)
							{
								tc_printf_debug("----------------------keyName=%s, nValueType=%d, value=%d-------------------------\n", gbkKey, nValueType, nInt);
								espSetFeedback(curConn, keyId, "%d", nInt);
							}
							else
							{
								tc_printf_debug("----------------------keyName=%s, return NULL -------------------------\n");
								espSetFeedback(curConn, keyId, "");
							}

						}
						else if(nValueType == CT_ENUM)
						{
							int nEnum = 0;
							if(scCfgGetAttribValue_enum(pConfig, gbkKey, &nEnum) == SC_ErrSuccess ||
									scCfgGetAttribDefault_enum(pConfig, gbkKey, &nEnum) == SC_ErrSuccess)
							{
								tc_printf_debug("----------------------keyName=%s, nValueType=%d, value=%d-------------------------\n", gbkKey, nValueType, nEnum);
								espSetFeedback(curConn, keyId, "%d", nEnum);
							}
							else
							{
								tc_printf_debug("----------------------keyName=%s, return NULL -------------------------\n");
								espSetFeedback(curConn, keyId, "");
							}
						}
						else if(nValueType == CT_BOOL)
						{
							int nBool = 0;
							if(scCfgGetAttribValue_bool(pConfig, gbkKey, &nBool) == SC_ErrSuccess ||
									scCfgGetAttribDefault_bool(pConfig, gbkKey, &nBool) == SC_ErrSuccess)
							{
								tc_printf_debug("----------------------keyName=%s, nValueType=%d, value=%d-------------------------\n", gbkKey, nValueType, nBool);
								espSetFeedback(curConn, keyId, "%d", nBool);
							}
							else
							{
								tc_printf_debug("----------------------keyName=%s, return NULL -------------------------\n");
								espSetFeedback(curConn, keyId, "");
							}

						}
						else if(nValueType == CT_FLOAT)
						{
							float fFloat = 0.0f;
							if(scCfgGetAttribValue_float(pConfig, gbkKey, &fFloat) == SC_ErrSuccess ||
									scCfgGetAttribDefault_float(pConfig, gbkKey, &fFloat) == SC_ErrSuccess)
							{
								tc_printf_debug("----------------------keyName=%s, nValueType=%d, value=%f-------------------------\n", gbkKey, nValueType, fFloat);
								espSetFeedback(curConn, keyId, "%f", fFloat);
							}
							else
							{
								tc_printf_debug("----------------------keyName=%s, return NULL -------------------------\n");
								espSetFeedback(curConn, keyId, "");
							}
						}
						else if(nValueType == CT_STRING)
						{
							char sStr[128] = "";
							if(scCfgGetAttribValue_string(pConfig, gbkKey, sStr) != SC_ErrSuccess)
							{
								scCfgGetAttribDefault_string(pConfig, gbkKey, sStr);
							}
							tc_printf_debug("----------------------keyName=%s, nValueType=%d, value=%s-------------------------\n", gbkKey, nValueType, sStr);
							//转码操作gbk->utf8
							char outbuf[128] = "";
							if(gbk2utf(sStr, strlen(sStr), outbuf, sizeof(outbuf)) != 0)
							{
								tc_printf_debug("----------转码失败---------\n");
							}
							//espSetFeedback(curConn, keyId, outbuf);
							//espSetFeedback(curConn, keyId,"%s",outbuf);
							espSetFeedbackWithType(curConn, keyId,CT_STRING,"%s",outbuf);
						}
						else if(nValueType == CT_TIME)
						{
							ScSystemTime scTime;
							memset(&scTime, 0, sizeof(scTime));
							if(scCfgGetAttribValue_time(pConfig, gbkKey, &scTime) != SC_ErrSuccess)
							{
								scCfgGetAttribDefault_time(pConfig, gbkKey, &scTime);
							}
							tc_printf_debug("---------------------Hour:%d, Minute:%d, Second:%d----------------\n", scTime.wHour, scTime.wMinute, scTime.wSecond);
							espSetFeedback(curConn, keyId, "%d:%d", scTime.wHour, scTime.wMinute);
						}
					}
				}
				else if(strcmp(keySource, "SDK") == 0)
				{
					//如果是获取IP信息
					if(strcmp(keyId, "15") == 0)
					{
						SysIVENetInfo netInfo;
						memset(&netInfo, 0, sizeof(netInfo));
						unsigned int valueLen = 0;
						if(TrafficSDK_GetData(pTrafficSDK, KEY_GET_NET_INFO, &netInfo, &valueLen, NULL, 0) == SC_ErrSuccess)
						{
							tc_printf_debug("--------------------------------------------------------------\n");
							tc_printf_debug("szIP = %s\n", netInfo.szIP);
							tc_printf_debug("szMask = %s\n", netInfo.szMask);
							tc_printf_debug("szGateway = %s\n", netInfo.szGateway);
							tc_printf_debug("--------------------------------------------------------------\n");

							espSetFeedback(curConn, "15", "%s", netInfo.szIP);
							espSetFeedback(curConn, "16", "%s", netInfo.szMask);
							espSetFeedback(curConn, "17", "%s", netInfo.szGateway);
						}
					}
					else if(strcmp(keyId, "21") == 0)
					{
						SysIVENetInfo netInfo;
						memset(&netInfo, 0, sizeof(netInfo));
						unsigned int valueLen = 0;
						ScErr errRet;
						if((errRet = TrafficSDK_GetData(pTrafficSDK, KEY_GET_OPS_PARENT_IPPORT, &netInfo, &valueLen, NULL, 0)) == SC_ErrSuccess)
						{
							tc_printf_debug("--------------------------------------------------------------\n");
							tc_printf_debug("szIP = %s\n", netInfo.szIP);
							tc_printf_debug("nPort = %s\n", netInfo.nPort);
							tc_printf_debug("--------------------------------------------------------------\n");
							espSetFeedback(curConn, "21", "%s", netInfo.szIP);
							espSetFeedback(curConn, "22", "%d", netInfo.nPort);
						}
					}
					else if(strcmp(keyId, "1") == 0)
					{
						BasicInfo basicInfo;
						memset(&basicInfo, 0, sizeof(basicInfo));
						unsigned int valenLen = 0;
						if(TrafficSDK_GetData(pTrafficSDK, KEY_GET_BASIC_INFO, &basicInfo, &valenLen, NULL, 0) == SC_ErrSuccess)
						{
							char gbkKey[1024] = "";
							char szKey[1024] = "";


							memset(gbkKey,0,sizeof(gbkKey));
							memset(szKey,0,sizeof(szKey));
							strncpy(gbkKey,basicInfo.szAuthorizedStatus,sizeof(gbkKey));
							if(gbk2utf(gbkKey, strlen(gbkKey), szKey, sizeof(szKey)) == 0) //utf转gbk转码成功
							{
								strncpy(basicInfo.szAuthorizedStatus,szKey,sizeof(basicInfo.szAuthorizedStatus));
							}

							memset(gbkKey,0,sizeof(gbkKey));
							memset(szKey,0,sizeof(szKey));
							strncpy(gbkKey,basicInfo.szAuthorizedInfo,sizeof(gbkKey));
							if(gbk2utf(gbkKey, strlen(gbkKey), szKey, sizeof(szKey)) == 0) //utf转gbk转码成功
							{
								strncpy(basicInfo.szAuthorizedInfo,szKey,sizeof(basicInfo.szAuthorizedInfo));
							}

							tc_printf_debug("--------------------------------------------------------------\n");
							tc_printf_debug("szResolution = %s\n", basicInfo.szResolution);
							tc_printf_debug("szHardwareVersion = %s\n", basicInfo.szHardwareVersion);
							tc_printf_debug("szFPGAVersion = %s\n", basicInfo.szFPGAVersion);
							tc_printf_debug("szSysVersion = %s\n", basicInfo.szSysVersion);
							tc_printf_debug("szBSPVersion = %s\n", basicInfo.szBSPVersion);
							tc_printf_debug("szSoftwareVersion = %s\n", basicInfo.szSoftwareVersion);
							tc_printf_debug("szAlgVersion = %s\n", basicInfo.szAlgVersion);
							tc_printf_debug("szDeviceID = %s\n", basicInfo.szDeviceID);
							tc_printf_debug("szAuthorizedStatus = %s\n", basicInfo.szAuthorizedStatus);
							tc_printf_debug("szAuthorizedInfo = %s\n", basicInfo.szAuthorizedInfo);

							tc_printf_debug("--------------------------------------------------------------\n");

							//espSetFeedback(curConn, "0", basicInfo.szResolution);
							//espSetFeedback(curConn, "1", basicInfo.szHardwareVersion);
							//espSetFeedback(curConn, "2", basicInfo.szFPGAVersion);
							//espSetFeedback(curConn, "3", basicInfo.szSysVersion);
							//espSetFeedback(curConn, "4", basicInfo.szBSPVersion);
							//espSetFeedback(curConn, "5", basicInfo.szSoftwareVersion);
							//espSetFeedback(curConn, "6", basicInfo.szAlgVersion);
							//espSetFeedback(curConn, "7", basicInfo.szDeviceID);
							//espSetFeedback(curConn, "8", basicInfo.szAuthorizedStatus);
							//espSetFeedback(curConn, "9", basicInfo.szAuthorizedInfo);



							espSetFeedbackWithType(curConn, "0", CT_STRING, "%s", basicInfo.szResolution);
							espSetFeedbackWithType(curConn, "1", CT_STRING, "%s", basicInfo.szHardwareVersion);
							espSetFeedbackWithType(curConn, "2", CT_STRING, "%s", basicInfo.szFPGAVersion);
							espSetFeedbackWithType(curConn, "3", CT_STRING, "%s", basicInfo.szSysVersion);
							espSetFeedbackWithType(curConn, "4", CT_STRING, "%s", basicInfo.szBSPVersion);
							espSetFeedbackWithType(curConn, "5", CT_STRING, "%s", basicInfo.szSoftwareVersion);
							espSetFeedbackWithType(curConn, "6", CT_STRING, "%s", basicInfo.szAlgVersion);
							espSetFeedbackWithType(curConn, "7", CT_STRING, "%s", basicInfo.szDeviceID);
							espSetFeedbackWithType(curConn, "8", CT_STRING, "%s", basicInfo.szAuthorizedStatus);
							espSetFeedbackWithType(curConn, "9", CT_STRING, "%s", basicInfo.szAuthorizedInfo);
							espSetFeedbackWithType(curConn, "10", CT_STRING, "%s", basicInfo.szDeviceTypeDesc);


						}
					}
					else if(strcmp(keyId, "146") == 0)
					{
						StorageDevInfos DevInfo;
						memset(&DevInfo, 0, sizeof(DevInfo));
						unsigned int valenLen = 0;
						if(TrafficSDK_GetData(pTrafficSDK, KEY_GET_STORAGE_DEV_INFO, &DevInfo, &valenLen, NULL, 0) == SC_ErrSuccess)
						{
							espSetFeedback(curConn, "146", DevInfo.aStorageDevInfo[0].szPath);
							if (DevInfo.nDevCount == 1)
							{
								espSetFeedback(curConn, "146001", "%d", 1);
								espSetFeedback(curConn, "147", "%0.2f", DevInfo.aStorageDevInfo[0].dfTotalSize);
								espSetFeedback(curConn, "148", "%0.2f", DevInfo.aStorageDevInfo[0].dfLeftSize);
								espSetFeedback(curConn, "149", "%0.2f", DevInfo.aStorageDevInfo[0].aPartitionInfo[0].dfTotalSize);
								espSetFeedback(curConn, "150", "%0.2f", DevInfo.aStorageDevInfo[0].aPartitionInfo[0].dfLeftSize);
								espSetFeedback(curConn, "151", "%0.2f", DevInfo.aStorageDevInfo[0].aPartitionInfo[1].dfTotalSize);
								espSetFeedback(curConn, "152", "%0.2f", DevInfo.aStorageDevInfo[0].aPartitionInfo[1].dfLeftSize);
							}
							else if (DevInfo.nDevCount == 2)
							{
								espSetFeedback(curConn, "146001", "%d", 2);
								float fTotalSize = DevInfo.aStorageDevInfo[0].dfTotalSize + DevInfo.aStorageDevInfo[1].dfTotalSize;
								float fTotalLeft = DevInfo.aStorageDevInfo[0].dfLeftSize + DevInfo.aStorageDevInfo[1].dfLeftSize;
								espSetFeedback(curConn, "147", "%0.2f", fTotalSize);
								espSetFeedback(curConn, "148", "%0.2f", fTotalLeft);
								espSetFeedback(curConn, "149", "%0.2f", DevInfo.aStorageDevInfo[0].dfTotalSize);
								espSetFeedback(curConn, "150", "%0.2f", DevInfo.aStorageDevInfo[0].dfLeftSize);
								espSetFeedback(curConn, "151", "%0.2f", DevInfo.aStorageDevInfo[1].dfTotalSize);
								espSetFeedback(curConn, "152", "%0.2f", DevInfo.aStorageDevInfo[1].dfLeftSize);				
							}
							else
							{
								espSetFeedback(curConn, "146001", "%d", 0);
							}
						}
					}
					else if(strcmp(keyId, "920") == 0)
					{
						SysIVEAdvancedNetInfo netInfo;
						memset(&netInfo, 0, sizeof(netInfo));
						unsigned int valueLen = 0;
						if(TrafficSDK_GetData(pTrafficSDK, KEY_GET_ADVANCED_NET_INFO, &netInfo, &valueLen, NULL, 0) == SC_ErrSuccess)
						{
							tc_printf_debug("--------------------------------------------------------------\n");
							tc_printf_debug("szLocalMAC = %s\n", netInfo.szLocalMAC);
							tc_printf_debug("nMTU = %d\n", netInfo.nMTU);
							tc_printf_debug("szDNSServer = %s\n", netInfo.szDNSServer);
							tc_printf_debug("--------------------------------------------------------------\n");
							espSetFeedback(curConn, "920", "%s", netInfo.szLocalMAC);
							espSetFeedback(curConn, "921", "%d", netInfo.nMTU);
							espSetFeedback(curConn, "922", "%s", netInfo.szDNSServer);
						}
					}
					else if (strcmp(keyId, "112101") == 0)
					{
						SysIVENetInfo netInfo;//复用一下已有结构体
						memset(&netInfo, 0, sizeof(netInfo));
						unsigned int valueLen = 0;
						if (TrafficSDK_GetData(pTrafficSDK, KEY_3G4G_INFO_GET, &netInfo, &valueLen, NULL, 0) == SC_ErrSuccess)
						{
							tc_printf_debug("--------------------------------------------------------------\n");
							tc_printf_debug("szIP = %s\n", netInfo.szIP);
							tc_printf_debug("szMask = %s\n", netInfo.szMask);
							tc_printf_debug("--------------------------------------------------------------\n");
							espSetFeedback(curConn, "112101", "%s", netInfo.szIP);
							espSetFeedback(curConn, "112102", "%s", netInfo.szMask);
						}
					}
				}
			 }
		}

        itemConfigNode = mxmlGetNextSibling(itemConfigNode);
    }

	return SC_ErrSuccess;
}


ScErr tcAddAttributeByReferer(const char *refererInfo, HttpConn* curConn)
{
	HTrafficSDK pTrafficSDK = NULL;
	HSCConfig pConfig = NULL;

	if( ((pTrafficSDK = getTrafficSDK()) == NULL) ||
			((pConfig = getHSCConfig()) == NULL) )
	{
		return SC_ErrNoResources;
	}

	char rangeBuf[128] = "";

	mxml_node_t *pTrafficMxml = NULL;
	if((pTrafficMxml = getTrafficMxml()) == NULL)
	{
		return SC_ErrUnknow;
	}

    mxml_node_t *refererNode = NULL;
    mxml_node_t *itemConfigNode = NULL;
    if((refererNode = mxmlFindElement(pTrafficMxml, pTrafficMxml, refererInfo, NULL, NULL, MXML_DESCEND)) != NULL)
	{
    	itemConfigNode = mxmlGetFirstChild(refererNode);
	}

    while(itemConfigNode != NULL)
    {
		if(mxmlGetType(itemConfigNode) == MXML_ELEMENT)
		{
			 const char *keyId = mxmlElementGetAttr(itemConfigNode, "keyId");
			 const char *keyName = mxmlElementGetAttr(itemConfigNode, "keyName");
			 const char *valueType = mxmlElementGetAttr(itemConfigNode, "valueType");
			 const char *keySource = mxmlElementGetAttr(itemConfigNode, "keySource");

			 if((keyId != NULL) && (keyName != NULL) && (valueType != NULL) && (keySource != NULL))
			 {
				 if(strcmp(keySource, "Config") == 0)
				 {
					//mxmlLoadFile操作gbk格式的文件，会返回空，所以暂时只能自己转码
					char gbkKey[256] = "";
					char szKey[256] = "";
					memcpy(szKey, keyName, strlen(keyName));
					if(utf2gbk(szKey, strlen(szKey), gbkKey, sizeof(gbkKey)) == 0) //utf转gbk转码成功
					{
						int nValueType = atoi(valueType);
						if(nValueType == CT_INT)
						{
							ScAttribIntRange rangeInt;
							memset(&rangeInt, 0, sizeof(rangeInt));
							if(scCfgGetAttribRange_int(pConfig, gbkKey, &rangeInt) == SC_ErrSuccess)
							{
								sprintf(rangeBuf, "范围：%d - %d", rangeInt.nValMin, rangeInt.nValMax);
							}
							tc_printf_debug("----------------------CT_INT: keyId=%s, rangeBuf=%s-------------------------\n", gbkKey, rangeBuf);
							espSetFeedback(curConn, keyId, rangeBuf);
						}
						else if(nValueType == CT_ENUM)
						{

						}
						else if(nValueType == CT_BOOL)
						{

						}
						else if(nValueType == CT_FLOAT)
						{
							ScAttribFloatRange rangeFloat;
							memset(&rangeFloat, 0, sizeof(rangeFloat));
							if(scCfgGetAttribRange_float(pConfig, gbkKey, &rangeFloat) == SC_ErrSuccess)
							{
								sprintf(rangeBuf, "范围：%f - %f", rangeFloat.fltValMin, rangeFloat.fltValMax);
							}
							tc_printf_debug("----------------------CT_FLOAT: keyId=%s, rangeBuf=%s-------------------------\n", gbkKey, rangeBuf);
							espSetFeedback(curConn, keyId, rangeBuf);
						}
						else if(nValueType == CT_STRING)
						{
							int nStrLength = 0;
							if(scCfgGetAttribRange_string(pConfig, gbkKey, &nStrLength) == SC_ErrSuccess)
							{
								sprintf(rangeBuf, "字符串长度限制：%d", nStrLength);
							}
							tc_printf_debug("----------------------CT_STRING: szKey=%s, rangeBuf=%s-------------------------\n", gbkKey, rangeBuf);
							espSetFeedback(curConn, keyId, rangeBuf);
						}
						else if(nValueType == CT_TIME)
						{

						}
					}
				 }
			 }
		}
		itemConfigNode = mxmlGetNextSibling(itemConfigNode);
    }
	return SC_ErrSuccess;
}

#endif