csocket_sys.cpp

unix下的socket编程用户可以直接调用的通用函数库

/**********************************************************
 * name: CSOCKET_Sys.cpp
 *
 * Description: 
 *   TBS BCC CSOCKET_Sys.cpp
 *
 *   Copyright to DDP 2000-2001 All rights reverved.
 *   2000.11.03 Created
 *
 * email: [e-mail]
 **********************************************************/


//extern	int bzero(char * ,int );
#include "../include/CSOCKET_Sys.h"

	CSOCKET_Sys::CSOCKET_Sys()
	{
		;
	}

	CSOCKET_Sys::~CSOCKET_Sys()
	{
		;
	}

	// Connect to server by host_addr and host_port
	// Return connect socket file desciptor( sockfd ) if all OK
 	// Return -1  ( socket error )
	// Return -2  ( connect error )
	int CSOCKET_Sys::TcpConnect( char *host_addr,short host_port,int time_out )
	{
		struct sockaddr_in serv;
		int sockfd;

		//bzero( (char*)&serv,sizeof(serv) );
		memset(&serv,0,sizeof(serv));
		serv.sin_family = AF_INET;
		serv.sin_addr.s_addr=inet_addr(host_addr);
		serv.sin_port = htons(host_port);

		if ((sockfd=socket(AF_INET,SOCK_STREAM,0)) < 0) 
		{
			// cout << "socket error!" << endl;
			fprintf(stderr," socket error!...\n");
			return (-1);
		}

		if( connect(sockfd,(struct sockaddr*)&serv,sizeof(serv)) < 0)
		{
			// cout << "connect to remote error!" << endl;
			fprintf(stderr," connect to remote error...!\n");
			close( sockfd );
			return -2;
		}
		return(sockfd);
	}

	// Connect to server by host_addr and host_port
	// Return connect socket file desciptor( sockfd ) if all OK
 	// Return -1  ( socket error )
	// Return -2  ( connect error )
	int CSOCKET_Sys::TcpConnect1( unsigned int IPaddress,unsigned short host_port,int time_out )
	{
		struct sockaddr_in serv;
		int sockfd;

		//bzero( (char*)&serv,sizeof(serv) );
		memset(&serv,0,sizeof(serv));
		serv.sin_family = AF_INET;
		serv.sin_addr.s_addr=htonl(IPaddress);
		serv.sin_port = htons(host_port);

		if ((sockfd=socket(AF_INET,SOCK_STREAM,0)) < 0) 
		{
			// cout << "socket error!" << endl;
			fprintf(stderr," socket error!\n");
			return (-1);
		}

		if( connect(sockfd,(struct sockaddr*)&serv,sizeof(serv)) < 0)
		{
			// cout << "connect to remote error!" << endl;
			fprintf(stderr," connect to remote error!..\n");
			close( sockfd );
			return -2;
		}
		return(sockfd);
	}

	// Listening on defined port,Only support IPV4
	// Return listen socket file desciptor( sockfd ) if all OK
 	// Return -1  ( socket error )
	int CSOCKET_Sys::TcpListen(short port)
	{
		int listenfd;
		int opt;
		struct sockaddr_in sin = { AF_INET };  /* the rest is null */

		if ((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
		{
			perror("socket"); 
			return(-1);
		}

		opt = 1;
		setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,(void *)&opt,(int)sizeof(opt));

		/*
		 * bind the socket on defined port
		 */
// 		bzero((char *)&sin,sizeof(sin));
		memset(&sin,0,sizeof(sin));
		sin.sin_family=AF_INET;
		sin.sin_port=htons( port );		/* defined port */
		if (bind(listenfd,(struct sockaddr *)&sin, sizeof(sin)) < 0)
		{
			perror("bind");
			close( listenfd );
			return (-1);
		}

		/*
		 * listen on defined port
		 */
		if ( listen( listenfd,5 ) < 0 ) 
		{
			perror("listen");
			close( listenfd );
			return (-1);
		}
		return ( listenfd );
	}

	// Send "n" bytes to defined socket through descriptor
	// Return number of sending bytes (n) if all Ok,
	// Return -1 if connection error.
	ssize_t CSOCKET_Sys::sendn( int fd , void *vptr , size_t n , int flags )
	{
		size_t nleft;
		size_t nsend;
		char *ptr;

		ptr = (char *)vptr;
		nleft = n;
		while ( nleft > 0 )
		{
			nsend = send(fd,ptr,nleft,flags);
			if( nsend <= 0 )
			{
				if( errno == EINTR )
				{
					nsend = 0; /* and call send() again */
				}
				else if( errno != EWOULDBLOCK )
				{
					// cout << "sendn:connection error,need reconnect:" << strerror(errno) << " errno!" <<endl;
					fprintf(stderr," sendn:connection error, need reconnect!\n");
					return -1;  /* connection error, must reconnect it */
				}
				// cout << "ERROR: < send return code=" << nsend << "> not avail..." << endl;
				fprintf(stderr," ERROR: send return code=%d...\n",nsend);
				return -3;
			}
			if ( nsend == 0xffffffff )
			{
				// cout << "ERROR: <sendn error>socket fd not avail...." << endl;
				fprintf(stderr, " ERROR: <sendn error> socket fd not avail....\n");
				return -3;
			}	
			if (nleft != nsend)
			{
				// cout << "sendn: nleft=" <<nleft <<" nsend=" <<nsend <<endl;
				fprintf(stderr," sendn: nleft=%d  nsend=%d..\n",nleft,nsend);
				return - 4;
			}
			nleft = nleft - nsend;
			ptr   = ptr + nsend;
			break;
		}
	    return( n );
	}

	// Receive "n" bytes from defined socket through it's descriptor
	// Return real length(bytes number) of receiving
	// Connect disabled return 0
	// Something is wrong about socket return -1
	ssize_t CSOCKET_Sys::recvn( int fd , void * vptr , size_t n , int flags)
	{
		int nleft;
		int nrecv;
		char *ptr;

		ptr = (char *)vptr;
		nleft = n;
		while ( nleft > 0 )
		{
			nrecv = recv( fd,ptr,nleft,flags );
			if( nrecv < 0 )
			{
				if( errno == EINTR ) /* if interrupted  */
				{
					// cout << "recvn: interrupt=" << strerror(errno) <<endl; 
					fprintf(stderr,"recvn: interrupt....\n");
					continue; /* and call read() again */
				}
				/*
				 * If any stations like this, send must reconnect the receiver.
				 */
				else
				{
					return -1; /* if errno !=EWOULDBLOCK, then close(fd) */
				}
			}
			else if( nrecv == 0 )  /* EOF */
			{
				// cout << " recvn: conect disabled! " << endl;
				fprintf(stderr," recvn: connect disabled!..\n");
				break;
			}
			nleft -= nrecv;
			ptr   += nrecv;
		} /* while over */
		return ( n-nleft );  /* return >=0 */
	}

	// Timed out on receivable
	// if decriptor is readable,then return >0.
	// if timed out,then return =0.
	// if error occurs,return <0.
	int CSOCKET_Sys::RecvableTimeout( int fd , int sec )
	{
		fd_set rset;
		struct timeval tv;
		time_t begin_t;
		int retval;

		if( sec == 0 )
		{
			return( select(fd+1,&rset,NULL,NULL,NULL) );	/* wait for ever */
		}
		if( sec < 0 )
		{
			return -1;
		}

		while( 1 )
		{
			begin_t = time(NULL);
			FD_ZERO( &rset );
			FD_SET( fd , &rset );
			tv.tv_sec  = sec;
			tv.tv_usec = 0;
			if( (retval=select(fd+1,&rset,NULL,NULL,&tv)) < 0 ) 
			{
				if( errno==EINTR )
				{
					// sec = sec - (begin_t-time(NULL));
					 sec = sec - ( time(NULL) - begin_t);
					continue;
				}
				else
				{
					break;
				}
			}
			else
			{
				break;
			}
		}
		return retval;
	}