📄 hex.cpp

📁 本代码是自己封装的采用WINPCAP技术对在线设备分配IP地址。
💻 CPP
字号:
// Hex.cpp: implementation of the CHex class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Hex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


CHex::CHex()
{
	m_bHex=NULL;
	m_iCurPoint=0;
	m_szbuf=NULL;
	m_bAddHex=NULL;
	m_pOffsetHex=NULL;
}

CHex::CHex(int isize)
{
	m_bHex=NULL;
	m_iCurPoint=0;
	m_szbuf=NULL;
	m_bAddHex=NULL;
	m_pOffsetHex=NULL;
	SetSize(isize);
	
}
CHex::CHex(LPCTSTR szData)
{
	m_bHex=NULL;
	m_iCurPoint=0;
	m_szbuf=NULL;
	m_bAddHex=NULL;
	m_pOffsetHex=NULL;
	SetSize((int)strlen(szData)/2+1);
	operator =(szData);
	
}

CHex::CHex(CHex &bSourceHex)
{
	m_bHex=NULL;
	m_iCurPoint=0;
	m_szbuf=NULL;
	m_bAddHex=NULL;
	m_pOffsetHex=NULL;
	SetSize(bSourceHex.GetSize());
	m_iCurPoint=bSourceHex.GetCurPoint();
	memcpy(m_bHex,bSourceHex.m_bHex,m_iCurPoint);	
}

CHex::~CHex()
{
	if (m_bHex) delete  m_bHex;
	if (m_szbuf) delete  m_szbuf;
	if (m_bAddHex) delete m_bAddHex;
	if (m_pOffsetHex) delete [] m_pOffsetHex;

}

BOOL CHex::Buf2Hex_Single(const char *buf, UCHAR * hex)
{
	UCHAR result;
	if (buf[0]<0||buf[1]<0) return false;
	if (buf[0]>='0'&&buf[0]<='9') result=(UCHAR)((buf[0]-48)*16);
	else if 	(buf[0]>='A'&&buf[0]<='F')
	{
		result=(UCHAR)((buf[0]-'A'+10)*16);
	}
	else if (buf[0]>='a'&&buf[0]<='f')
	{
		result=(UCHAR)((buf[0]-'a'+10)*16);
	}
	else
	{
		return false;
	}
	
	if (buf[1]>='0'&&buf[1]<='9') *hex=(UCHAR)(buf[1]-48);
	else if (buf[1]>='A'&&buf[1]<='F')
		*hex=(UCHAR)(buf[1]-'A'+10);
	else if (buf[1]>='a'&&buf[1]<='f')
		*hex=(UCHAR)(buf[1]-'a'+10);
	else
		return false;
	
	*hex=(UCHAR)(*hex+result);
	return true;
}

BOOL CHex::Buf2Hex(const char *buf, UCHAR *hex)//将字符串转成HEX
{
	int i;
	int len=(int)strlen(buf)/2;
	for(i=0;i<len;i++)
	{
		if (!Buf2Hex_Single(&buf[i*2],&hex[i])) return false;
	}
	return true;
}

void CHex::SetSize(int iSize)
{
	if (m_bHex) 
	{
		delete m_bHex;	
		m_bHex=NULL;
	}
	m_bHex=new BYTE[iSize];
	m_iSize=iSize;
}

BOOL CHex::Add(void *bAddData, int iLen)
{
	if (m_iCurPoint+iLen>m_iSize) 
	{
#ifdef _HEXTHROW 
		throw "CHex空间不足";
#endif 
		return false;
	}
	memcpy(m_bHex+m_iCurPoint,bAddData,iLen);
	m_iCurPoint+=iLen;
	return true;
}

BOOL CHex::Add(const CHex &bHex)
{
	return Add(bHex.m_bHex,bHex.GetCurPoint());
}

BOOL CHex::Add(const CHex &bHex,int nBegin,int nLen)
{
	if (nLen<0) return Add(bHex.m_bHex+nBegin,bHex.GetCurPoint()-nBegin);
	return Add(bHex.m_bHex+nBegin,nLen);
}

BOOL CHex::AddASC(LPCTSTR szData)
{
	Add((void *)szData,(int)strlen(szData));
	return true;
}

BOOL CHex::AddOneByte(BYTE bData)//没有判断错误
{
	m_bHex[m_iCurPoint]=bData;
	m_iCurPoint++;
	return true;
}

BOOL CHex::AddTwoByte(USHORT wData)
{
	m_bHex[m_iCurPoint++]=HIBYTE(wData);
	m_bHex[m_iCurPoint++]=LOBYTE(wData);
	return true;
}
BOOL CHex::AddUINT(UINT nVal)
{
	m_bHex[m_iCurPoint++]=nVal>>24;
	m_bHex[m_iCurPoint++]=(UCHAR)((nVal&0x00FF0000)>>16);
	m_bHex[m_iCurPoint++]=(UCHAR)((nVal&0x0000FF00)>>8);
	m_bHex[m_iCurPoint++]=(UCHAR)(nVal&0x000000FF);

	return true;	
}

BOOL CHex::SetData(int iBegin,BYTE *bSetData,int iLen)
{
	if (iBegin+iLen>=m_iSize) 
	{
#ifdef _HEXTHROW 
		throw "CHex空间不足";
#endif
		return false;
	}
	memcpy(m_bHex+iBegin,bSetData,iLen);
	return true;
}

BOOL CHex::SetAt(BYTE bData, int iPoint)
{
	m_bHex[iPoint]=bData;
	return true;
}

CHex::operator  BYTE *( )
{
	if (!m_bHex) throw "CHex空指针";
	return m_bHex;
}

CHex::operator CString()
{
	int i;
	if (m_szbuf)
	{
		delete m_szbuf;
		m_szbuf=NULL;
	}
	m_szbuf=new char[m_iCurPoint*2+2];
	for(i=0;i<m_iCurPoint;i++) sprintf(m_szbuf+i*2,"%02X",m_bHex [i]);
	m_szbuf[m_iCurPoint*2]=0;
	return m_szbuf;
}

void CHex::operator =(CString &strbuf)
{
	int len=strbuf.GetLength ();
	
#ifdef _HEXTHROW 
	if (m_iSize<len)
		throw "CHex空间不足";
	if (len%2!=0)
		throw "CHex\n长度不正确";
#endif 
	BOOL flag=Buf2Hex(strbuf.GetBuffer  (len),m_bHex);
	if (!flag)
	{
		m_iCurPoint=0;
#ifdef _HEXTHROW 
		throw "输入有错误字符";
#endif 
	}
	m_iCurPoint=len/2;
}


void CHex::operator =(const char * szbuf)
{
#ifdef _HEXTHROW 
	if (m_iSize<(int)strlen(szbuf)/2)
		throw "CHex\n空间不足";
	if (strlen(szbuf)%2!=0)
		throw "CHex\n长度不正确";
#endif 
	BOOL flag=Buf2Hex(szbuf,m_bHex);
	if (!flag)
	{
		m_iCurPoint=0;
#ifdef _HEXTHROW 
		throw "输入有错误字符";
#endif 
	}
	m_iCurPoint=(int)strlen(szbuf)/2;
}

void CHex::operator =(const CHex &bHex)
{
	if (bHex.GetSize()>m_iSize)
	SetSize(bHex.GetSize());
	m_iCurPoint=bHex.GetCurPoint();
	memcpy(m_bHex,bHex.m_bHex,m_iCurPoint);
}


void CHex::operator +=(const char * szbuf)
{
	int len=(int)strlen(szbuf)/2;
	BOOL flag;
#ifdef _HEXTHROW 
	if (m_iSize<len+m_iCurPoint)
		throw "CHex\n空间不足";
	if (strlen(szbuf)%2!=0)
		throw "CHex\n长度不正确";
#endif 
	if (m_bAddHex) 
	{
		delete m_bAddHex;
		m_bAddHex=NULL;
	}
	m_bAddHex=new BYTE[len+2];
	flag=Buf2Hex(szbuf,m_bAddHex);
	if (!flag)
	{
		m_iCurPoint=0;
#ifdef _HEXTHROW 
		throw "输入有错误字符";
#endif 
	}	
	Add(m_bAddHex,len);
}

BOOL  CHex::operator ==(CHex & hex1)
{
	int i;
	if (hex1.GetCurPoint ()!=m_iCurPoint) return false;
	for (i=0;i<m_iCurPoint;i++)
	{
		if (m_bHex[i]!=hex1.m_bHex [i]) return false;
	}
	return true;
}

BOOL  CHex::operator !=(CHex & hex1)
{
	int i;
	if (hex1.GetCurPoint ()!=m_iCurPoint) return true;
	for (i=0;i<m_iCurPoint;i++)
	{
		if (m_bHex[i]!=hex1.m_bHex [i]) return true;
	}
	return false;
}


void CHex::Move(int i)
{
#ifdef _HEXTHROW 
		if (m_iCurPoint+i>m_iSize) throw "CHex\n 当前长度指针大于地址空间";
#endif 
	m_iCurPoint+=i;
}

void CHex::SetZero()
{
	memset(m_bHex,0,m_iSize);
}

void CHex::MoveTo(int i)
{
#ifdef _HEXTHROW 
		if (i>m_iSize) throw "CHex\n 当前长度指针大于地址空间";
#endif 
	m_iCurPoint=i;
}

BOOL CHex::CopyTo(CHex &destHex,int iSize)	//绝对复制
{
	if (-1==iSize)
	{
		iSize=m_iCurPoint;
	}
	if (destHex.GetSize ()<iSize)
	{
#ifdef _HEXTHROW 
		throw "CHex\n被复制对象空间不足";
#endif 
		return false;
	}
	memcpy(destHex.m_bHex ,m_bHex,iSize);
	destHex.MoveTo (iSize);
	return true;
}

int CHex::GetSize() const
{
	return m_iSize;
}

int CHex::GetCurPoint() const
{
	return m_iCurPoint;
}

BOOL CHex::CopyToByteArray(CByteArray &barray)
{
	int i;
	for(i=0;i<m_iCurPoint;i++)
		barray.Add (m_bHex[i]);
	return true;
}

int CHex::CreateFromSafeArray(COleSafeArray &sa)
{
	int i,len;
	len=sa.GetOneDimSize ();
	if (m_bHex==0) SetSize(len+8);
	if (len>m_iSize)
	{
#ifdef _HEXTHROW 
		
		throw "CHex\n被复制对象空间不足";
#endif
		return false;
	}
	for(i=0;i<len;i++) sa.GetElement ((long *)&i,m_bHex+i);
	MoveTo(len);
	return len;
}

USHORT CHex::ToUShort()
{
	USHORT i;
	i=m_bHex[0];
	i=i<<8;
	i+=m_bHex[1];
	return i;
}
WPARAM CHex::ToULong()
{
	return MAKEWPARAM(MAKEWORD(m_bHex[3],m_bHex[2]),MAKEWORD(m_bHex[1],m_bHex[0]));;
}

UINT CHex::ToBCD()
{
	int i;
	if (m_szbuf)
	{
		delete m_szbuf;
		m_szbuf=NULL;
	}
	m_szbuf=new char[m_iCurPoint*2+2];
	for(i=0;i<m_iCurPoint;i++) sprintf(m_szbuf+i*2,"%02X",m_bHex [i]);
	m_szbuf[m_iCurPoint*2]=0;
	return atoi(m_szbuf);
}

char * CHex::ToDBTime(BOOL IsShortYear)
{
	if (m_szbuf)
	{
		delete m_szbuf;
		m_szbuf=NULL;
	}
	m_szbuf=new char[20];	
	char sztemp[8];
	m_szbuf[0]=0;
	int i=1;
	if (!IsShortYear)			//年
	{
		sprintf(sztemp,"%02X%02X-",m_bHex[0],m_bHex[1]);
		i=2;
	}
	else
		sprintf(sztemp,"%02X-",m_bHex[0]);
	strcat(m_szbuf,sztemp);

	//月
	sprintf(sztemp,"%02X-",m_bHex[i++]);
	strcat(m_szbuf,sztemp);

	//日
	sprintf(sztemp,"%02X",m_bHex[i++]);
	strcat(m_szbuf,sztemp);

	if (!IsShortYear&&m_iCurPoint<5) return m_szbuf;
	if (IsShortYear&&m_iCurPoint<4) return m_szbuf;

	sprintf(sztemp," %02X",m_bHex[i++]);
	strcat(m_szbuf,sztemp);
	
	if (!IsShortYear&&m_iCurPoint<6) return m_szbuf;
	if (IsShortYear&&m_iCurPoint<5) return m_szbuf;

	sprintf(sztemp,":%02X",m_bHex[i++]);
	strcat(m_szbuf,sztemp);

	if (!IsShortYear&&m_iCurPoint<7) return m_szbuf;
	if (IsShortYear&&m_iCurPoint<6) return m_szbuf;

	sprintf(sztemp,":%02X",m_bHex[i++]);
	strcat(m_szbuf,sztemp);
	return m_szbuf;
}

char * CHex::ToTime()
{
	if (m_szbuf)
	{
		delete m_szbuf;
		m_szbuf=NULL;
	}
	m_szbuf=new char[20];	
	char sztemp[8];
	m_szbuf[0]=0;
	sprintf(sztemp,"%02X:%02X",m_bHex[0],m_bHex[1]);
	strcat(m_szbuf,sztemp);
	if (m_iCurPoint<3) return m_szbuf;
	sprintf(sztemp,":%02X",m_bHex[2]);
	strcat(m_szbuf,sztemp);
	return m_szbuf;
}

CTime CHex::ToCTime()
{
#ifdef _HEXTHROW 
		if (m_iCurPoint<6) 	throw "CHex\n转成CTime失败，长度不够6个字节";
#endif 
	if (m_iCurPoint<6) return 0;
	SYSTEMTIME stime;
	char sztemp[8];

	sprintf(sztemp,"%02X%02X",m_bHex[0],m_bHex[1]);
	stime.wYear =atoi(sztemp);

	sprintf(sztemp,"%02X",m_bHex[2]);
	stime.wMonth =atoi(sztemp);

	sprintf(sztemp,"%02X",m_bHex[3]);
	stime.wDay =atoi(sztemp);

	sprintf(sztemp,"%02X",m_bHex[4]);	
	stime.wHour=atoi(sztemp);

	sprintf(sztemp,"%02X",m_bHex[5]);
	stime.wMinute=atoi(sztemp);

	sprintf(sztemp,"%02X",m_bHex[6]);
	stime.wSecond =atoi(sztemp);

	CTime time(stime);
	return time;
}


BOOL CHex::Offset(int *pnOffset, int len)
{
	int i;
	int nAllOffset=0;
	if (m_pOffsetHex)
	{
		delete [] m_pOffsetHex;
		m_pOffsetHex=NULL;
	}
	m_pOffsetHex=new CHex[len];
	for(i=0;i<len;i++)
	{
		m_pOffsetHex[i].SetSize(pnOffset[i]);	
		m_pOffsetHex[i].Add(m_bHex+nAllOffset,pnOffset[i]);
		nAllOffset+=pnOffset[i];
	}
	return true;
}

CHex * CHex::GetHexItem(int nIndex)	
{
	return &m_pOffsetHex[nIndex];
}

void CHex::operator >>(int nMoveToLen)
{
	MoveTo(nMoveToLen);
}

void CHex::operator <<(const char *szbuf)
{
	 operator +=(szbuf);
}

void CHex::operator <<(const CHex &bAddHex)
{
	 Add(bAddHex.m_bHex,bAddHex.GetCurPoint());
}


BOOL CHex::Cat(CHex &bData)
{
	Add(bData.m_bHex,bData.GetCurPoint());
	return true;
}

LPCTSTR CHex::ToShowString(BOOL IsSpace)
{
	int i;
	int nSpaceNum;
	if (m_szbuf)
	{
		delete m_szbuf;
		m_szbuf=NULL;
	}
	if (IsSpace) nSpaceNum=3;
	else
		nSpaceNum=2;
	m_szbuf=new char[m_iCurPoint*nSpaceNum+2];
	for(i=0;i<m_iCurPoint;i++) 
	{
		if (IsSpace)
		sprintf(m_szbuf+i*3,"%02X ",m_bHex [i]);
		else
		sprintf(m_szbuf+i*2,"%02X",m_bHex [i]);
	}
	m_szbuf[m_iCurPoint*nSpaceNum]=0;
	return m_szbuf;	
}
/*
	m_szbuf=new char[m_iCurPoint*2+2];
	for(i=0;i<m_iCurPoint;i++) sprintf(m_szbuf+i*2,"%02X",m_bHex [i]);
	m_szbuf[m_iCurPoint*2]=0;
*/
void CHex::Trace(LPCTSTR szScript)
{
	TRACE("%s:%s\n",szScript,(CString)*this);
}
💿 文件大小 88 K
👤 上传用户 zhaobaoru
📂 所属分类 Internet/网络编程
🏷️ 相关标签

#WINPCAP #代码 #封装 #分配
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -