handlemsg.cpp

来自「液晶电视完整代码可实现人机界面」· C++ 代码 · 共 2,266 行 · 第 1/4 页

//------------------------------------------------------------------- 
//文件名：HandleMsg.cpp
//描  述：报文转换
//------------------------------------------------------------------- 

#include "handlemsg.h"

typedef struct _ST_ERR_CODE 
{
	int  iErrCode;
	char strErrMsg[80];
} ST_ERR_CODE;

ST_ERR_CODE  ErrorCode[]={
	{ERR_SYSTEM,		"System Error"},
	{ERR_DB_OPER, 		"Database operation error"},
	{ERR_NOTFOUND,		"Record not found"}, 
	{ERR_FUNC_NOTLOAD,	"Function not loaded"},
	{CFG_FILE_ERROR,	"配置文件错"},
	{PARSER_ERROR,		"格式转换失败"},
	{SEND_MBFE_ERROR,	"发送MBFE失败"},
	{FILE_OPEN_ERROR,	"文件打开错"},
	{FILE_OPRT_ERROR,	"文件操作错或内容错误 "},
	{ERR_PARAM,		"参数错误 "},
	{NET_CONN_ERROR,	"网络连接错误 "},
	{NET_SEND_ERROR,	"网络发送错误 "},
	{NET_RECV_ERROR,	"网络接收错误 "},
	{ERR_NOT_DIRECT_TRANS,  "非直联交易"},
	{ERR_KEYI_CZ,           "可疑重账"},
	{ERR_DUI_ZHANG,		"对帐"},
	{ERR_GET_COMMSEQNO,	"取报文标识号错误"},
	{ERR_GET_MSGREFNO,	"取报文参考号错误"},
	{9999,			"Unknow Error"}
};


BOOL DynFuncList::AddFunc(struct DynFunc dynfunc)
{
	if ( funcno >= sizeoflist ){
		struct DynFunc *funclist1 = new DynFunc[sizeoflist + 20];
		if ( funclist1 == NULL )
			return FALSE;
		
		for ( int i=0; i<sizeoflist; i++ ){
			memcpy( funclist1[i].func_name , funclist[i].func_name, FUNCNAMESIZE + 1 );
			funclist1[i].func_type = funclist[i].func_type;
			funclist1[i].func_addr = funclist[i].func_addr;
			funclist1[i].parano = funclist[i].parano;
		}

		if ( funclist )
			delete funclist;
		funclist = funclist1;
		sizeoflist += 20;
	}
	memcpy( funclist[funcno].func_name ,dynfunc.func_name, FUNCNAMESIZE + 1);
	funclist[funcno].func_type = dynfunc.func_type;
	funclist[funcno].func_addr = dynfunc.func_addr;
	funclist[funcno].parano = dynfunc.parano;
	funcno++;
	return TRUE;
}


BOOL DynFuncList::AddFunc(char *funcname, char functype, int (*funcaddr)(), int parano)
{
	if ( funcno >= sizeoflist ){
		struct DynFunc *funclist1 = new DynFunc[sizeoflist + 20];
		if ( funclist1 == NULL )
		{
			printf("funclist1 is NULL\n");
			return FALSE;
		}
		for ( int i=0; i<sizeoflist; i++ ){
			memcpy( funclist1[i].func_name , funclist[i].func_name, FUNCNAMESIZE + 1 );
			funclist1[i].func_type = funclist[i].func_type;
			funclist1[i].func_addr = funclist[i].func_addr;
			funclist1[i].parano = funclist[i].parano;
		}

		if ( funclist )
			delete funclist;
		funclist = funclist1;
		sizeoflist += 20;
	}
	memset( funclist[funcno].func_name, 0, FUNCNAMESIZE );
	strncpy( funclist[funcno].func_name ,funcname, FUNCNAMESIZE + 1);
	funclist[funcno].func_type = functype;
	funclist[funcno].func_addr = funcaddr;
	funclist[funcno].parano = parano;
	funcno++;
	return TRUE;
}

int DynFuncList::FuncPos(char *funcname)
{
	char *ptr = strstr(funcname, "(");
	char buf[FUNCNAMESIZE+1];

	memset(buf, 0, FUNCNAMESIZE);
	if ( ptr != NULL && ptr-funcname <= FUNCNAMESIZE ){
		memcpy( buf, funcname, ptr-funcname );
		buf[ptr-funcname] = 0;
	} else
		return -1;
	for ( int i=0; i<funcno; i++ ){
		if ( memcmp(funclist[i].func_name ,buf, FUNCNAMESIZE ) == 0 )
			return i;
	}
	return -1;
}
	
void HandleData::PrintIntStr( )
{
	cout << interparser->XMLToString() << endl;
}

void HandleData::GetPara( char *func_para, int *argc, char argv[][M_MAX_PARA_LEN] )
{
	char *ptr = strstr(func_para, "(");
	char buf[M_MAX_PARA_LEN + 1];
	char value[M_MAX_ITEMCONTENT_LEN + 1];
	int i;

	// Log(LOGSTEP, "[In GetPara()], ptr: ",  ptr) ;
	*argc = 0;
	while ( ptr )
	{

		for ( i=0; i< M_MAX_PARA_LEN && ptr[i] && ptr[i] != ',' && ptr[i] != ')'; i++ )
		{
			buf[i] = ptr[i];
		}
		buf[i] = 0;
		TrimDeli( buf );			// 删除空格等分割符

		if ( strlen(buf) )
		{
			if ( SelfData( buf ) ) // 需要从内部流取数据
			{		
				GetSelfData( buf, value );
				memset( buf, 0, M_MAX_PARA_LEN+1 );
				memcpy( buf, value, M_MAX_PARA_LEN );
			}
			strcpy( argv[(*argc)++], buf );
		} 
		
		if ( ptr[i] == ',' )
		{	// 存在下一参数
			ptr += i;		
			ptr++;
		} else
			ptr = 0;
	}
}


// 从内部流中获取数据
BOOL HandleData::GetSelfData( char *refer, char *value )
{
	if ( interparser->GetValuesByFullName( refer, value ) )
	{
		return FALSE;
	}
	else
	{
		return TRUE;
	}
}


void HandleData::Rootcode( char *txcode )
{
	memcpy(rootcode, txcode, TXCODELEN);  // 交易码 
	rootcode[TXCODELEN] = 0;
}

int HandleData::SetEnv( char *txcode, char *XMLConfigFileName, const DynFuncList &dynfunclist)
{

	if( strlen(txcode) >= TXCODELEN)
		memcpy(rootcode, txcode, TXCODELEN);  // 交易码 
	else
		strcpy( rootcode , txcode );
	rootcode[TXCODELEN] = 0;
	
	try 
	{
		parser = new CXMLParser;		// 格式流
		parser->InitConfig(XMLConfigFileName);	// 加载配置文件

		for ( int i=0; i < dynfunclist.funcno; i++ )
		{
			int_dynfunclist.AddFunc( dynfunclist.funclist[i] );		// 注册功能函数列表
		}
	}
	catch ( ... )
	{
		printf("Set xml_env failed!\n");
		return -1;
	}
	return 0;
}

int HandleData::RunFunc( char *func, char *input, int &len, char *output )
{
	int position = int_dynfunclist.FuncPos( func );     // 确定动态函数位置
	if ( position < 0 ) 	// 无此函数注册
	{
		Log( LOGERROR, "No pre_func:", func );
		return(ERR_FUNC_NOTLOAD);
	}

	Log( LOGSTEP, "[In RunFunc()] Run function:", func );

	int fargc = FUNCS[position].parano;
	char fargv[M_MAX_PARA_NUM][M_MAX_PARA_LEN] ;
	int tmplen = inputlen;
	int ret = 0;

	GetPara( func, &fargc, fargv );

	for (int i=0; i<fargc; i++)
	{
		Log( LOGSTEP, "[In RunFunc()]Parameter: ", fargv[i]);
	}


	if ( FUNCS[position].func_type == M_DBFUNC )
	{
		int (*dbfuncp)(void *,int,char[M_MAX_PARA_NUM][M_MAX_PARA_LEN],char *,int *,char *);
		dbfuncp = (int (*)(void *,int,char[M_MAX_PARA_NUM][M_MAX_PARA_LEN],char *,int *,char *))FUNCS[position].func_addr;
		if ( dbfuncp )
		{
			ret = dbfuncp( db_proc, fargc, fargv, input, &tmplen, output );
		}
		else
		{
			ret = ERR_SYSTEM;
		}
	} 
	else 
	{
		int (*funcp)(int,char[M_MAX_PARA_NUM][M_MAX_PARA_LEN],char *,int *,char *);
		funcp = (int (*)(int,char[M_MAX_PARA_NUM][M_MAX_PARA_LEN],char *,int *,char *))FUNCS[position].func_addr;
		if ( funcp )
		{
			ret = funcp( fargc, fargv, input, &tmplen, output );
		}
		else
		{
			ret = ERR_SYSTEM;
		}
	}
	
	if ( !ret )
	{		// 执行动态处理函数成功
		Log(LOGSTEP, "[In RunFunc()] Function's output", output);
		len = tmplen;
		// return 0;
		return M_SUCCESS;
	}
	// Modified by HCH -- 2002.03.25
	// return 2;			// 执行动态处理函数失败
	else 
	{
		printf("[%s - %d]RunFunc() [%s] return: [%d] \n", __FILE__, __LINE__, func, ret);
		Log(LOGSTEP, "[In RunFunc()] Run function fail", "return");
		errno = ret;
		return(ret);
	}
}

// 域处理函数，输入函数、域值, 输出处理后的域值
void HandleData::ContentFunc( char *func, char *input, char *output )
{
	char outvalue[M_MAX_OUTPUT_LEN + 1];
	int len = sizeof(input);
	char strErrMsg[M_MAX_ERRMSG_LEN + 1];

	memset( outvalue , 0 , sizeof( outvalue));
	printf("[%s  %d]Function [%s]'s input[%s] \n", __FILE__, __LINE__, func, input);
	int Ret = RunFunc( func, input, len, outvalue ) ;
	printf("[%s - %d]RunFunc() return code: [%d]\n", __FILE__, __LINE__, Ret);

	if (Ret != 0)
	{
		GetErrMsg(Ret, strErrMsg);

		printf("[%s - %d]:Run function failed: [%s]\n", __FILE__, __LINE__, strErrMsg);
		if (Ret < 0)
			printf("Ret=[%d] strErrMsg=[%s]\n",Ret,strErrMsg);
		else 
		{
			// Don't throw exception if Ret > 0
			;
		}
	}

	// 输出处理后的域值
	if (len < M_MAX_OUTPUT_LEN ){
		memcpy(output, outvalue, len);
		output[len] = 0;
		printf("[%s  %d]Function [%s]'s output[%s] \n", __FILE__, __LINE__, func, output);
	}
}


// 内容检查函数，输入函数串, 检查发现错误时抛出异常。
void HandleData::CheckFunc( char *func )
{
	char errout[M_MAX_OUTPUT_LEN + 1];
	int len = sizeof(input);
	char strErrMsg[M_MAX_ERRMSG_LEN + 1];

	memset(strErrMsg, 0, sizeof(strErrMsg));

	Log(LOGSTEP, "Now in check function: ", func);

	int ret = RunFunc( func, errout, len, errout ) ;


	char strTemp[80];
	sprintf(strTemp, "[%s - %d]RunFunc() [%s] return code: [%d]\n", __FILE__, __LINE__, func, ret);
	Log(LOGSTEP, "[In Check function]", strTemp);


	if (ret != 0)
	{
		GetErrMsg(ret, strErrMsg);

		printf("[%s - %d]:Run function failed: [%s]\n", __FILE__, __LINE__, strErrMsg);
		if (ret < 0)
		{
			ThrowMsgException(ret, strErrMsg);
		}
		else 
		{
			// Don't throw exception if ret > 0
			;
		}
	}

}


// 格式预处理，输出下一处理码
void HandleData::PreFunc( char *pre_func, char *transcode )
{
	char output[M_MAX_OUTPUT_LEN + 1];			// 临时存放处理码, 防止输出值太长
	int len = inputlen;
	char strErrMsg[M_MAX_ERRMSG_LEN + 1];
	
	int ret = RunFunc( pre_func, input, len, output );

	printf("[%s - %d]RunFunc() [%s] return code: [%d]\n", __FILE__, __LINE__, pre_func, ret);
	if (ret != 0)
	{
		GetErrMsg(ret, strErrMsg);

		printf("[%s - %d]:Run function failed: [%s]\n", __FILE__, __LINE__, strErrMsg);
		if (ret < 0)
			ThrowMsgException(ret, strErrMsg);
		else 
		{
			// Don't throw exception if ret > 0
			;
		}
	}
	// 执行动态预处理函数成功，生成下一处理码
	memcpy(transcode, output, TXCODELEN);
	transcode[TXCODELEN] = 0;
}

// 格式后处理，使用输出流为缺省输入
void HandleData::PostFunc( char *post_func )
{
	char buf[M_MAX_OUTPUT_LEN + 1];			// 格式后处理的输出值
	int len = outdatalen;
	char strErrMsg[M_MAX_ERRMSG_LEN + 1];
	
	printf("[%s - %d]执行后处理函数: [%s] \n", __FILE__, __LINE__, post_func);
	int ret = RunFunc( post_func, output, len, buf );
	printf("[%s - %d]RunFunc() [%s] return code: [%d]\n", __FILE__, __LINE__, post_func, ret);
	if (ret != 0)
	{
		GetErrMsg(ret, strErrMsg);
		printf("[%s - %d]:Run function failed: [%s]\n", __FILE__, __LINE__, strErrMsg);
		if (ret < 0)
			ThrowMsgException(ret, strErrMsg);
		else 
		{
			// Don't throw exception if ret > 0
			;
		}
	}
}

int HandleData::Process( char *in_data, int in_data_len, char *out_data, int &out_data_len )
{
	input = in_data;
	printf("Process inputlen = [%d][%d]\n", in_data_len,inputlen);
	inputlen = in_data_len;
	output = out_data;
	indataptr = 0;
	outdatalen = 0;
	outputsize = out_data_len;
	errno=0;
	
	char	childnode[NODELEN + 1];
	char	rightnode[NODELEN + 1];
	char	dynlibpath[FILEPATHLEN + 1];

	// Added by HCH -- 2002.03.20
	void *fptr, *func;
	int (*funcp)();
	int iOrgFuncNo; 

	Log(LOGSTEP, "Input data:", in_data );

	// Added by HCH -- 2002.03.20
	iOrgFuncNo = int_dynfunclist.funcno;
	try
	{
		status = 0;
		if ( parser )
			parser->reset();
		else
			ThrowMsgException( GENERR , "No parser tool !" );

		if ( interparser )
			delete interparser;
		interparser = new CXMLParser;
		interparser->InitXMLStream();

		// 生成输出流父节点;
		interparser->AddRootNode( XML_INTROOT , 0 );

		// 注册动态函数
		if ( parser->GetRootNode( childnode ) )
			ThrowMsgException( GENERR , "Can't locate root node !" );
		int ret = parser->Locate( FUNC_LIST );
		if ( ret == 0 )
		{
			parser->GetTagAttri(DYNAMIC_FILE, dynlibpath );
			ret = parser->GetChildNode( childnode );
			char item_name[80];
			char item_values[20];
			while ( ret == 0 )
			{
				if ( !ret )
					ret = parser->GetTagAttri( XML_F_NAME , item_name );
				if ( !ret )
					ret = parser->GetTagAttri( "para_num" , item_values );

				// Modified by HCH -- 2002.03.20
				// int_dynfunclist.AddFunc(item_name,	'2', test11, atoi(item_values) );
				// ============== BEGIN ======================
				fptr = dlopen( dynlibpath, RTLD_NOW );
				if ( fptr )
				{
					func = dlsym( fptr, item_name );
					if ( func )
					{
						funcp = (int(*)())func;
						int_dynfunclist.AddFunc(item_name,	'2', funcp, atoi(item_values) );
					}
					else 
					{
						Log( LOGPROMPT, "Get item name error !", item_name);
					}
				}
				else
				{
					printf( "Load dll %s error: %s\n" ,dynlibpath, dlerror());
				}
				// ============== END ======================
				ret = parser->GetRightNode( childnode, rightnode );
			}
		}

		// 如果存在解包定义则进行解包
		Log( LOGSTEP, "Unpacket beginning ...");
		UnpacketData( );

		Log(LOGSTEP, "解包结果: ", interparser->XMLToString() );

		// 如果存在打包定义则进行打包
		Log( LOGSTEP, "Packet beginning ...");
		
		PacketData( );

		Log( LOGSTEP, "Packet end ");
	}
	catch( CommException &e )
	{
		strcpy(errmsg, e.m_strErrText );
		Log( LOGERROR, e.m_strErrText );
		status = -1;
	}
	catch( ... )
	{
		printf("------Catch Exception!------\n");
		status = -1;
	}
	
	// 释放动态加载的函数，并关闭动态库

	out_data_len = outdatalen;

	// Added by HCH -- 2002.03.20
	if ( fptr )
	{
		int_dynfunclist.funcno = iOrgFuncNo;
		dlclose( fptr );
	}

	return status;
}


void HandleData::UnpacketData( )
{
	char	transcode[NODELEN + 1];
	char    buf[M_TMPBUF_LEN + 1];
	char	 strErrMsg[M_MAX_ERRMSG_LEN + 1];

	memset( transcode , 0 , NODELEN + 1 );
	memcpy( transcode, rootcode, NODELEN + 1 );

	// 在配置文件中定位交易码所在位置；
	if ( parser->GetRootNode( buf ) )
		ThrowMsgException( GENERR , "Can't locate root node !" );
	if ( parser->Locate( "transaction", "code", transcode ) )
	{
		sprintf(strErrMsg, "Can't locate unpack-root transcode[%s] !" , transcode );
		ThrowMsgException( GENERR , strErrMsg );
	}
	printf("[%s - %d]transcode: [%s] \n", __FILE__, __LINE__, transcode);

	if ( parser->Locate( REQUEST ) )
		ThrowMsgException( GENERR , "Can't locate unpack-root REQUEST !" );
	//	存在预处理属性, 则根据预处理返回的处理码重新定位
	if ( parser->GetTagAttri( PRE_FUNC , buf ) == 0 )
	{
		// 执行动态预处理函数"buf", 并获得下一处理码"transcode"
		PreFunc( buf, transcode ) ;	
		if ( parser->GetRootNode( buf ) )
		{
			ThrowMsgException( GENERR , "Can't locate root node !" );
		}
		printf("[%s - %d]transcode: [%s] \n", __FILE__, __LINE__, transcode);

		if ( parser->Locate( "transaction", "code", transcode ) )
		{
			sprintf(strErrMsg, "Can't locate unpack transcode[%s] !" , transcode );
			ThrowMsgException( GENERR , strErrMsg );
		}

		if ( parser->Locate( REQUEST ) )
		{
			ThrowMsgException( GENERR , "Can't locate unpack-root REQUEST !" );
		}
	}

	if ( parser->GetTagAttri( M_XML_DELIMITER_TYPE , buf ) )
	{