Linux网络编程：使用select函数实现socket 收发数据

我就是我 2022-01-13 09:11 260阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

所谓的回射是指：客户端A向服务端B发送数据，服务端B接收到数据之后，再将接收到的数据发送回客户端B。所谓的迭代服务器，是指服务器端只用一个进程处理或线程处理所有客户端的请求。与之对应的是并发服务器，并发服务器是指对于每一一个客户端的请求，服务端都分配一个进程或是线程独立来处理客户端的处理。下面介绍使用select函数实现TCP回射迭代服务。直接上代码：

服务端程序：

/\*=============================================================================  
\#     FileName: tcpservselect.c  
\#         Desc: receive client data and then send they back.  
\#       Author: Licaibiao  
\#   LastChange: 2017-02-12   
=============================================================================\*/  
\#include<stdio.h>    
\#include<sys/types.h>    
\#include<sys/socket.h>    
\#include<unistd.h>    
\#include<stdlib.h>    
\#include<errno.h>    
\#include<arpa/inet.h>    
\#include<netinet/in.h>    
\#include<string.h>    
\#include<signal.h>  
\#define MAXLINE      1024  
\#define LISTENLEN 10  
\#define SERV\_PORT 6666  
   
int main(int argc, char \*\*argv)  
\{  
    int                    i, maxi, maxfd, listenfd, connfd, sockfd;  
    int                    nready, client\[FD\_SETSIZE\];  
    ssize\_t                n;  
    fd\_set                rset, allset;  
    char                buf\[MAXLINE\];  
    socklen\_t            clilen;  
    struct sockaddr\_in    cliaddr, servaddr;  
   
    listenfd = socket(AF\_INET, SOCK\_STREAM, 0);  
   
    bzero(&servaddr, sizeof(servaddr));  
    servaddr.sin\_family      = AF\_INET;  
    servaddr.sin\_addr.s\_addr = htonl(INADDR\_ANY);  
    servaddr.sin\_port        = htons(SERV\_PORT);  
   
    bind(listenfd, (struct sockaddr\*) &servaddr, sizeof(servaddr));  
   
    listen(listenfd, LISTENLEN);  
   
    maxfd = listenfd;            /\* initialize \*/  
    maxi = -1;                    /\* index into client\[\] array \*/  
    for (i = 0; i < FD\_SETSIZE; i++)  
        client\[i\] = -1;            /\* -1 indicates available entry \*/  
    FD\_ZERO(&allset);  
    FD\_SET(listenfd, &allset);  
   
    for ( ; ; )   
    \{  
        rset = allset;        /\* structure assignment \*/  
        nready = select(maxfd+1, &rset, NULL, NULL, NULL);  
   
        if (FD\_ISSET(listenfd, &rset)) /\* new client connection \*/  
        \{      
            clilen = sizeof(cliaddr);  
            connfd = accept(listenfd, (struct sockaddr\*) &cliaddr, &clilen);  
\#ifdef    NOTDEF  
            printf("new client: %s, port %d\\n",  
                    inet\_ntop(AF\_INET, &cliaddr.sin\_addr, 4, NULL),  
                    ntohs(cliaddr.sin\_port));  
\#endif  
   
            for (i = 0; i < FD\_SETSIZE; i++)  
                if (client\[i\] < 0) \{  
                    client\[i\] = connfd;    /\* save descriptor \*/  
                    break;  
                \}  
            if (i == FD\_SETSIZE)  
            \{  
                printf("too many clients");  
                exit(0);  
            \}  
   
            FD\_SET(connfd, &allset);    /\* add new descriptor to set \*/  
            if (connfd > maxfd)  
                maxfd = connfd;            /\* for select \*/  
            if (i > maxi)  
                maxi = i;                /\* max index in client\[\] array \*/  
   
            if (--nready <= 0)  
                continue;                /\* no more readable descriptors \*/  
        \}  
   
        for (i = 0; i <= maxi; i++)     /\* check all clients for data \*/  
        \{      
            if ( (sockfd = client\[i\]) < 0)  
                continue;  
            if (FD\_ISSET(sockfd, &rset))   
            \{  
                if ( (n = read(sockfd, buf, MAXLINE)) == 0)/\* connection closed by client \*/   
                \{  
                    close(sockfd);  
                    FD\_CLR(sockfd, &allset);  
                    client\[i\] = -1;  
                \} else  
                    write(sockfd, buf, n);  
   
                if (--nready <= 0)  
                    break;                /\* no more readable descriptors \*/  
            \}  
        \}  
    \}  
\}  
   
在服务端的程序中，我们使用select 来处理任意个客户的单进程程序，而不是派生一个子程序。  
客户端程序：

/\*=============================================================================  
\#     FileName: tcpcliselect.c  
\#         Desc: send data to server and receive data from server  
\#       Author: Licaibiao  
\#   LastChange: 2017-02-12   
=============================================================================\*/  
\#include<stdio.h>    
\#include<sys/types.h>    
\#include<sys/socket.h>    
\#include<unistd.h>    
\#include<stdlib.h>    
\#include<errno.h>    
\#include<arpa/inet.h>    
\#include<netinet/in.h>    
\#include<string.h>    
\#include<signal.h>  
\#define MAXLINE      1024  
\#define LISTENLEN 10  
\#define SERV\_PORT 6666  
   
int max(int a, int b)  
\{  
    return a>b ? a : b;  
\}  
   
void str\_cli(FILE \*fp, int sockfd)  
\{  
    int            maxfdp1, stdineof;  
    fd\_set        rset;  
    char        buf\[MAXLINE\];  
    int        n;  
   
    stdineof = 0;  
    FD\_ZERO(&rset);  
    for ( ; ; )   
    \{  
        if (stdineof == 0)  
            FD\_SET(fileno(fp), &rset);  
        FD\_SET(sockfd, &rset);  
        maxfdp1 = max(fileno(fp), sockfd) + 1;  
        select(maxfdp1, &rset, NULL, NULL, NULL);  
   
        if (FD\_ISSET(sockfd, &rset))   
        \{      
            if ( (n = read(sockfd, buf, MAXLINE)) == 0) /\* socket is readable \*/  
            \{  
                if (stdineof == 1)  
                    return;        /\* normal termination \*/  
                else  
                    printf("str\_cli: server terminated prematurely");  
            \}  
            write(fileno(stdout), buf, n);  
        \}  
   
        if (FD\_ISSET(fileno(fp), &rset))  /\* input is readable \*/  
        \{    
            if ( (n = read(fileno(fp), buf, MAXLINE)) == 0)   
            \{  
                stdineof = 1;  
                shutdown(sockfd, SHUT\_WR);    /\* send FIN \*/  
                FD\_CLR(fileno(fp), &rset);  
                continue;  
            \}  
   
            write(sockfd, buf, n);  
        \}  
    \}  
\}  
   
int main(int argc, char \*\*argv)  
\{  
    int    sockfd;  
    struct sockaddr\_in    servaddr;  
   
    if (argc != 2)  
    \{  
        printf("usage: tcpcli <IPaddress>");  
        exit(0);  
    \}  
    sockfd = socket(AF\_INET, SOCK\_STREAM, 0);  
   
    bzero(&servaddr, sizeof(servaddr));  
    servaddr.sin\_family = AF\_INET;  
    servaddr.sin\_port = htons(SERV\_PORT);  
    inet\_pton(AF\_INET, argv\[1\], &servaddr.sin\_addr);  
   
    connect(sockfd, (struct sockaddr\*) &servaddr, sizeof(servaddr));  
   
    str\_cli(stdin, sockfd);        /\* do it all \*/  
   
    exit(0);  
\}  
   
   
    在第60行我们使用了shutdown函数。我们知道，TCP是全双工工作，在我们做批量输入批量输出的时候，我们客户端已经把数据发送完毕，这个时候并不能直接关闭描述符，因为可能还有数据在从服务端发送回来的路上。close函数是直接终止读和写两个方向的数据传送。但是使用shutdown可以单方向关闭数据传输。  
    在客户端，我们使用Ctrl + d 来结束客户端程序。Ctrl + d 会发送一个exit 。在TCP传输中，如果对端TCP发送一个FIN（finish 对端进程终止），那么该套接字变为可读，并且read返回0（EOF）

运行结果：

运行服务端程序

root[@ubuntu][ubuntu]:/home/share/test\# ./strserselect  
另外一个终端运行客户端程序：  
root[@ubuntu][ubuntu]:/home/share/test\# ./strcliselect 127.0.0.1  
china                        /\*发送\*/  
china                        /\*接收\*/

注意：上面的程序存在一个问题，如果有一个恶意客户端只发送一个字节数据（不是换行符）后进入睡眠，服务器调用read读入一个字节，后面就阻塞在read函数以等待其他的数据，这样一来服务端就阻塞在一个客户端，不能再处理其他客户端的请求(拒绝服务型攻击)  
解决上面问题有下面的几种方法：

（a）使用非阻塞式IO

（b）对IO操作设置一个超时

（c）让每个客户由单独的控制线程提供服务

\---------------------   
作者：li\_wen01   
来源：CSDN   
原文：https://blog.csdn.net/li\_wen01/article/details/55004918   
版权声明：本文为博主原创文章，转载请附上博文链接！

转载于:https://my.oschina.net/u/4000302/blog/3044645

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220113/15bfe308dc544f98b88b04d62c13ac0b.png
[ubuntu]: https://my.oschina.net/u/555627