netif.cpp

2002年

#include "netif.h"
#include <stdio.h>
#include <string.h>

#ifndef WIN32
#include <unistd.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#endif

char StringBuffer::cmdbuf[MAXMESG] = "";
char StringBuffer::recvbuf[MAXMESG]="";
char StringBuffer::saybuf[MAXMESG]="";
char StringBuffer::msgbuf[MAXMESG]="";
char StringBuffer::matbuf[MAXMESG]="";	//to be used only by Mat Log

Socket* Network::sock;

StringBuffer::StringBuffer()
{
}

StringBuffer::~StringBuffer()
{
}

int Network::wait_message(char *buf, Socket *esock)
{
	if(esock == NULL) return 0;
	timeval tv;
	fd_set readfds;
	tv.tv_sec = 0;
	tv.tv_usec = 100000;

	FD_ZERO(&readfds);
    FD_SET((unsigned int)esock->socketfd, &readfds);

	for (int i = 0; i < 10; i ++){
		if (select(esock->socketfd + 1, &readfds, NULL, NULL, &tv)){
			if (receive_message(buf, esock) == 1){
				return 1;
			}else{
				return 0;
			}
		}
	}
	
/*
	
	for (int i = 0; i < 10; i++)  {
		if (receive_message(buf, esock) == 1){
			return 1;
		
#ifdef WIN32
		Sleep(100);
#endif
#ifndef WIN32
		sleep(1);
#endif
	}
*/
	return 0;
}


Socket* Network::init_connection(char *host, int port){
	struct hostent 	*host_ent ;
	struct in_addr	*addr_ptr ;
	struct sockaddr_in	cli_addr ;

/*     winsock initialization       */
#ifdef WIN32
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD( 2, 2 );

	if ( WSAStartup( wVersionRequested, &wsaData ) != 0 ) {
		return NULL;
	}


	if ( LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 2 ) {
		WSACleanup( );
		return NULL; 
	}
#endif
	
	if(inet_addr(host) == -1){
		if((host_ent = (struct hostent *)gethostbyname(host)) == NULL) {
			return NULL;
		}else{
			addr_ptr = (struct in_addr *) *host_ent->h_addr_list ;
			host = inet_ntoa(*addr_ptr) ;
		}
	}
	
	//  Open UDP socket.
	 
	int	sockfd;
	if( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
		return NULL ;	// Can't open socket.
	
	 /*      Bind any local address.              */
	 
	memset((char *) &cli_addr,0,sizeof(cli_addr)) ;
	cli_addr.sin_family			= AF_INET ;
	cli_addr.sin_addr.s_addr	= htonl(INADDR_ANY) ;
	cli_addr.sin_port			= htons(0) ;


	if(bind(sockfd, (struct sockaddr *) &cli_addr,
		sizeof(cli_addr)) < 0){
		return NULL ;	// Can't bind local address
	}
	
	//Fill in the structure with the address of the server.	 
	Socket*	esock = new Socket;
	esock->socketfd = sockfd ;

	memset((char *) &esock->serv_addr,0, sizeof(esock->serv_addr)) ;
	esock->serv_addr.sin_family		= AF_INET ;
	esock->serv_addr.sin_addr.s_addr	= inet_addr(host) ;
	esock->serv_addr.sin_port			= htons(port) ;
/*
	int timeout = 1;
	setsockopt(sockfd, IPPROTO_TCP, SO_RCVTIMEO, (char*)(&timeout), sizeof(int));*/

/*    set the socket to be nonblocking		*/
/*
#ifdef WIN32
	unsigned long arp = 1;
	ioctlsocket(sockfd, FIONBIO, &arp);
#endif
*/
//	settononblock(sockfd);
	return esock ;
}

int Network::send_message(char *buf, Socket *esock)
{
	if (!buf || !esock) return 0;

	int n ;
	n = strlen(buf) ;
  
	if( sendto(esock->socketfd, buf, n+1, 0,
       (struct sockaddr *)&esock->serv_addr, sizeof(esock->serv_addr))!= n )
	   return (-1) ;
	else {
		return 0;
	}
}
	   
int Network::receive_message(char *buf, Socket *esock)
{
	int			n,servlen ;
	struct sockaddr_in	serv_addr ;

	servlen = sizeof(serv_addr) ;

#ifdef WIN32
	n = recvfrom(esock->socketfd, buf, MAXMESG, 0,
	       (struct sockaddr *)&serv_addr, &servlen);
#else //_LINUX
	n = recvfrom(esock->socketfd, buf, MAXMESG, 0,
	       (struct sockaddr *)&serv_addr, (socklen_t *) &servlen);
#endif

	if(n < 0){
#ifdef WIN32
		if( n == WSAETIMEDOUT) return n;
		if( n == -1 && errno == WSAEWOULDBLOCK) return 0 ;
#else //_LINUX
		if (n == -1 && errno == EWOULDBLOCK) return 0;
#endif
		else {
			fflush(stderr);
			return (-1) ;
		}
	}
	else{
		buf[n] = '\0' ;
		esock->serv_addr.sin_port = serv_addr.sin_port ;//?

		if(n == 0) {
			return 0 ;
		}else{
			return 1 ;
		}
	}
}


void Network::close_connection(Socket *esock)
{
	if(esock == NULL) return;
#ifdef WIN32
	shutdown(esock->socketfd, SD_BOTH);
	closesocket(esock->socketfd) ;
#else // _LINUX
	close(esock->socketfd);
#endif
}