sock_func.c

socket编程

#include "sock_func.h"

int socket_init( int * pSockfd )
{
	int     ans ;
	int     sockfd ;
	struct  sockaddr_in serv_addr   ;

	int clien , childpid;
	int newsockfd ;
	struct  sockaddr_in cli_addr ;

	*pSockfd = -1 ;

	/*-------------------*/
	/* open a TCP socket */
	/*-------------------*/

	sockfd = socket( AF_INET , SOCK_STREAM , 0 )    ;
	if ( sockfd < 0 ) {
		TraceLog_str("socket happen error!");
		return -1 ;
	}

	/*------------------------*/
	/* bind our local address */
	/*------------------------*/

	bzero( (char*)&serv_addr , sizeof(serv_addr) ) ;
	serv_addr.sin_family            = AF_INET               ;
	serv_addr.sin_addr.s_addr       = htonl(INADDR_ANY)     ;
	serv_addr.sin_port              = htons(SERV_TCP_PORT)  ;

	ans = bind( sockfd , (struct sockaddr *)&serv_addr , sizeof(serv_addr) ) ;

	if ( ans < 0 ) {
		TraceLog_str("bind happen error!");
		return -1 ;
	}

	ans = listen( sockfd , 5 ) ;
	if ( ans < 0 ) {
		TraceLog_str("listen happen error!");
		return -1 ;
	}

	TraceLog_str("socket initialize successfully!");

	*pSockfd = sockfd ;

	return 0;
}

int socket_recv( int sockfd , struct PG_HEAD * pg_head , char ** ptr )
{
	int rval ;
	char * pData ;

	*ptr = NULL ;

	memset( pg_head , '\0' , sizeof(struct PG_HEAD) ) ;

	rval = recv( sockfd , pg_head , sizeof(struct PG_HEAD) , 0 );

	if ( rval < 0 ) {
		TraceLog_str("recv happen error!");
		return -1 ;
	}
	else if ( rval == 0 ) {
		TraceLog_str( "this request has been canceled , abnormal!" ) ;
		return 1 ;
	}
	else if ( rval != (int)sizeof(struct PG_HEAD) ) {
		TraceLog_str("recv happen error!");
		return -1 ;
	}

	if ( pg_head->reqSize > 0 )
	{
		pData = (char*)malloc(pg_head->reqSize + 1) ;
		if( pData == NULL ) {
			TraceLog_str("memory not enough!");
			return -1 ;
		}

		memset( pData , '\0' , pg_head->reqSize + 1 ) ;

		rval = recv( sockfd , pData , pg_head->reqSize , 0 );

		if ( rval != pg_head->reqSize ) {
			free( pData ) ;
			TraceLog_str("recv happen error!");
			return -1 ;
		}

		*ptr = pData ;
	}

	TraceLog_recv( pg_head , *ptr) ;

	return 0 ;
}


int socket_send( int sockfd , int pg_type , char * p_data)
{
	struct PG_HEAD pg_head ;
	int rval ;
	int pg_size ;

	char * buff ;

	memset( &pg_head , '\0' , sizeof(struct PG_HEAD) ) ;

	pg_head.reqType = pg_type ;
	pg_head.reqSize = (p_data==NULL ? 0 : strlen(p_data)) ;

	pg_size = sizeof(struct PG_HEAD) + pg_head.reqSize ;

	buff = (char*)malloc( pg_size) ;
	memset( buff , '\0', pg_size) ;

	memcpy( buff , &pg_head , sizeof(struct PG_HEAD) ) ;
	if ( p_data != NULL )
	{
		memcpy( buff+sizeof(struct PG_HEAD) , p_data , strlen(p_data) ) ;
	}

	TraceLog_send(&pg_head, p_data) ;

	rval = send( sockfd , buff , pg_size, 0 ) ;

	free(buff) ;

	if ( rval != pg_size ) {
		TraceLog_str("send back happen error!\n");
		return -1 ;
	}

	TraceLog_str( "send back successfully!" ) ;

	return 0 ;
}