netsend.c

这是一个潜入式开发的c语言代码

#include "netsend.h"
#include <netdb.h>

/* all pack data */
BYTE packDATA[PACKHEAD_SIZE+PACKDATA_SIZE+VERIFYCODE_SIZE];
/* config data */
NConfig m_configDATA;
/* pack head data */
NPackHEAD m_PackHEAD;
/* verify code */
VerifyCode m_VerifyCode;

NConfig*	pConfig;	// pointer to config data
NPackHEAD*	pPackHEAD;	// pointer to pack head
VerifyCode* pVerifyCode;// pointer to verify code
BYTE* pSEND_HEAD;		// pointer to send buffer head
BYTE* pSEND_DATA;		// pointer to send buffer data
BYTE* pSEND_VERIFYCODE;	// pointer to send buffer verifycode
FIIO* pNetIO;			// FIIO object



Boolean nsend_Init(BYTE* MacID, CHAR *remoteIP, UINT32 port, UINT16 bah, BYTE* key)
{
	pSEND_HEAD = packDATA;
	pSEND_DATA = pSEND_HEAD + PACKHEAD_SIZE;
	pSEND_VERIFYCODE = pSEND_DATA + PACKDATA_SIZE;
	pPackHEAD = (NPackHEAD*)&m_PackHEAD;
	pVerifyCode = (VerifyCode*)&m_VerifyCode;
	pConfig = (NConfig*)&m_configDATA;


	//save config
	pConfig->port = port;
	memcpy(pConfig->key, key, sizeof(pConfig->key) );
	memcpy(pConfig->remoteIP, remoteIP, sizeof(pConfig->remoteIP) );
	f_cpname(pConfig->MAC, sizeof(pConfig->MAC), MacID);

	// ----set pack head ----
	pPackHEAD->bytesNum = sizeof(packDATA);
	pPackHEAD->remoteIP = inet_addr(remoteIP);
	pPackHEAD->u16BAH = bah;
	memcpy(pPackHEAD->key, key, sizeof(pPackHEAD->key) );
	pPackHEAD->key[pPackHEAD->key[0]] = pPackHEAD->key[pPackHEAD->key[0]]^(*((BYTE*)&bah));
	
	return nsend_Connect();
}

/* Non-blocking mode*/
Boolean nsend_Connect()
{
	Boolean success;
	struct sockaddr_in sockAddr;
	REGINT iLen=sizeof(sockAddr);

	// create
	pNetIO = FsockCreate(client, inet_addr(pConfig->remoteIP), pConfig->port);
	if( pNetIO == NULL )
		return False;
	
	// open
	success = FioOpen(pNetIO);

	// set local addr
	getsockname(((FIOSOCK*)pNetIO->pObj)->socket, (struct sockaddr *)&sockAddr,&iLen);
	pPackHEAD->localIP = inet_addr(inet_ntoa(sockAddr.sin_addr));

	return True;
}

VOID nsend_DisConnect()
{
	FioClose(pNetIO);
	FsockDestory(pNetIO);
	pNetIO = NULL;
}

VOID ENcodeData()
{
	//使用1BYTE XOR 加密。
	UINT32 i;
	BYTE key;
	key = pConfig->key[pConfig->key[0]];

	for(i=0; i<PACKDATA_SIZE; i++)
	{
		pSEND_DATA[i] = pSEND_DATA[i]^key;
	}
}

VOID MakeVerifycode()
{
	//make code
	pSEND_VERIFYCODE[0] = LRC(packDATA, PACKHEAD_SIZE+PACKDATA_SIZE);
}

/* pack a tag to an NTag */
VOID PackItem(NTag* item, FOutputTag* tag)
{
	REGINT index;
	ASSERT(tag == NULL);

	item->wValue = tag->wValue;
	item->status = tag->Status;
	f_cpname(item->Name, sizeof(item->Name), tag->TagName);
	ext_ToBuffer(tag->Value, DOUBLE_IEEE_LH, &item->value.dval);
}

VOID UnFlodItemData(BYTE* buffer, NTag* data, REGINT* length)
{
	REGINT size = 0;
	REGINT lsize = 0;
	REGINT offset = 0;

	size=40;
	f_memcpy(buffer + (offset+=lsize), 40, (BYTE*)(data->Name), sizeof(data->Name), size);
	lsize=size;

	size=sizeof(data->value.bBuffer);
	memcpy(buffer + (offset+=lsize), (BYTE*)(data->value.bBuffer), size);
	lsize=size;

	size=sizeof(data->wValue);
	memcpy(buffer + (offset+=lsize), (BYTE*)(&data->wValue), size);
	lsize=size;

	size=sizeof(data->status);
	memcpy(buffer + (offset+=lsize), (BYTE*)(&data->status), size);
	lsize=size;

	*length = offset+lsize;
}

VOID UnFoldHead()
{
	REGINT size = 0;
	REGINT lsize = 0;
	REGINT offset = 0;

	size=sizeof(pPackHEAD->remoteIP);
	memcpy(pSEND_HEAD + (offset+=lsize), (BYTE*)(&pPackHEAD->remoteIP), size);
	lsize=size;

	size=sizeof(pPackHEAD->localIP);
	memcpy(pSEND_HEAD + (offset+=lsize), (BYTE*)(&pPackHEAD->localIP), size);
	lsize=size;

	size=sizeof(pPackHEAD->u16BAH);
	memcpy(pSEND_HEAD + (offset+=lsize), (BYTE*)(&pPackHEAD->u16BAH), size);
	lsize=size;

	size=sizeof(pPackHEAD->key);
	memcpy(pSEND_HEAD + (offset+=lsize), (BYTE*)(pPackHEAD->key), size);
	lsize=size;

	size=sizeof(pPackHEAD->bytesNum);
	memcpy(pSEND_HEAD + (offset+=lsize), (BYTE*)(&pPackHEAD->bytesNum), size);
	lsize=size;
}

VOID UnFoldData(FTagGroup* grp)
{
	UDATA tmpUDATA;
	REGINT lsize = 0;
	REGINT offset = 0;
	REGINT i;
	NTag atag;

	// set MAC, GroupID
	tmpUDATA.u32 = grp->OutTagNum;
	f_memcpy(pSEND_DATA, 50, (BYTE*)pConfig->MAC, sizeof(pConfig->MAC), 50);
	f_memcpy(pSEND_DATA+ 50, 20, (BYTE*)grp->GrpName, sizeof(grp->GrpName), 20);
	memcpy(pSEND_DATA +  70, (BYTE*)(&tmpUDATA.u32), 4);
	
	// unfold group
	offset = 74;
	for(i=0; i<grp->OutTagNum; i++)
	{
		PackItem(&atag, grp->OutTag[i]);
		UnFlodItemData(pSEND_DATA + offset, &atag, &lsize);
		offset += lsize;
	}
}

/* compose data with a group */
VOID ComposeData(FTagGroup* grp)
{
	REGINT index;

	// compose head
	UnFoldHead();
	// compose data
	UnFoldData(grp);
}

/* send data by group */
Boolean nsend_SendGrp(FTagGroup* grp)
{
	//init
	memset(pSEND_DATA, 0, PACKDATA_SIZE);
	memset(pSEND_VERIFYCODE, 0, VERIFYCODE_SIZE);
	
	//compose data
	ComposeData(grp);
	//encode data
	ENcodeData();
	//make verify code
	MakeVerifycode();

	//send
	if( pNetIO!= NULL && FioWrite(pNetIO, packDATA, sizeof(packDATA)) != -1 )
	{
		return True;
	}
	else
	{
		// mark and buffer
		// ...

		// reconnect,non-blocking mode
		nsend_DisConnect();
		nsend_Connect();

		return False;
	}
}