2.txt

linux环境下的TCP网络服务器端实现原代码

不得不说的一个概念性问题：阻塞与非阻塞 
   在阻塞服务中，当服务器运行到accept语句而没有客户连接服务请求到来，那么会发生什么情况? 这时服务器就会停止在accept语句上等待连接服务请求的到来；同样，当程序运行到接收数据语句recv时，如果没有数据可以读取，则程序同样会停止在接收语句上。这种情况称为阻塞(blocking)。 
    但如果你希望服务器仅仅注意检查是否有客户在等待连接，有就接受连接;否则就继续做其他事情，则可以通过将 socket设置为非阻塞方式来实现:非阻塞socket在没有客户在等待时就使accept调用立即返回 。 
    通过设置socket为非阻塞方式，可以实现“轮询”若干socket。当企图从一个没有数据等待处理的非阻塞socket读入数据时，函数将立即返回，并且返回值置为-1，并且errno置为EWOULDBLOCK。但是这种“轮询”会使CPU处于忙等待方式，从而降低性能。考虑到这种情况，假设你希望服务器监听连接服务请求的同时从已经建立的连接读取数据，你也许会想到用一个accept语句和多个recv()语句，但是由于accept及recv都是会阻塞的，所以这个想法显然不会成功。 
    调用非阻塞的socket会大大地浪费系统资源。而调用select()会有效地解决这个问题，它允许你把进程本身挂起来，而同时使系统内核监听所要求的一组文件描述符的任何活动，只要确认在任何被监控的文件描述符上出现活动，select()调用将返回指示该文件描述符已准备好的信息，从而实现了为进程选出随机的变化，而不必由进程本身对输入进行测试而浪费CPU开销。 

    其次，并发服务器，在上述cycletcpserver.c中，由于使用了fork技术也可以称之为并发服务器，但这种服务器并不是真正意义上的IO多路复用的并发服务器，并且由于没有处理阻塞问题，实际应用有各种各样的问题。 

一个典型IO多路复用的单进程并发服务器流程如下： 
/*IO多路复用并发服务流程图*/ 

    下面是一个演示IO多路复用的源程序，是一个端口转发程序，但它的用处相当大，实际应用中的各类代理软件或端口映射软件都是基于这样的代码的，比如Windows下的WinGate、WinProxy等都是在此基础上实现的。源代码如下： 

/*----------------------源代码开始--------------------------------------------*/ 
#include <stdlib.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <sys/time.h> 
#include <sys/types.h> 
#include <string.h> 
#include <signal.h> 
#include <sys/socket.h> 
#include <netinet/in.h> 
#include <arpa/inet.h> 
#include <errno.h> 

static int forward_port; 

#undef max 
#define max(x,y) ((x) > (y) ? (x) : (y)) 

/*************************关于本文档************************************ 
*filename: tcpforwardport.c 
*purpose: 演示了select的用法，这是一个极好的代理软件核心，专门作端口映射用 
*tidied by: zhoulifa([e-mail]) 周立发(http://zhoulifa.bokee.com) 
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
*date time:2006-07-05 19:00:00 
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
* 但请遵循GPL 
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码 
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
*********************************************************************/ 

static int listen_socket (int listen_port) { 
    struct sockaddr_in a; 
    int s; 
    int yes; 
    if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) { 
        perror ("socket"); 
        return -1; 
    } 
    yes = 1; 
    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof (yes)) < 
0) { 
        perror ("setsockopt"); 
        close (s); 
        return -1; 
    } 
    memset (&a, 0, sizeof (a)); 
    a.sin_port = htons (listen_port); 
    a.sin_family = AF_INET; 
    if (bind(s, (struct sockaddr *) &a, sizeof (a)) < 0) { 
        perror ("bind"); 
        close (s); 
        return -1; 
    } 
    printf ("accepting connections on port %d\n", (int) listen_port); 
    listen (s, 10); 
    return s; 
} 

static int connect_socket (int connect_port, char *address) { 
    struct sockaddr_in a; 
    int s; 
    if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) { 
        perror ("socket"); 
        close (s); 
        return -1; 
    } 

    memset (&a, 0, sizeof (a)); 
    a.sin_port = htons (connect_port); 
    a.sin_family = AF_INET; 

    if (!inet_aton(address, (struct in_addr *) &a.sin_addr.s_addr)) { 
        perror ("bad IP address format"); 
        close (s); 
        return -1; 
    } 

    if (connect(s, (struct sockaddr *) &a, sizeof (a)) < 0) { 
        perror ("connect()"); 
        shutdown (s, SHUT_RDWR); 
        close (s); 
        return -1; 
    } 
    return s; 
} 

#define SHUT_FD1 { \ 
    if (fd1 >= 0) {   \ 
        shutdown (fd1, SHUT_RDWR);  \ 
        close (fd1);  \ 
        fd1 = -1;     \ 
    }   \ 
} 

#define SHUT_FD2 { \ 
    if (fd2 >= 0) {   \ 
        shutdown (fd2, SHUT_RDWR);  \ 
        close (fd2);  \ 
        fd2 = -1;     \ 
    }   \ 
} 

#define BUF_SIZE 1024 

int main (int argc, char **argv) { 
    int h; 
    int fd1 = -1, fd2 = -1; 
    char buf1[BUF_SIZE], buf2[BUF_SIZE]; 
    int buf1_avail, buf1_written; 
    int buf2_avail, buf2_written; 

    if (argc != 4) { 
        fprintf (stderr, "Usage\n\tfwd   \n"); 
        exit (1); 
    } 

    signal (SIGPIPE, SIG_IGN); 

    forward_port = atoi (argv[2]); 

    /*建立监听socket*/ 
    h = listen_socket (atoi (argv[1])); 
    if (h < 0) exit (1); 

    for (;;) { 
        int r, nfds = 0; 
        fd_set rd, wr, er; 
        FD_ZERO (&rd); 
        FD_ZERO (&wr); 
        FD_ZERO (&er); 
        FD_SET (h, &rd); 

        /*把监听socket和可读socket三个一起放入select的可读句柄列表里*/ 
        nfds = max (nfds, h); 
        if (fd1 > 0 && buf1_avail < BUF_SIZE) { 
            FD_SET (fd1, &rd); 
            nfds = max (nfds, fd1); 
        } 
        if (fd2 > 0 && buf2_avail < BUF_SIZE) { 
            FD_SET (fd2, &rd); 
            nfds = max (nfds, fd2); 
        } 

        /*把可写socket两个一起放入select的可写句柄列表里*/ 
        if (fd1 > 0 && buf2_avail - buf2_written > 0) { 
            FD_SET (fd1, &wr); 
            nfds = max (nfds, fd1); 
        } 
        if (fd2 > 0 && buf1_avail - buf1_written > 0) { 
            FD_SET (fd2, &wr); 
            nfds = max (nfds, fd2); 
        } 

        /*把有异常数据的socket两个一起放入select的异常句柄列表里*/ 
        if (fd1 > 0) { 
            FD_SET (fd1, &er); 
            nfds = max (nfds, fd1); 
        } 
        if (fd2 > 0) { 
            FD_SET (fd2, &er); 
            nfds = max (nfds, fd2); 
        } 

        /*开始select*/ 
        r = select (nfds + 1, &rd, &wr, &er, NULL); 

        if (r == -1 && errno == EINTR) continue; 
        if (r < 0) { 
            perror ("select()"); 
            exit (1); 
        } 

        /*处理新连接*/ 
        if (FD_ISSET (h, &rd)) { 
            unsigned int l; 
            struct sockaddr_in client_address; 
            memset (&client_address, 0, l = sizeof (client_address)); 
            r = accept (h, (struct sockaddr *)&client_address, &l); 
            if (r < 0) { 
                perror ("accept()"); 
            } else { 
                /*关闭原有连接，把新连接作为fd1，同时连接新的目标fd2*/ 
                SHUT_FD1; 
                SHUT_FD2; 
                buf1_avail = buf1_written = 0; 
                buf2_avail = buf2_written = 0; 
                fd1 = r; 
                fd2 = connect_socket (forward_port, argv[3]); 
                if (fd2 < 0) { 
                    SHUT_FD1; 
                } else 
                    printf ("connect from %s\n", inet_ntoa(client_address.sin_addr)); 
            } 
        } 

        /* NB: read oob data before normal reads */ 
        if (fd1 > 0) 
        if (FD_ISSET (fd1, &er)) { 
            char c; 
            errno = 0; 
            r = recv (fd1, &c, 1, MSG_OOB); 
            if (r < 1) { 
                SHUT_FD1; 
            } else 
                send (fd2, &c, 1, MSG_OOB); 
        } 

        if (fd2 > 0) 
        if (FD_ISSET (fd2, &er)) { 
            char c; 
            errno = 0; 
            r = recv (fd2, &c, 1, MSG_OOB); 
            if (r < 1) { 
                SHUT_FD1; 
            } else 
                send (fd1, &c, 1, MSG_OOB); 
        } 

        /* NB: read data from fd1 */ 
        if (fd1 > 0) 
        if (FD_ISSET (fd1, &rd)) { 
            r = read (fd1, buf1 + buf1_avail, BUF_SIZE - buf1_avail); 
            if (r < 1) { 
                SHUT_FD1; 
            } else 
                buf1_avail += r; 
        } 

        /* NB: read data from fd2 */ 
        if (fd2 > 0) 
        if (FD_ISSET (fd2, &rd)) { 
            r = read (fd2, buf2 + buf2_avail, BUF_SIZE - buf2_avail); 
            if (r < 1) { 
                SHUT_FD2; 
            } else 
                buf2_avail += r; 
        } 

        /* NB: write data to fd1 */ 
        if (fd1 > 0) 
        if (FD_ISSET (fd1, &wr)) { 
            r = write (fd1, buf2 + buf2_written, buf2_avail - buf2_written); 
            if (r < 1) { 
                SHUT_FD1; 
            } else 
                buf2_written += r; 
        } 

        /* NB: write data to fd1 */ 
        if (fd2 > 0) 
        if (FD_ISSET (fd2, &wr)) { 
            r = write (fd2, buf1 + buf1_written, buf1_avail - buf1_written); 
            if (r < 1) { 
                SHUT_FD2; 
            } else 
                buf1_written += r; 
        } 

        /* check if write data has caught read data */ 
        if (buf1_written == buf1_avail) buf1_written = buf1_avail = 0; 
        if (buf2_written == buf2_avail) buf2_written = buf2_avail = 0; 

        /* one side has closed the connection, keep writing to the other side until empty */ 
        if (fd1 < 0 && buf1_avail - buf1_written == 0) { 
            SHUT_FD2; 
        } 
        if (fd2 < 0 && buf2_avail - buf2_written == 0) { 
            SHUT_FD1; 
        } 
    } 
    return 0; 
} 
/*----------------------源代码结束--------------------------------------------*/