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[FD_SETSIZE] = { 0 };

//
int tcp_server_init(int port);
//
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 g_select(int n, fd_set  *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

////////////////////////////////////////////////////////
int connect_to_center(int trynum,int wait_second);
int connect_accept( int server_fd, fd_set *rset, int &connect_fd );
int connect_process( fd_set *rset );
int process_accept ( int server_fd );


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

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

     process_accept( server_fd );

    /*

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

	for(;;)
    //while ( FD_ISSET( server_fd, &rset ) )
	{//1
		printf( "select ...\n" );
		nready = g_select(FD_SETSIZE, &rset, NULL, NULL, NULL);

		if (nready==0) continue;
		if (nready<0)
		{//2
			//log("!!!select error!");
			printf("!!!select error!\n");
			continue;
		}//2
		printf( "select success.\n" );


        connect_fd = accept( server_fd, (struct sockaddr *)NULL, NULL);
        if (connect_fd <= 0)
    	{
	    	printf("accept error !");
            continue;
    	}
    	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;
                    printf( "i = %d\n", i );
					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);
				continue;
			}//3
	    FD_SET(connect_fd, &rset);
        printf( "connect_fd = %d\n", connect_fd );

		//nready--;
		//maxbi++;
		puts( "connect_accept success." );	
		//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  g_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 = port;
	struct sockaddr_in serv_addr;

    int m_serv_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (m_serv_sockfd == -1) {
        printf("serv_socket error\n");
        exit(0);
    }

    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)) == -1) 
	{
        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, 20) == -1) {
        printf("listen error\n");
        exit(1);
    }
    return m_serv_sockfd;
}

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 = 0;
    int j = 0;
    char buf[1024];
    int len=0;
    
	//while (j++<100)
    {
	    for(i=0;i<FD_SETSIZE;i++)
    	{//2
            len = 0;
            //printf( "i=%d\n", i );
	    	if (FD_ISSET(g_link[i], rset)) 
		    {//3
                printf( "i=%d\n", i );
                //send( g_link[i], "xx", 2, 0 );
                puts( "read" );
    			bzero(buf,1024);
 		    	len = recv( g_link[i], buf, 100, 0);
          
                if ( len > 0 )
                {
                     buf[len] = 0;
                     printf( "receive len: %d.", len);
                     printf( "%s\n", buf );
                     
                }
                else
                {
                    strcpy( buf, "nothing to receive." );
                    len = strlen( buf );
                    close( g_link[i] );
                    FD_CLR( g_link[i], rset);
                    g_link[i] = 0;
              
                }
                send( g_link[i], buf, len, 0); 
            }
        }
        // if ( len > 0 ) break;
        // usleep( 1000 );
     }
     printf( "connect end\n" );
     return 1;
				/*		
					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
				//*/	
             

						//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);
				
		//}//3
	//}//2	
}

int   process_accept( int server_fd )
{
    int connect_fd;
    int i=0;
    char str[256] = "";
    int len;
    
    //while( 1 )
    {
        connect_fd = accept( server_fd, (struct sockaddr *)NULL, NULL);
        if ( connect_fd == -1 )
        {
            perror( "accept error!" );
            exit(1);
        }
        printf( "send data\n" );
        while ( 1 )
        {
            len = recv( connect_fd, str, 256, 0 );
            if (len>0 )
            {
                printf( "Recive: %s\n", str );
                send( connect_fd, str, strlen( str ), 0 );
            }
            if ( strcmp( str, "quit" )==0 )
               break;    
        }
    }
    return 1;
}