疯狂的bug【select -IO复用中】

最新推荐文章于 2022-02-28 12:50:41 发布
最新推荐文章于 2022-02-28 12:50:41 发布
阅读量1.1k 收藏
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fall221/article/details/8986938
版权

    select版本的回显服务，初期的bug是，客户端可以连接上服务器，但是客户端发送字符串过来以后，服务器的select却阻塞在那里，死活没反映。。。gdb调试查看了fd_set类型的值，也发现的确是有两个值的叠加的——一个是监听套接字，一个是刚刚连接上的客户套接字。这就奇怪了！直到看到 http://bbs.csdn.net/topics/230024080 上别人的提问，最后他说：解决了，原因是我的socket集中混进了一个 错误的socket，select一直报10038的错误，

于是我也开始找这方面的错误，但是找不到，最后与标准代码对比，才发现错误的原因，是select第一个参数设置错误。

错误代码：服务器ser.c

#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>

#define CONN_MAX 10000
#define cerror(str) do{perror(str); exit(EXIT_FAILURE);}while(0)

int sock_init_ser(int is_any, 
            const char *addr,
            int port,
            int backlog);
            
void do_client_sock(int *pcd);

int conn_fd[CONN_MAX];
int conn_n;   // 当前数组中最大可用的元素序号+1，检查时，>=conn_n的元素可以跳过
int fd_max;

/*
 *   MAIN
 *   回显服务的服务器端
 *   使用select实现
 */
int main(int argc, char * argv[])
{
    int sd;
    fd_set fs;
    int i;
    
    if(argc<3)
    {
        printf("Usage: argv[0] port backlog [ipaddr]\n");
        exit(0);
    }
    
    if (argc>=4)
    {
        sd=sock_init_ser(0,argv[3],atoi(argv[1]), atoi(argv[2]));
    }else
    {
        sd=sock_init_ser(1,NULL,atoi(argv[1]), atoi(argv[2]));
    }
     
                   
    for(i=0; i<CONN_MAX; i++) // init to -1
    {
        conn_fd[i]=-1;
    }
    conn_n=0;
    fd_max=sd;
    while(1)
    {
        int sr;
        FD_ZERO(&fs);
        FD_SET(sd, &fs);
        fd_max=sd;
        for (i=0; i<conn_n; i++)
        {
            if (conn_fd[i]!=-1)
            {               // continue;
                FD_SET(conn_fd[i], &fs);
                if(i>fd_max)
                {
                    fd_max=i;//conn_fd[i]; // 不是fd_max=i  !!!
                } 
            } 
        } 
        sr = select(fd_max+1, &fs, NULL, NULL, NULL);  // select
        if (sr<0)   // select error
        {
            perror("select");
            continue;
        }
        if(sr==0)  // select timeout
        {
            continue;
        }
        
        for (i=0; i<conn_n; i++)
        {
            if(conn_fd[i]!=-1 && FD_ISSET(conn_fd[i], &fs))
                 do_client_sock(conn_fd+i);  // echo back
        }
        
        // listen socket
        if (FD_ISSET(sd, &fs))
        {
            int cd=accept(sd, NULL, NULL);
            if(cd<0)
            {
                if(errno == EINTR)
                {
                    continue;
                }
                else
                {
                    perror("accept");
                    continue;
                }
            }
            // 
            for(i=0; i<conn_n+1; i++) // or i<CONN_MAX
            {
                if(conn_fd[i]==-1)
                {
                     conn_fd[i]=cd;
                     printf("add a new client\n");
                     break;
                }
            }
            if(i>=CONN_MAX-1)
            {
                close(cd);
                conn_fd[i]=-1;
                printf("conn_fd full\n");
                continue;
            }
            if(i>=conn_n)
                conn_n=i+1;
                
            printf("conn_n= %d\n",conn_n);
        }
        
    }
    
    close(sd);
    return 0;
}

/*
 * sock_init_ser
 * is_any为0时，需要指定IP地址，为非零时，IP地址字段被忽略，使用INADDR_ANY
 * port为端口号，backlog为监听个数
 */
int sock_init_ser(int is_any, 
            const char *addr,
            int port,
            int backlog)
{
    int sd;
    struct sockaddr_in sin;
    
    sd=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(sd<0)
    {
        cerror("socket");
    }
    memset(&sin, 0, sizeof(sin) );
    sin.sin_family = AF_INET;
    sin.sin_port = htons(port);
    if (is_any)
    {
        sin.sin_addr.s_addr = htonl(INADDR_ANY);
    }else
    {
        inet_pton(AF_INET, addr, &(sin.sin_addr));
    }
    if (bind(sd, (struct sockaddr*)&sin,sizeof(sin))<0)  
    {
        cerror("bind");
    }
    
    if(listen(sd,backlog)<0)
        cerror("listen");
    printf("server open addr: %d\n", ntohs(sin.sin_port));
    return sd;
    
}

/*
 * do_client_sock
 * 监听客户套接子，有消息到来则read，然后打印到标准输出，
 * 并发回给客户，同时需要处理关闭和出错，此时需要将客户套接子从数组里删除。
 */
void do_client_sock(int *pcd)
{
    char buf[256];
    int nr = read(*pcd, buf, 256-1);
    if(nr<0)
    {
        perror("read\n");
        close(*pcd);
        *pcd=-1;
        printf("del a client\n");
        return;
    }
    if (nr==0)
    {
        close(*pcd);
        *pcd=-1;
        printf("del a client\n");
        return;
    }
    printf("recv: %s\n", buf);
    write(*pcd, buf, 256-1);
}
客户端： 

#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>

#define cerror(str) do{perror(str); exit(EXIT_FAILURE);}while(0)


int sock_init_client( const char *addr,  int port);
            
void do_client_sock(int cd);

/*
 *   MAIN
 *   回显服务的客户端程序，使用格式形如client 5778 192.168.1.105
 *   连接以后，发送some test string by %d, seq: %d字符串给服务器，第一个整数是进程id
 *   第二个整数是序号，从1开始递增。完成一次回显以后，休眠10s，随后开始下一个。
*/
int main(int argc, char * argv[])
{
    int cd;
   
    if(argc<3)
    {
        printf("Usage: argv[0] port ipaddr");
    }
    
    cd= sock_init_client(argv[2], atoi(argv[1])) ;
    do_client_sock(cd);
    
    return 0;                  
}

/*
 * do_client_sock
 * 连接完成以后执行循环回显
*/
void do_client_sock(int cd)
{
    while(1)
    {
        char buf[256];
        static int seqnum=1;
        int nr;
        snprintf(buf, sizeof(buf), "some test string by %d, seq: %d",getpid(), seqnum++);
        nr=write(cd, buf, strlen(buf));
        if(nr!=strlen(buf))
            printf("write error\n");
        nr = read(cd, buf, 256-1);
        if(nr<0)
        {
            perror("read\n");
            close(cd);
            exit(1);
        }
        if (nr==0)
        {
            close(cd);
            exit(1);
        }
        buf[strlen(buf)]='\0';
        printf("echo back: %s\n", buf);
        sleep(10);
    }
}

/*
 * sock_init_client
 * 给定IP地址和端口号，执行连接
 */
int sock_init_client( const char *addr,  int port)
{
    int cd;
    struct sockaddr_in sin;
    
    cd=socket(AF_INET, SOCK_STREAM, 0);
    if(cd<0)
    {
        cerror("socket");
    }
    memset(&sin, 0, sizeof(sin) );
    sin.sin_family = AF_INET;
    sin.sin_port = htons(port);
    inet_pton(AF_INET, addr, &(sin.sin_addr));
    
    if (connect(cd, (struct sockaddr*)&sin, sizeof(sin) )<0)
    {
        cerror("connect");
    }
    
    return cd;
    
}

错误的地方在ser.c: 

  for (i=0; i<conn_n; i++)
        {
            if (conn_fd[i]!=-1)
            {               // continue;
                FD_SET(conn_fd[i], &fs);
                if(i>fd_max)
                {
                    fd_max=i;//conn_fd[i]; // 不是fd_max=i  !!!
                } 
            } 
        }
套接字描述是一个个分配的，监听套接字先分配，accept进来的客户套接字后分配，所以客户套接字会比监听套接字大。而conn_n在第一次accept进一个或若干个客户后，值为1或2，3.。。。因此，用i去于fd_max比，是不正确的。假如只有一个客户，那么循环一次就退出，i=0肯定小于fd_max,因此fd_max最后只囊括了监听套接字，客户套接字忽略了。

因此应该改为

  for (i=0; i<conn_n; i++)
        {
            if (conn_fd[i]!=-1)
            {               // continue;
                FD_SET(conn_fd[i], &fs);
                if(conn_fd[i]>fd_max)
                {
                    fd_max=conn_fd[i]; // 不是fd_max=i  !!!
                } 
            } 
        }

运行：

服务器：

administrator@ubuntu:~/mytest$ ./ser 8887 5 192.168.1.105
server open addr: 8887
add a new client
conn_n= 1
recv: some test string by 5757, seq: 1
recv: some test string by 5757, seq: 2
recv: some test string by 5757, seq: 3
recv: some test string by 5757, seq: 4
recv: some test string by 5757, seq: 5
recv: some test string by 5757, seq: 6


客户：

administrator@ubuntu:~/mytest$ ./client 8887 192.168.1.105
echo back: some test string by 5757, seq: 1
echo back: some test string by 5757, seq: 2
echo back: some test string by 5757, seq: 3
echo back: some test string by 5757, seq: 4
echo back: some test string by 5757, seq: 5
echo back: some test string by 5757, seq: 6



纯属虚构
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
select-IO多路复用
Zxn、Sirius荣耀之路
10-29 860
1、基本概念 IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： 当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。 如果一个服务器即要处理TCP，又要处理UD
网络编程----IO复用之select模型
hailong0715的专栏
04-06 3243
前一篇文章提到了，多线程/多进程虽然能够在一定程度上解决并发，但是由于进程/线程的切换消耗系统资源，多余并发量比较大的服务无法支持，因此为了解决大并发场景，需要一种能够支持更多并发的方法----IO复用， 与多线程/进程相比，IO复用最大的优点是避免了线程进程切换时产生的系统开销，内核不用创建线程也不用再维护这些线程了，这样就避免了很多不必要的开销。 本文介绍一种IO复用模型，select模型，
Tcp accept 10038错误
naezhou的专栏
10-01 4227
问题：自己做着东西玩，一个对话框界面的服务器端，对话框上面有两个Button，一个用于启动服务器工作，一个用来停止服务器。第一次启动和停止的时候工作都正常，当停止服务器再启动的时候，在Tcp监听线程中accept（）出错，错误代码10038。资料：MSDN上对10038的描述WSAENOTSOCK10038Scoket operation on nonsocket.Anoperation wa
socket select设置延时 错误码10038
qq_42136233的博客
12-08 1552
初始化套接字后，在select之前又关闭了套接字，造成select返回-1,错误码：10038
在windows下使用python中的select函数报错‘[WinError 10038] 在一个非套接字上尝试了一个操
lch551218的博客
01-18 7631
注意：Python的select方法在Windows和Linux环境下的表现是不一样的，Windows下它只支持socket对象，不支持文件描述符（file descriptions)，而Linux两者都支持。因此，当select函数的第一个参数数组中包含非socket对象时（字符串），就会报‘[WinError 10038] 在一个非套接字上尝试了一个操作。’错误！ ...
select函数--IO多路复用详解
玫瑰花店的博客
01-22 1577
本章基于网络编程，需要学习网络编程的可以看我这篇博客： socket编程（超简单、详细、可运行）–实现一个简单的聊天程序 什么是多路复用IO呢？ 多路io：允许同时对多个I/O进行控制 可能这样说还是有点抽象，stm32下面有GPIO口，如果我需要一个LED屏幕连接在32开发板上面，是不是又很多的接线，每个接线接着板子上面的对应引脚上面，既然我们接线这个引脚了，是不是首先需要让这个引脚处于使能状态，这就是开时钟，多个引脚我们是不是要开多个引脚的时钟。配置好后我们的开发板的处理器是不是会按照需要去对这些IO口
IO多路复用（select）
椛茶的博客
02-28 1274
IO 多路复用技术是指由进程通知内核监听指定的一个或多个 IO 事件，当 IO 事件发生时由内核通知唤醒进程，它一般用在一个进程需要同时监听处理多个 IO 事件的场景，与多进程或多线程的方式相比，使用 IO 多路复用技术无需创建多个进程或线程，减少系统开销。本文将介绍 select 函数的用法，它允许进程通知内核监听多个 IO 事件，并在事件发生或者设置的超时时间到达时唤醒进程处理。
掌握golang select IO多路复用
热门推荐
张成基
08-05 2万+
select作用 Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。. select的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。 与switch语句相比，select有比较多的限制，其中最大的一条限制就是每个case语句后面必须是一个**Io操作** 。 大致的结构如下： select{ case <-chan1: //如果chan1成功读到数据，则进行该case处理语句 case ch
IO多路复用---select详解及示例
weixin_46566893的博客
11-23 1573
一、IO多路复用 I/O复用使得程序能同时监听多个文件描述符，这使得程序的性能得到了很大程度的提高。 Linux下实现I/O复用的系统调用主要有select、poll、epoll。（这里注意：epoll是Linux系统所特有的） 二、select系统调用 select系统调用的用途：在一段时间内，监听文件描述符上的可读、可写、和异常时间的发生。本文主要介绍select系统调用API。 三、select API及主要函数说明 #include<sys/select.h> int select(in
Linux内核剖析-----IO复用函数epoll内核源码剖析
Eunice_fan1207的博客
08-16 2561
本文参考董浩博客http://donghao.org/uii/ epoll内核实现 （1）内核为epoll做准备工作 这个模块在内核初始化时（操作系统启动）注册了一个新的文件系统，叫"eventpollfs"（在eventpoll_fs_type结构里），然后挂载此文件系统。另外还创建两个内核cache（在内核编程中，如果需要频繁分配小块内存，应该创建kmem_ca...
记linux下IO复用--IO复用的学习
这是一个博客
03-21 679
1.区分堵塞、非堵塞 在一个IO操作过程中，以read为例，会涉及到两个过程： 1.等待数据准备好； 2.将数据从内核拷贝到进程中 这两个阶段是否发生阻塞，将产生不同的效果。 堵塞IO： 进程在请求read阻塞io的数据时，操作需要彻底完成后才返回到用户空间 非堵塞IO: 进程在步骤1不堵塞，如果数据没准备好，read（io操作）函数会立即返回一个状态值反馈给进程，所以对于非阻塞io，可以用一个w...
io多路复用中select底层数据结构
最新发布
09-01
在多路复用中，`select` 函数是一种常用的方法。`select` 函数使用了一个名为 `fd_set` 的数据结构来管理文件描述符的状态。`fd_set` 是一个位掩码（bitmask），它可以表示一组文件描述符。 `fd_set` 的底层数据结构通常是一个数组，数组的每个元素对应一个文件描述符。通过设置数组元素的值来表示文件描述符的状态。`fd_set` 使用位操作来操作数组元素，以便设置、清除和检查文件描述符的状态。 具体来说，`fd_set` 结构体定义如下： ```c typedef struct fd_set { unsigned int fd_count; int fd_array[FD_SETSIZE]; } fd_set; ``` 其中，`fd_count` 表示 `fd_array` 中有效的文件描述符数量，`FD_SETSIZE` 是一个常量，表示 `fd_array` 的最大长度。 在使用 `select` 函数之前，需要使用宏函数 `FD_ZERO` 将 `fd_set` 初始化为空集合，然后使用 `FD_SET` 宏函数将需要监听的文件描述符加入到 `fd_set` 中。调用 `select` 函数后，会根据文件描述符的状态修改 `fd_set` 中对应的位。 需要注意的是，因为 `fd_set` 使用位掩码表示文件描述符的状态，所以它的大小是固定的。如果需要同时监听大量的文件描述符，可能需要考虑其他方式来管理文件描述符的状态。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值