fiosock.c

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

/*#########################################################################

  fiosock.c - implements of IOSocket. For Linux Platform.
  
		Copyright (c) 2005-2006, RICHISLAND All rights reserved.
  
  Purpose		:
  Version       :1.00
  Author        :
  Complete Date :

  Function List :
  History       :
  _________________________________________________________________________
  DATE          AUTHOR    VERSION    DESCRIBE
  -------------------------------------------------------------------------
  2006-05-06              Ver1.00    Create

#########################################################################*/
#include "fiosock.h"
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <sys/socket.h>


#define FSOCK_INSTANCE_NUM 1
#ifdef FSOCK_STATIC_INSTANCE

FIOSOCK S_SOCK[FSOCK_INSTANCE_NUM];
FIIO    S_FIIO[FSOCK_INSTANCE_NUM];
#endif //FSOCK_STATIC_INSTANCE


/* 
 * implements of IOSocket, exported 
 */

FIIO* FEXPORT FsockCreate(SOCKTYPE type, UINT32 ip, UINT16 port)
{
	Boolean success;
	REGINT flags;

	#ifdef FSOCK_STATIC_INSTANCE
	FIOSOCK* pNewsock = &S_SOCK[0];
	FIIO* pFIIO = &S_FIIO[0];
	#else
	FIOSOCK* pNewsock = (FIOSOCK*)malloc( sizeof(FIOSOCK) );
	FIIO* pFIIO = (FIIO*)malloc( sizeof(FIIO) );
	#endif
	
	pFIIO->pObj = pNewsock;
	pFIIO->pOpen = FsockOpen;
	pFIIO->pClose = FsockClose;
	pFIIO->pConfig = FsockCfg;
	pFIIO->pRead = FsockRead;
	pFIIO->pWrite = FsockWrite;

	pNewsock->type = type;
	pNewsock->u32IP = ip;
	pNewsock->u16Port = port;


	if(type != slink)
	{
		//create
		pNewsock->socket = socket(AF_INET, SOCK_STREAM, 0);
		//set file pipe to Non blocking mode
		flags = fcntl(pNewsock->socket,  F_GETFL,  0);  
		fcntl(pNewsock->socket,  F_SETFL,  flags|O_NONBLOCK);

		if(pNewsock->socket == -1)
		{
			success = False;
			DBG_MSG("create socket failed\n");
		}
		else
		{
			success = True;
  
			// bind when socktype is server.
			if(type == server && FsockBind(pNewsock) == False)
			{
				DBG_MSG("error occurs on binding.\n");
				success = False;
			}
		}
	}


	if( success )
	{
		DBG_MSG("create socket ok.\n");
		return pFIIO;
	}
	else
	{
		FsockDestory(pFIIO);
		pFIIO = 0;
		return pFIIO;
	}
}

Boolean FEXPORT FsockOpen(FIOSOCK *pObj)
{
	int ret;
	Boolean success;
	UINT32 sin_size;
	struct sockaddr_in _addr;

	_addr.sin_family= AF_INET; 
	_addr.sin_port= htons(pObj->u16Port); 
	_addr.sin_addr.s_addr= pObj->u32IP; 


	// socket client
	if(pObj->type == client)		
	{
		ret = connect(pObj->socket,(struct sockaddr *)&_addr,sizeof (_addr));
		return (0 == ret );
	}
	// socket server
	else if(pObj->type == server)	
	{
		success = False;

		if( listen(pObj->socket, 0xFF) == 0)
		{
			DBG_MSG("listening..\n");


			sin_size = sizeof( struct sockaddr_in );
			ret = accept(pObj->socket, (struct sockaddr *)&_addr, &sin_size);

			if(ret > 0)
			{
				FsockClose(pObj);
				pObj->type = slink;
				pObj->socket = ret;
				pObj->u32IP = (UINT32)(_addr.sin_addr.s_addr);
				pObj->u16Port = _addr.sin_port;

				success = True;
				DBG_MSG("remote:");
				DBG_MSG( inet_ntoa(pObj->u32IP) );
				DBG_MSG2(" %d.\n", pObj->u16Port);
			}
			else
			{
				DBG_MSG("accept failed.\n");
			}
		}
		else
		{
			DBG_MSG("listen failed.\n");
		}

		return success;

	}
	// for SOCKTYPE can't call open.
	else					
	{	return False;	}

}

VOID FEXPORT FsockDestory(FIIO *pFIIO)
{
	ASSERT(pFIIO == NULL);

	//close
	FsockClose(pFIIO->pObj);
	
	//free resources
	#ifndef FSOCK_STATIC_INSTANCE
	free(pFIIO->pObj);
	free(pFIIO);
	#endif
}

Boolean FEXPORT FsockCfg(FIOSOCK *pObj)
{
	return False;
}

REGINT FEXPORT FsockRead(FIOSOCK *pObj, BYTE* pBuffer, UINT16 bufferSize)
{
	if(pObj->socket <= 0)
		return -1;
	else
		return recv(pObj->socket, pBuffer, bufferSize, 0);
}

REGINT FEXPORT FsockWrite(FIOSOCK *pObj, BYTE* pBuffer, UINT16 usedSize)
{
	if(pObj->socket <= 0)
		return -1;
	else
		return (REGINT)send (pObj->socket, pBuffer, usedSize, MSG_NOSIGNAL);
}

Boolean FEXPORT FsockClose(FIOSOCK *pObj)
{
	return FsockDisConnect(pObj);
}


/*
 *  functions not exported
 */

Boolean FsockBind(FIOSOCK* pObj)
{
	if(pObj->type == server)
	{
		REGINT ret;
		REGINT temp;
		struct sockaddr_in local_addr; /* 本地地址信息 */ 


		// set socket for reuse
		temp = 1;
		setsockopt(pObj->socket,SOL_SOCKET,SO_REUSEADDR,&temp,sizeof(temp)); 

		// set address
		local_addr.sin_family=AF_INET; 
		local_addr.sin_port=htons(pObj->u16Port); 
		local_addr.sin_addr.s_addr = pObj->u32IP; 

		// bind
		ret = bind(pObj->socket, (struct sockaddr *)&local_addr, sizeof(local_addr));

		return (ret == 0);
	}
	else
		return False;
}

Boolean FsockDisConnect(FIOSOCK* pObj)
{
	if(shutdown(pObj->socket, 1) == 0 &&
		close(pObj->socket) == 0)
	{
		return True;
	}
	else
		return False;
}