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

最新推荐文章于 2025-04-22 15:41:37 发布
原创 最新推荐文章于 2025-04-22 15:41:37 发布 · 1.2k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种在基于select的回显服务中遇到的问题及解决方法。问题表现为客户端虽然能够成功连接服务器，但在发送字符串后，服务器端的select操作却出现阻塞。通过调试和分析，找到了导致该现象的根本原因，并给出了修正后的代码片段。

    select版本的回显服务，初期的bug是，客户端可以连接上服务器，但是客户端发送字符串过来以后，服务器的select却阻塞在那里，死活没反映。。。gdb调试查看了fd_set类型的值，也发现的确是有两个值的叠加的——一个是监听套接字，一个是刚刚连接上的客户套接字。这就奇怪了！直到看到 http://bbs.youkuaiyun.com/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



select-IO多路复用
Zxn、Sirius荣耀之路
10-29 965
1、基本概念 IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： 当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。 如果一个服务器即要处理TCP，又要处理UD
网络编程----IO复用之select模型
hailong0715的专栏
04-06 3418
前一篇文章提到了，多线程/多进程虽然能够在一定程度上解决并发，但是由于进程/线程的切换消耗系统资源，多余并发量比较大的服务无法支持，因此为了解决大并发场景，需要一种能够支持更多并发的方法----IO复用， 与多线程/进程相比，IO复用最大的优点是避免了线程进程切换时产生的系统开销，内核不用创建线程也不用再维护这些线程了，这样就避免了很多不必要的开销。 本文介绍一种IO复用模型，select模型，
socket select设置延时 错误码10038
qq_42136233的博客
12-08 1984
初始化套接字后，在select之前又关闭了套接字，造成select返回-1,错误码：10038
在windows下使用python中的select函数报错‘[WinError 10038] 在一个非套接字上尝试了一个操
lch551218的博客
01-18 7944
注意：Python的select方法在Windows和Linux环境下的表现是不一样的，Windows下它只支持socket对象，不支持文件描述符（file descriptions)，而Linux两者都支持。因此，当select函数的第一个参数数组中包含非socket对象时（字符串），就会报‘[WinError 10038] 在一个非套接字上尝试了一个操作。’错误！ ...
select函数--IO多路复用详解
玫瑰花店的博客
01-22 1712
本章基于网络编程，需要学习网络编程的可以看我这篇博客： socket编程（超简单、详细、可运行）–实现一个简单的聊天程序 什么是多路复用IO呢？ 多路io：允许同时对多个I/O进行控制 可能这样说还是有点抽象，stm32下面有GPIO口，如果我需要一个LED屏幕连接在32开发板上面，是不是又很多的接线，每个接线接着板子上面的对应引脚上面，既然我们接线这个引脚了，是不是首先需要让这个引脚处于使能状态，这就是开时钟，多个引脚我们是不是要开多个引脚的时钟。配置好后我们的开发板的处理器是不是会按照需要去对这些IO口
I/O 多路复用之 select 详解
最新发布
qq_70260827的博客
04-22 1112
简单来说，I/O 多路复用允许我们在一个线程中同时监听多个 I/O 描述符（如 socket），一旦某个描述符就绪（比如有数据可读），我们就可以处理它，而不用阻塞在某一个 I/O 上。selectpollepoll（Linux 独有）其中select是最基础、最广泛支持的一种方式。select的核心思想是：你告诉内核你“关心”哪些文件描述符，内核会帮你监控它们是否就绪（可读、可写、异常）。你只需要等待，当有事件发生时，再去处理对应的 fd。select。
IO多路复用之select
qq_55882840的博客
07-09 3383
IO多路复用也称IO多路转接，它是一种网络通信的手段（机制），通过这种方式可以同时监测多个文件描述符并且这个过程是阻塞的，一旦检测到有文件描述符就绪（ 可以读数据或者可以写数据）程序的阻塞就会被解除，之后就可以基于这些（一个或多个）就绪的文件描述符进行通信了。通过这种方式在单线程/进程的场景下也可以在服务器端实现并发。常见的IO多路转接方式有：select、poll、epoll。
IO多路复用---select详解及示例
weixin_46566893的博客
11-23 1770
一、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多路复用
m0_56399733的博客
08-14 1396
IO多路复用技术：select、poll、epoll及两种工作模式。
Linux内核剖析-----IO复用函数epoll内核源码剖析
Eunice_fan1207的博客
08-16 2686
本文参考董浩博客http://donghao.org/uii/ epoll内核实现 （1）内核为epoll做准备工作 这个模块在内核初始化时（操作系统启动）注册了一个新的文件系统，叫"eventpollfs"（在eventpoll_fs_type结构里），然后挂载此文件系统。另外还创建两个内核cache（在内核编程中，如果需要频繁分配小块内存，应该创建kmem_ca...
IO多路复用深入解析：select函数全面剖析
总结，IO多路复用是解决高并发问题的有效方法之一，select作为其中的一种实现，虽然存在限制，但在特定场景下仍具有实用性。了解和掌握select可以帮助我们更好地理解和设计并发网络服务，特别是在资源有限或对性能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值