server.cpp~

tcp/ip服务端测试源码

#include <stdio.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <errno.h>
#include <netdb.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <termios.h>
#include <string.h>

//
char g_center_host[16] = "127.0.0.1";
char g_center_port[8]  = "8001";
int  g_link[20];

//
int connect_to_center(int trynum,int wait_second);
int tcp_connect2(const char *host, const char *serv);
int g_create_thread(pthread_t &tid, pthread_attr_t *attr, void*(*thread_proc)(void *),  void * param );
int tcp_server_init(int port);
int  Select(int n, fd_set  *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
int connect_accept( int server_fd, fd_set rset, int &connect_fd );
int connect_process( fd_set rset );

int main(int argc, int *argv[])
{
	fd_set rset;
	int server_fd;
	int connect_fd;
	int nready;


	printf( "start...\n" );
	server_fd = tcp_server_init( 8001 );

	printf( "init success.\n" );
	FD_ZERO(&rset);
	FD_SET(server_fd, &rset);

	for(;;)
	{//1
		printf( "select ...\n" );
		nready = Select(FD_SETSIZE, &rset, NULL, NULL, NULL);
		printf( "select success.\n" );
		if (nready==0) continue;
		if (nready<0)
		{//2
			//log("!!!select error!");
			printf("!!!select error!\n");
			continue;
		}//2
		
		if ( -1 == connect_accept( server_fd, rset, connect_fd ) )
		{
			continue;
		}
		//nready--;
		//maxbi++;
			
		//deal up			
		connect_process( rset );
	
	}//1
}


int tcp_connect2(const char *host, const char *serv)
{
     struct sockaddr_in addr;
     struct hostent *hostaddr;
     int s;
     int reuse;
     int port;
     
     port=atoi(serv);
     s = socket(PF_INET, SOCK_STREAM, 0);
     if (s == -1) return -1;
     
     hostaddr=gethostbyname(host);
     if(!hostaddr)
     {
     	return -1;
     }	
     
     bzero(&addr,sizeof(addr));
  	
     addr.sin_family = AF_INET;
     addr.sin_port = htons(port);
     addr.sin_addr.s_addr = htonl(INADDR_ANY);
     memcpy(&addr.sin_addr.s_addr,hostaddr->h_addr,hostaddr->h_length);
     		
     if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
	  close(s);
	  return -1;
     }
     return (s);
}

int connect_to_center(int trynum,int wait_second)
{
	int fd,i=0;
	for(;;)
	{
		printf( "count: %d\n", i );
		fd = tcp_connect2(g_center_host, g_center_port);
		if(fd > 0) return fd;
		printf( "connect failed!\n" );
		if(trynum == -1 || i++ < trynum)
		{
			sleep(wait_second);
			continue;
		}
		else break;
	}
	return fd;
}




int  Select(int n, fd_set  *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
{
    int ret;
try_again:
    ret = select(n, readfds, writefds, exceptfds, timeout);
    if (ret < 0) {
        switch (errno) {
        case EINTR:
            goto try_again;
        case EAGAIN:
            goto try_again;
        case EBADF:
        default:
            break;
        }
    }
    return ret;
}


/////////////////////////////////////////////////////////////////////////////////////////////////////
// create thread

int g_create_thread(pthread_t &tid, pthread_attr_t *attr, void*(*thread_proc)(void *),  void * param )
{
	pthread_attr_t attr1;
	if (attr==NULL)
		attr = &attr1;
	int prilocy;
	pthread_attr_init(attr);	
	pthread_attr_setschedpolicy(attr,1);
	
	if(pthread_create(&tid,attr,thread_proc,param)!=0)
	{
		return -1;
	}
	
	if(pthread_detach(tid)!=0)
	{
		return -1;
	}
	return 0;
}


int tcp_server_init(int port)
{
    int on = 1;
    short serv_port;
	struct sockaddr_in serv_addr;
	
    serv_port = port;
    int m_serv_sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (m_serv_sockfd < 0) {
        printf("serv_socket error\n");
        exit(0);
    }

    // allow local address reuse and periodicall test if connection still alive
//    setsockopt(serv_sockfd[i], SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
//    setsockopt(serv_sockfd[i], SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));

    bzero(&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_port);

    if (bind(m_serv_sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) 
	{
        printf("bind serv_sockfd error\n");
        exit(1);
    }

//    if (fcntl(serv_sockfd, F_SETFL, fcntl(serv_sockfd[i],
//       F_GETFL, 0) | O_NONBLOCK) < 0)
//        printf("fcntl error\n");

    if (listen(m_serv_sockfd, 1) < 0) {
        printf("listen error\n");
        exit(1);
    }
    return m_serv_sockfd;

//    serv_link_state[i] = 0;
}

int connect_accept( int server_fd, fd_set rset, int &connect_fd )
{
	int i;
	
	//if(FD_ISSET( serv_sockfd, &rset))
	//{
	connect_fd = accept( server_fd, (struct sockaddr *)NULL, NULL);

	if (connect_fd < 0) 
	{
		printf("accept error !");
	}
	if(connect_fd <= 0) return -1;

	printf("A new up client join in!\n");
			
	for(i=0;i<FD_SETSIZE;i++)
			{
				if(g_link[i] <= 0)
				{//3
					g_link[i] = connect_fd;
					break;
				}//3
			}
			
	if(i == FD_SETSIZE)
			{//3
				printf("!!!Too many clients!\n ");
				printf("System will refuse the other client's connect request!\n");	
				close(connect_fd);
				return -1; 
			}//3

	FD_SET(connect_fd, &rset);
	return 0;	
}


int connect_process( fd_set rset )
{
	int i, j;
	
	for(i=0;i<FD_SETSIZE;i++)
	{//2
		if (FD_ISSET(i, &rset)) 
		{//3
					char buf[1024];
					bzero(buf,1024);
					int len = read(i,buf,1024);
				/*		
					if(len <= 0)
					{//4
						close(i);
						printf("!!! One UP client disconnect!\n");
						FD_CLR(i,&rset);
						for(j=0;j<FD_SETSIZE;j++)
						{ 
							if(g_link[j]<=0)
								continue;
							if(g_link[j]==i)
							{
								g_link[j] = -1;
								break;
							}		
						}
						//maxbi--;
					}//4
				//*/	
			if (len >0)
					{//4  
					//from up Client To down
						printf("from up Client To down msg:\n");
						puts( buf );
						//log(buf,len);
						//get_hex_data(buf,len);
						//for(i=0;i<FD_SETSIZE;i++)
						{
							//if(m_link.client[i]<0) continue;
							//write(g_link[i],buf,len);
						}
						//list_produce(incoming, p);
					} //4 	
		}//3
	}//2	
}