非阻塞读和写版 TCP回显C/S

本文提供了一个非阻塞IO的实现案例,包括客户端和服务端的代码。客户端使用fcntl将套接字、标准输入和标准输出设为非阻塞模式,并通过select进行多路复用。服务端接受连接并回显收到的数据。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

通过fcntl设置套接字,标准输出,标准输入为非阻塞

客户端代码:

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <sys/time.h>

#define BUFSIZE 4096

int max(int a,int b) {
    return a > b ? a : b;
}

char* gf_time(void) {
    struct timeval tv;
    static char str[30];
    char* ptr;

    if (gettimeofday(&tv,NULL) < 0) {
        printf("gettimeofday error: %s\n",strerror(errno));
        exit(1);
    }
    ptr = ctime(&tv.tv_sec);
    strcpy(str,&ptr[11]);
    snprintf(str + 8,sizeof(str) - 8,".%06ld",tv.tv_usec);
    return str;
}

void client_noblock_echo(int fd) {
    int val;
    val = fcntl(fd,F_GETFL,0);
    if (fcntl(fd,F_SETFL,val | O_NONBLOCK) < 0) {
        printf("fcntl error: %s\n",strerror(errno));
        exit(1);
    }

    val = fcntl(STDIN_FILENO,F_GETFL,0);
    if (fcntl(STDIN_FILENO,F_SETFL,val | O_NONBLOCK) < 0) {
        printf("fcntl error: %s\n",strerror(errno));
        exit(1);
    }

    val = fcntl(STDOUT_FILENO,F_GETFL,0);
    if (fcntl(STDOUT_FILENO,F_SETFL,val | O_NONBLOCK) < 0) {
        printf("fcntl error: %s\n",strerror(errno));
        exit(1);
    }

    char to[BUFSIZE],from[BUFSIZE];
    char *tws,*twr; // 发送缓冲区准备发送的(wait send) 准备接收的数据(wait receive from stdin)
    char *fwo,*fwr; //接收缓冲区准备输出的(wait output to stdout) 准备接收的数据(receive from server)
    fd_set rs,ws;
    tws = twr = to;
    fwo = fwr = from;
    int ioeof = 0;
    int maxfdp1 = max(fd,max(STDOUT_FILENO,STDIN_FILENO)) + 1;
    int n,nw;
    for (; ;) {
        FD_ZERO(&rs);
        FD_ZERO(&ws);
        if (ioeof == 0 && twr < &to[BUFSIZE]) {
            FD_SET(STDIN_FILENO,&rs);
        }
        if (fwo != fwr) {
            FD_SET(STDOUT_FILENO,&ws);
        }
        if (tws != twr) {
            FD_SET(fd,&ws);
        }
        if (fwr < &from[BUFSIZE]) {
            FD_SET(fd,&rs);
        }
        if (select(maxfdp1,&rs,&ws,NULL,NULL) < 0) {
            printf("select error: %s\n",strerror(errno));
            exit(1);
        }
        if (FD_ISSET(STDIN_FILENO,&rs)) {
            if ((n = read(STDIN_FILENO,twr,&to[BUFSIZE] - twr)) < 0) {
                if (errno != EWOULDBLOCK) {
                    printf("read error on stdin\n");
                }
            }else if (n == 0) {
                fprintf(stderr,"%s: EOF on stdin\n",gf_time());
                ioeof = 1;
                if (tws == twr) {
                    if (shutdown(fd,SHUT_WR) < 0) {
                        printf("shutdown error: %s\n",strerror(errno));
                        exit(1);
                    }
                }
            }else {
                fprintf(stderr,"%s: read %d bytes from stdin\n",gf_time(),n);
                twr += n;
                FD_SET(fd,&ws);
            }       
        }

        if (FD_ISSET(fd,&rs)) {
            if ((n = read(fd,from,&from[BUFSIZE] - fwr)) < 0) {
                if (errno != EWOULDBLOCK){
                    printf("read error on socket\n");
                    exit(1);
                }
            }else if (n == 0) {
                fprintf(stderr,"%s: EOF on socket\n",gf_time());
                if (ioeof) {
                    return;
                }else {
                    printf("client_noblock_echo: server terminated prematurely\n");
                    exit(1);
                }
            }else {
                fprintf(stderr,"%s: read %d bytes from socket\n",gf_time(),n);
                fwr += n;
                FD_SET(STDOUT_FILENO,&ws);
            }
        }

        if (FD_ISSET(STDOUT_FILENO,&ws) && ((n = fwr - fwo) > 0)) {
            if ((nw = write(STDOUT_FILENO,fwo,n)) < 0) {
                if (errno != EWOULDBLOCK) {
                    printf("write error to stdout\n");
                    exit(1);
                }
            }else {
                fprintf(stderr,"%s: wrote %d bytes to stdout\n",gf_time(),nw);
                fwo += nw;
                if (fwo == fwr) {
                    fwr = fwo = from;
                }
            }
        }

        if (FD_ISSET(fd,&ws) && ((n = twr - tws) > 0)) {
            if ((nw = write(fd,tws,n)) < 0) {
                if (errno != EWOULDBLOCK) {
                    printf("write to socket error\n");
                    exit(1);
                }
            }else {
                fprintf(stderr,"%s: write %d bytes to socket\n",gf_time(),nw);
                tws += nw;
                if (tws == twr) {
                    tws = twr = to;
                    if (ioeof) {
                        if (shutdown(fd,SHUT_WR) < 0) {
                            printf("shutdown error: %s\n",strerror(errno));
                            exit(1);
                        }
                    }
                }
            }
        }
    }
}
int main(int argc,char** argv) {
    if (argc != 3) {
        printf("please check <hostname or ip address> <services name or port>\n");
        exit(1);
    }

    struct addrinfo hints;
    hints.ai_flags = AI_ALL;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    struct addrinfo* results;
    int err;
    if ((err = getaddrinfo(argv[1],argv[2],&hints,&results)) != 0) {
        printf("getaddrinfo error: %s\n",gai_strerror(err));
        exit(1);
    }

    struct addrinfo* dummy = results;
    int sockfd;
    for (; dummy != NULL; dummy = dummy->ai_next) {
        if ((sockfd = socket(dummy->ai_family,dummy->ai_socktype,dummy->ai_protocol)) < 0) {
            continue;
        }
        if (connect(sockfd,dummy->ai_addr,dummy->ai_addrlen) == 0) {
            break;
        }
        close(sockfd);
    }

    if (dummy == NULL) {
        freeaddrinfo(results);
        printf("all socket failed\n");
        exit(1);
    }
    freeaddrinfo(results);
    client_noblock_echo(sockfd); 
    return 0;
}

服务端代码:

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <sys/wait.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <signal.h>

#define LISTENQ 100
#define BUFSIZE 4096

void server_echo(int fd) {
    char buf[BUFSIZE];
    int n;
    while ((n = read(fd,buf,BUFSIZE)) > 0) {
        if (write(fd,buf,n) != n) {
            printf("write to client error: %s\n",strerror(errno));
            exit(1);
        }
    }
}

void sig_child(int signo) {
    int pid;
    while ((pid = waitpid(-1,NULL,WNOHANG)) > 0) {
        printf("child process %d terminated\n",pid);
    }
}
int main(int argc,char** argv) {
    if (argc != 2) {
        printf("please check or add <service name or port>\n");
        exit(1);
    }

    struct addrinfo hints;
    bzero(&hints,sizeof(struct addrinfo));

    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    struct addrinfo* results;
    int err;
    if ((err = getaddrinfo(NULL,argv[1],&hints,&results)) != 0) {
        printf("getaddrinfo error: %s\n",gai_strerror(err));
        exit(1);
    }

    struct addrinfo* dummy = results;
    int sockfd;
    for (; dummy != NULL; dummy = dummy->ai_next) {
        if ((sockfd = socket(dummy->ai_family,dummy->ai_socktype,dummy->ai_protocol)) < 0) {
            continue;
        }

        if (bind(sockfd,dummy->ai_addr,dummy->ai_addrlen) == 0) {
            break;
        }
        close(sockfd);
    }

    if (dummy == NULL) {
        freeaddrinfo(results);
        printf("all socket failed\n");
        exit(1);
    }
    freeaddrinfo(results);
    if (listen(sockfd,LISTENQ) < 0) {
        printf("listen error: %s\n",strerror(errno));
        exit(1);
    }
    if (signal(SIGCHLD,sig_child) == SIG_ERR) {
        printf("signal error: %s\n",strerror(errno));
        exit(1);
    }
    int connfd;
    int ppid;
    for (; ;) {
        if ((connfd = accept(sockfd,NULL,NULL)) < 0) {
            if (errno == EINTR) {
                continue;
            }
            printf("accept error: %s\n",strerror(errno));
            exit(1);
        }
        if ((ppid = fork()) < 0) {
            printf("fork error: %s\n",strerror(errno));
            exit(1);
        }else if (ppid == 0) {
            close(sockfd);
            server_echo(connfd);
            close(connfd);
            exit(0);
        }
        close(connfd);
    }
}

测试:

启动服务器->启动tcpdump捕捉(本次测试服务器是在主机上.所以需要通过网卡lo捕捉,不然是抓不到的)->启动客户端,如图:

这里写图片描述

实验二 多线程非阻塞模式网络通信实验 1 实验类型 设计型实验 2实验目的 * 理解Winsock API的调用方法 * 了解TCP或UDP协议的工作原理 * 掌握TCP或UDP服务端程序客户端程序的编流程 * 熟悉非阻塞模式网络程序编 * 熟悉多线程程序编。 3背景知识 * Winsock编程模型 Winsock编程的主要有流套接字编程数据报套接字编程两类,主要区别在于:前者提供双向的、有序的、无重复并且无记录边界的数据流服务,即采用有连接的数据传输服务,保证数据可靠到达;后者也支持双向数据流,但不能保证数据的可靠、有序无重复,它保留了记录边界,是一种无连接、不可靠的数据传输模型。 * 套接字模式 Winsock提供了两种套接字模式:阻塞模式非阻塞模式。 在阻塞模式下,在I/O操作完成前,执行操作的Winsock函数(比如sendrecv)会一直等候下去,不会立即返程序(将控制权交还给程序)。而在非阻塞模式下,Winsock函数无论如何都会立即返。 多线程非阻塞模式编程常用的函数 ** 创建套接字函数socket SOCKET socket(int af,int type,int protocol); //由于采用流套接字进行数据传输,因此type参数必须设置为SOCK_STREAM,protocol参数必须设置为IPPROTO_TCP。 ** 绑定本地地址到所创建的套接字函数bind int bind(SOCKET s,const struct sockaddr* name,int namelen); ** 监听网络连接请求函数listen int listen(SOCKET s,int backlog); ** 连接请求函数connect int connect(SOCKET s,const struct sockaddr FAR* name,int namelen); ** 接受请求函数accept SOCKET accept(SOCKET s,struct sockaddr* addr,int* addrlen); ** 发送数据函数send int send(SOCKET s,const char* buf,int len,int flags); ** 接收数据函数recv int recv(SOCKET s,char* buf,int len,int flags); ** int ioctlsocket(SOCKET s, long cmd, u_long* argp ); 参数说明如下: s,套接字句柄。cmd,在套接字s上执行的命令描述符,我们只关心FIONBIO . argp,指针变量,指定cmd命令的参数。如果argp为0,非阻塞模式则是禁用的;如果argp为非0,设置套接字S为非阻塞模 ** 接收数据函数recvfrom() int recvfrom(SOCKET s,char* buf,int len,int flags, struct sockaddr* from,int* fromlen); *** 发送数据函数sendto() int sendto(SOCKET s,const char* buf,int len,int flags, const struct sockaddr* to,int* tolen); *** 关闭套接字函数closesocket() int closesocket(SOCKET s); *** 创建线程函数CreateThread() DWORD WINAPI TestThreadProc();//执行线程工作对应的函数。 创建线HANDLE hThread = CreateThread(NULL,0,TestThreadProc,this,0,NULL); 参数说明:NULL:安全属性继承进程 0:堆栈大小默认1M 线程函数:TestThreadProc this:传递参数 0:创建即执行 NULL:thread ID 13)修改套接字工作模式int ioctlsocket(SOCKET s, long cmd, u_long* argp ); 4 实验内容 1、认真理解套接字阻塞非阻塞两种模式编程,仔细阅并调试运行理论课堂提供的面向链接面向非链接网络程序源代码,分析在服务端客户端分别使用了哪些Winsock API函数,入实验报告; 2、要求实验中程序实现一下功能: ○1服务端能够接受多个客户端链接,并在服务端为每个客户端通信创建一个线程,由该线程负责对应客户端通信。 ○2服务端把接收的客户端发送过来的信息给客户端,当服务端收到对方的数据为“bye”时,关闭对应套接字,结束该线程。 3、编程设计实验思考题中问题。 5 实验思考题 ○1能否在接收数据之间不进行bind()调用?如果能,请说明可能的情况。 ○2阻塞模式非阻塞模式网络程序区别。
最新发布
03-28
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值