fmessage.cpp

李刚 请赶快放开我的权限 我上载的源码都是很精湛的,请查阅,qing请加我 [e-mail]必要的话可以和我在线沟通

#include "fmessage.h"
#include <string.h>



#define FAULT -1
#define INTMEMMOVE(NUM1, SEG)\
	CHAR* str = IntToHexString(NUM1, SEG##_LEN); \
	memmove(m_achHead + SEG##_OFFSET, str, SEG##_LEN); \
	delete str;
			 
CFMessage::CFMessage()
{
     m_pchBody = NULL;
     m_pchMess = NULL;
	 BYTE achHead[HEAD_LENGTH];
	 memset(achHead, '0', HEAD_LENGTH);
	 _InitHead(achHead, HEAD_LENGTH);
}

CFMessage::CFMessage(const LPBYTE fmessage, WORD32 length)
{
     m_pchBody = NULL;
     m_pchMess = NULL;
	 memset(m_achHead, '0', HEAD_LENGTH);
     _InitHead(fmessage, length);
     if (length > HEAD_LENGTH)
     {
          length = length - HEAD_LENGTH;
          _InitBody(fmessage+HEAD_LENGTH, length);
     }
}
CFMessage::CFMessage(const LPBYTE head, WORD32 headlen, const LPBYTE body,
WORD32 bodylen)
{
     m_pchBody = NULL;
     m_pchMess = NULL;
	 memset(m_achHead, '0', HEAD_LENGTH);
     _InitHead(head, headlen);
     _InitBody(body, bodylen);
}
CFMessage::CFMessage(const PCHAR head, const PCHAR body)
{
     m_pchBody = NULL;
     m_pchMess = NULL;
	 memset(m_achHead, '0', HEAD_LENGTH);
     _InitHead((LPBYTE)head, strlen(head));
     _InitBody((LPBYTE)body, strlen(body));
}
CFMessage::CFMessage(const PCHAR mess)
{
     m_pchBody = NULL;
     m_pchMess = NULL;
	 memset(m_achHead, '0', HEAD_LENGTH);
     _InitMess((LPBYTE)mess, strlen(mess));
}
CFMessage::CFMessage(const LPBYTE mess)
{
     m_pchBody = NULL;
     m_pchMess = NULL;
	 memset(m_achHead, '0', HEAD_LENGTH);
     _InitMess(mess, strlen((CHAR*)mess));
}
LPBYTE CFMessage::GetBody() const
{
     return m_pchBody;
}
WORD32 CFMessage::GetBodyLength() const
{
     WORD32 n = HexStringToInt((LPBYTE)(m_achHead+MSGLEN_OFFSET), MSGLEN_LEN);
	 return n == FAULT ? FAULT : n-1;
}
BOOL CFMessage::GetCommandMode() const
{
	return m_achHead[CMDMODE_OFFSET]=='0' ? false : true;
}
CHAR* CFMessage::GetCommandCode() const
{
     memmove((CHAR*)m_achCMDCODE, CMDCODE_OFFSET+m_achHead, CMDCODE_LEN);
     return (CHAR*)m_achCMDCODE;
}
CHAR* CFMessage::GetTransCommCode() const
{
     memmove((CHAR*)m_achTRANSCMDCODE, TRANS_CMDCODE_OFFSET+m_achHead,
TRANS_CMDCODE_LEN);
     return (CHAR*)m_achTRANSCMDCODE;
}
CHAR CFMessage::GetFunctionID() const
{
     return m_achHead[FUNCID_OFFSET];
}
LPBYTE CFMessage::GetHead() const
{
     return (LPBYTE)m_achHead;
}
WORD32 CFMessage::GetHeadLength() const
{
     return HEAD_LENGTH;
}
WORD16 CFMessage::GetJournalNum() const
{
     return (WORD16)HexStringToInt((LPBYTE)m_achHead+JOURNALNUM_OFFSET, JOURNALNUM_LEN);
}
WORD16 CFMessage::GetLength() const
{
     return (WORD16)(GetHeadLength() + GetBodyLength());
}
LPBYTE CFMessage::GetMessage() const
{
     memmove(m_pchMess, m_achHead, HEAD_LENGTH);
     memmove(m_pchMess+HEAD_LENGTH, m_pchBody, GetBodyLength());
	 m_pchMess[HEAD_LENGTH+GetBodyLength()] = '\0';
     return m_pchMess;
}
BYTE CFMessage::GetTerminalID() const
{
     return (BYTE)HexStringToInt((LPBYTE)m_achHead+TERMID_OFFSET, TERMID_LEN);
}
BYTE CFMessage::GetUserID() const
{
     return (BYTE)HexStringToInt((LPBYTE)m_achHead+USERID_OFFSET, USERID_LEN);
}
WORD16 CFMessage::GetTimer() const
{
     return (WORD16)HexStringToInt((LPBYTE)m_achHead+TIMER_OFFSET, TIMER_LEN);
}
BYTE CFMessage::GetWindowID() const
{
     return (BYTE)HexStringToInt((LPBYTE)m_achHead+WNDID_OFFSET, WNDID_LEN);
}
VOID CFMessage::_SetBodyLength(WORD32 bodylen)
{
     INTMEMMOVE(bodylen+1, MSGLEN);

	 if (bodylen > 0) m_pchBody[bodylen]='\0';
}
VOID CFMessage::SetCommandCode(const PCHAR commcode)
{
     CHAR ch;
	 for (WORD32 loop=0; loop<CMDCODE_LEN && commcode[loop] != '\0'; loop++)
     {
         if (commcode[loop] <= 'z' && commcode[loop] >= 'a') ch = commcode[loop]+'A'-'a'; 
		 else
			ch = commcode[loop];
		 m_achHead[CMDCODE_OFFSET+loop] = ch;
     }
	 SetTransCommCode(commcode);
}
VOID CFMessage::SetTransCommCode(const PCHAR commcode)
{
     CHAR ch;
     for (WORD32 loop=0; loop<TRANS_CMDCODE_LEN && commcode[loop] != '\0';
loop++)
     {
		 if (commcode[loop] <= 'z' && commcode[loop] >= 'a') ch = commcode[loop]+'A'-'a'; 
		 else
			 ch = commcode[loop];
          m_achHead[TRANS_CMDCODE_OFFSET+loop] = ch;
     }
}
VOID CFMessage::SetCommandMode(BOOL mode)
{
     m_achHead[CMDMODE_OFFSET]= '0'+(mode ? true : false);
}
VOID CFMessage::SetFunctionID(CHAR func)
{
     m_achHead[FUNCID_OFFSET] = func;
}
VOID CFMessage::SetJournalNum(WORD16 journum)
{
    INTMEMMOVE(journum, JOURNALNUM);
}
VOID CFMessage::SetBody(const LPBYTE body, WORD32 len)
{
     _AllocBody(len);
     memmove(m_pchBody, body, len);
     _SetBodyLength(len);
}
VOID CFMessage::SetTerminalID(BYTE termid)
{
	INTMEMMOVE(termid, TERMID);
}
VOID CFMessage::SetUserID(BYTE userid)
{
	INTMEMMOVE(userid, USERID);
}
VOID CFMessage::SetTimer(WORD16 timer)
{
	INTMEMMOVE(timer, TIMER);
}

VOID CFMessage::SetWindowID(BYTE wndid)
{
    INTMEMMOVE(wndid, WNDID);
}
CFMessage::~CFMessage()
{
	 if (m_pchBody != NULL) { delete m_pchBody; m_pchBody = 0; }
	 if (m_pchMess != NULL) delete m_pchMess;
}
VOID CFMessage::_AllocBody(WORD32 space)
{
     if (m_pchBody != NULL)
     {
          delete m_pchBody;
          m_pchBody = NULL;
     }
     if (space > 0)
	 {
          m_pchBody = new BYTE[space+1];
		  m_pchBody[space]='\0';
	 }


     if (m_pchMess != NULL) { delete m_pchMess; m_pchMess = NULL; }
     space = space>0 ? space : 0;
     m_pchMess = new BYTE[space+HEAD_LENGTH+1];
	 m_pchMess[space+HEAD_LENGTH] = '\0';
}
VOID CFMessage::_InitHead(LPBYTE head, WORD32 len)
{
    m_achHead[HEAD_LENGTH]='\0';
	m_achCMDCODE[CMDCODE_LEN]='\0';
	m_achTRANSCMDCODE[TRANS_CMDCODE_LEN]='\0';

	if (len <=0 ) return;
    len = (len>HEAD_LENGTH ? HEAD_LENGTH : len);
    memmove(m_achHead, head, len);
	CleanHead();
	if (m_pchMess != NULL) { delete m_pchMess; m_pchMess = NULL; }
    m_pchMess = new BYTE[GetBodyLength()+HEAD_LENGTH+1];
	m_pchMess[GetBodyLength()+HEAD_LENGTH]='\0';

}
VOID CFMessage::_InitBody(const LPBYTE body, WORD32 len)
{
     if (len <0) return;
     if (len == 0) { _AllocBody(0); return; }

     _AllocBody(len);
     memmove(m_pchBody, body, len);
     _SetBodyLength(len);
}
VOID CFMessage::_InitMess(LPBYTE mess, WORD32 len)
{
     _InitHead(mess, len);
     if (len <= HEAD_LENGTH)
	 {
		 _SetBodyLength(0);
		 return;
	 }
     _InitBody(mess+HEAD_LENGTH, len-HEAD_LENGTH);
}
VOID CFMessage::SetBody(const PCHAR body)
{
     SetBody((LPBYTE)body, strlen(body));
}
VOID CFMessage::CleanHead()
{
	if (GetUserID()		== FAULT) SetUserID(0)		;
	if (GetTerminalID()	== FAULT) SetTerminalID(0)	;
	if (GetWindowID()	== FAULT) SetWindowID(0)	;

	if (GetFunctionID()<'0' && GetFunctionID() > 'z') SetFunctionID('0') ;
	SetCommandMode(GetCommandMode());

	if (GetBodyLength()	== FAULT) _SetBodyLength(0)	;
	if (GetJournalNum()	== FAULT) SetJournalNum(0)	;
	if (GetTimer()	== FAULT) SetTimer(0)	;
}
static WORD32 HexCharToInt(CHAR hexCHAR)
{
	if (hexCHAR >= '0' && hexCHAR <= '9')
		return hexCHAR - '0';

	if (hexCHAR >= 'A' && hexCHAR <= 'F')
		return hexCHAR - 'A' + 10;

	if (hexCHAR >= 'a' && hexCHAR <= 'f')
		return hexCHAR - 'a' + 10;

	return FAULT;
}

CFMessage& CFMessage::operator =(const PCHAR mess)
{
	_InitMess((LPBYTE)mess, strlen(mess));
	return *this;
}
CFMessage& CFMessage::operator =(const CFMessage& fmess)
{
	_InitMess(fmess.GetMessage(), fmess.GetLength());
	return *this;
}
CFMessage::CFMessage(const CFMessage& mess1)
{
	m_pchBody = NULL;
	m_pchMess = NULL;
	 memset(m_achHead, '0', HEAD_LENGTH);
	_InitMess(mess1.GetMessage(), mess1.GetLength());
}
CFMessage& operator +(const CFMessage& fmess, const CHAR* mess)
{
	LPBYTE newmess = new BYTE[fmess.GetLength()+strlen(mess)];
	memmove(newmess, fmess.GetMessage(), fmess.GetLength());
	memmove(newmess+fmess.GetLength(), mess, strlen(mess));
	CFMessage* pmess = new CFMessage(newmess, fmess.GetLength()+strlen(mess));
	return *pmess;
}
VOID CFMessage::SetMMICommand(const PCHAR mmi)
{
	SetCommandCode(mmi);
	if (strlen(mmi) < CMDCODE_LEN) return;
	SetBody(mmi+CMDCODE_LEN);
}


VOID CFMessage::Add(LPBYTE lpstr, WORD32 len)
{
	LPBYTE newbody = new BYTE[GetBodyLength() + len];
	memmove(newbody, GetBody(), GetBodyLength());
	memmove(newbody+GetBodyLength(), lpstr, len);
	SetBody(newbody, GetBodyLength() + len);
}

VOID CFMessage::Add(const PCHAR str)
{
	Add((LPBYTE)str, strlen(str));
}
BOOL CFMessage::IsBroad() const
{
	return m_achHead[BROADLABEL_OFFSET] == '2';
}
VOID CFMessage::SetBroad(BOOL label)
{
	m_achHead[BROADLABEL_OFFSET] = label ? '2' : '0';
}
#include <stdio.h>
VOID CFMessage::Print() const
{
    printf("head=%s\n", GetHead());
	printf("head2=%s\n", GetHead()+32);
    printf("body=%s\n\n", GetBody());
    printf("journalnum=%d\n", GetJournalNum());

	printf("userid=%d termid=%d winid=%d funcid=%c commandmode=%d\n",
           GetUserID(),
           GetTerminalID(),
           GetWindowID(),
           GetFunctionID(),
           GetCommandMode()
            );

    printf("commandcode=%s, transcommandcode=%s\n",
           GetCommandCode(),
           GetTransCommCode());
    printf("journalnum=%d\n", GetJournalNum());
    printf("messlength=%d\n", GetLength());
	
	if (IsBroad()) printf("broad cast message\n");
	else printf("not broad castfasd message\n");
}


/*------------------------------------------------
	用于字符串和16进制转换的四个函数
------------------------------------------------*/
WORD32 HexStringToInt(const LPBYTE pString, WORD32 len)
{
	WORD32 loop, n, nResult = 0;

	for (loop=0; loop < len; loop++)
	{
		n = HexCharToInt(pString[loop]);
		if (n == FAULT) return FAULT;
		nResult = 16*nResult + n;
	}
	return nResult;
}

WORD32 HexStringToInt(PCHAR pString)
{
	return HexStringToInt((LPBYTE)pString, strlen(pString));
}

PCHAR IntToHexString(WORD32 num, WORD32 stringlen)
{
	if (stringlen <=0) return NULL;

	stringlen = stringlen > 99 ? 99 : stringlen;

	PCHAR hexstr = IntToHexString(num);
	WORD32   reallen = strlen(hexstr);
	
	PCHAR strResult = new CHAR[100];
	if (stringlen >= reallen) 
	{
		memset(strResult, '0', stringlen - reallen);
		memmove(strResult + stringlen - reallen, hexstr, reallen);
		strResult[stringlen] = '\0';
	}
	else //if (stringlen < reallen)
	{
		memmove(strResult, hexstr+(reallen-stringlen), stringlen);
		strResult[reallen] = '\0';
	}
	
	delete hexstr;
	return strResult;
}
PCHAR IntToHexString(WORD32 num)
{
	CHAR tmp[11];
	CHAR* achResult = new CHAR[11];
	WORD32 digit, loop;

	if (num==0) 
	{
		strcpy(achResult, "0");
		return achResult;
	}

	loop = 0;
	while (num > 0)
	{
		digit = num % 16;
		num = num / 16;

		if (digit<10) tmp[loop] = (CHAR)('0'+digit);
		if (digit>9) tmp[loop] = (CHAR)('A' + digit - 10);
		loop++;
	}
	tmp[loop] = '\0';

	WORD32 len = loop;
	for (loop=0; loop<len; loop++)
		achResult[loop] = tmp[len-1-loop];
	achResult[loop] = '\0';
	
	return achResult;
}