C语言实现 select模式编程

最新推荐文章于 2024-08-12 07:39:13 发布
最新推荐文章于 2024-08-12 07:39:13 发布
阅读量3.4k 收藏 4
点赞数 1
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28295425/article/details/52935918
版权

server：

// TcpServer.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <WINSOCK2.H>   
#include <iostream>

#pragma comment(lib,"WS2_32.lib")   

#define   PORT   9990   
#define   DATA_BUFSIZE   8192   

// 定义套接字信息
typedef   struct   _SOCKET_INFORMATION   {   
    CHAR   Buffer[DATA_BUFSIZE];        // 发送和接收数据的缓冲区
    WSABUF   DataBuf;                       // 定义发送和接收数据缓冲区的结构体，包括缓冲区的长度和内容
    SOCKET   Socket;                            // 与客户端进行通信的套接字
    DWORD   BytesSEND;                  // 保存套接字发送的字节数
    DWORD   BytesRECV;                  // 保存套接字接收的字节数
} SOCKET_INFORMATION,   *   LPSOCKET_INFORMATION;   

DWORD   TotalSockets = 0;               // 记录正在使用的套接字总数量
LPSOCKET_INFORMATION   SocketArray[FD_SETSIZE];         // 保存Socket信息对象的数组，FD_SETSIZE表示SELECT模型中允许的最大套接字数量

// 创建SOCKET信息
BOOL   CreateSocketInformation(SOCKET   s)   
{   
    LPSOCKET_INFORMATION   SI;                                      // 用于保存套接字的信息       
 //   printf("Accepted   socket   number   %d\n",   s);         // 打开已接受的套接字编号
    // 为SI分配内存空间
    if ((SI = (LPSOCKET_INFORMATION) GlobalAlloc(GPTR,   
              sizeof(SOCKET_INFORMATION)))   ==   NULL)   
    {   
        printf("GlobalAlloc()   failed   with   error   %d\n",   GetLastError());   
        return   FALSE;   
    }   
    // 初始化SI的值    
    SI->Socket = s;   
    SI->BytesSEND = 0;   
    SI->BytesRECV = 0;   
    // 在SocketArray数组中增加一个新元素，用于保存SI对象 
    SocketArray[TotalSockets]   =   SI;       
    TotalSockets++;                     // 增加套接字数量

    return(TRUE);   
}     

// 从数组SocketArray中删除指定的LPSOCKET_INFORMATION对象
void   FreeSocketInformation(DWORD   Index)   
{   
    LPSOCKET_INFORMATION SI = SocketArray[Index];   // 获取指定索引对应的LPSOCKET_INFORMATION对象
    DWORD   i;   
    // 关闭套接字
    closesocket(SI->Socket);   
    //printf("Closing   socket   number   %d\n",   SI->Socket);   
    // 释放指定LPSOCKET_INFORMATION对象资源
    GlobalFree(SI);   
    // 将数组中index索引后面的元素前移
    for (i = Index; i < TotalSockets; i++)   
    {   
        SocketArray[i] = SocketArray[i+1];   
    }   
     TotalSockets--;        // 套接字总数减1
}   

// 主函数，启动服务器
int _tmain(int argc, _TCHAR* argv[])
{
    SOCKET   ListenSocket;                  // 监听套接字
    SOCKET   AcceptSocket;                  // 与客户端进行通信的套接字
    SOCKADDR_IN   InternetAddr;         // 服务器的地址
    WSADATA   wsaData;                      // 用于初始化套接字环境
    INT   Ret;                                          // WinSock API的返回值
    FD_SET   WriteSet;                          // 获取可写性的套接字集合
    FD_SET   ReadSet;                           // 获取可读性的套接字集合
    DWORD   Total = 0;                              // 处于就绪状态的套接字数量
    DWORD   SendBytes;                      // 发送的字节数
    DWORD   RecvBytes;                      // 接收的字节数


    // 初始化WinSock环境
    if ((Ret = WSAStartup(0x0202,&wsaData)) != 0)   
    {   
        printf("WSAStartup()   failed   with   error   %d\n",   Ret);   
        WSACleanup();   
        return -1;   
    }   
    // 创建用于监听的套接字 
    if ((ListenSocket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0,   
              WSA_FLAG_OVERLAPPED))   ==   INVALID_SOCKET)     
    {   
        printf("WSASocket()   failed   with   error   %d\n",   WSAGetLastError());   
        return -1;   
    }   
    // 设置监听地址和端口号
    InternetAddr.sin_family = AF_INET;   
    InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY);   
    InternetAddr.sin_port = htons(PORT);   
    // 绑定监听套接字到本地地址和端口
    if(bind(ListenSocket, (PSOCKADDR)&InternetAddr, sizeof(InternetAddr)) == SOCKET_ERROR)   
    {   
        printf("bind()   failed   with   error   %d\n",   WSAGetLastError());   
        return -1;   
    }   
    // 开始监听
    if   (listen(ListenSocket,   5))   
    {   
        printf("listen()   failed   with   error   %d\n",   WSAGetLastError());   
        return -1;   
    }   


/*  // 设置为非阻塞模式
    ULONG NonBlock = 1;   
    if(ioctlsocket(ListenSocket, FIONBIO, &NonBlock) == SOCKET_ERROR)   
    {   
        printf("ioctlsocket() failed with error %d\n", WSAGetLastError());   
        return -1;   
    }   
    // 为ListenSocket套接字创建对应的SOCKET_INFORMATION
    // 这样就可以把ListenSocket添加到SocketArray数组中

    */

    CreateSocketInformation(ListenSocket);    
    while(TRUE)   
    {   
        // 准备用于网络I/O通知的读/写套接字集合
        FD_ZERO(&ReadSet);   
        FD_ZERO(&WriteSet);   
        // 向ReadSet集合中添加监听套接字ListenSocket
        FD_SET(ListenSocket,   &ReadSet);   
        // 将SocketArray数组中的所有套接字添加到WriteSet和ReadSet集合中
        // SocketArray数组中保存着监听套接字和所有与客户端进行通信的套接字
        // 这样就可以使用select()判断哪个套接字有接入数据或者读取/写入数据
        for   (DWORD i=0; i<TotalSockets; i++)   
        {
            LPSOCKET_INFORMATION SocketInfo = SocketArray[i];
            FD_SET(SocketInfo->Socket,   &WriteSet);   
            FD_SET(SocketInfo->Socket,   &ReadSet);   
        }
        // 判断读/写套接字集合中就绪的套接字    
        if((Total = select(0, &ReadSet, &WriteSet, NULL, NULL)) == SOCKET_ERROR)   
        {   
            printf("select()   returned   with   error   %d\n",   WSAGetLastError());   
            return -1;   
        }      
        // 依次处理所有套接字。本服务器是一个回应服务器，即将从客户端收到的字符串再发回到客户端。
        for   (DWORD i=0; i<TotalSockets; i++)   
        {
            LPSOCKET_INFORMATION SocketInfo = SocketArray[i];           // SocketInfo为当前要处理的套接字信息
            // 判断当前套接字的可读性，即是否有接入的连接请求或者可以接收数据
            if (FD_ISSET(SocketInfo->Socket,   &ReadSet))   
            {   
                if(SocketInfo->Socket == ListenSocket)      // 对于监听套接字来说，可读表示有新的连接请求
                {
                    Total--;    // 就绪的套接字减1
                    // 接受连接请求，得到与客户端进行通信的套接字AcceptSocket
                    if((AcceptSocket = accept(ListenSocket, NULL, NULL))   !=   INVALID_SOCKET)   
                    {   
                        printf("连接成功！\n");
                        /*
                        // 设置套接字AcceptSocket为非阻塞模式
                        // 这样服务器在调用WSASend()函数发送数据时就不会被阻塞
                        NonBlock   =   1;   
                        if(ioctlsocket(AcceptSocket, FIONBIO, &NonBlock)   ==   SOCKET_ERROR)   
                        {   
                            printf("ioctlsocket()   failed   with   error   %d\n",   WSAGetLastError());   
                            return -1;                             
                        }   
                        */

                        // 创建套接字信息，初始化LPSOCKET_INFORMATION结构体数据，将AcceptSocket添加到SocketArray数组中
                        if(CreateSocketInformation(AcceptSocket) == FALSE)   
                            return -1;   
                    }   
                    else   
                    {   
                        if(WSAGetLastError() != WSAEWOULDBLOCK)   
                        {   
                            printf("accept()   failed   with   error   %d\n",   WSAGetLastError());   
                            return -1;   
                        }   
                    }                   
                }
                else   // 接收数据
                {
                    // 如果当前套接字在ReadSet集合中，则表明该套接字上有可以读取的数据
                    if   (FD_ISSET(SocketInfo->Socket,   &ReadSet))   
                    {   
                        Total--;                // 减少一个处于就绪状态的套接字
                        memset(SocketInfo->Buffer, ' ', DATA_BUFSIZE);  
                        ZeroMemory(SocketInfo->DataBuf.buf,DATA_BUFSIZE);// 初始化缓冲区
                        SocketInfo->DataBuf.buf = SocketInfo->Buffer;           // 初始化缓冲区位置
                        SocketInfo->DataBuf.len   =   DATA_BUFSIZE;             // 初始化缓冲区长度
                        // 接收数据
                        DWORD  Flags = 0;   
                        if(WSARecv(SocketInfo->Socket, &(SocketInfo->DataBuf), 1, &RecvBytes, &Flags, 
                            NULL, NULL) == SOCKET_ERROR)   
                        {   
                            // 错误编码等于WSAEWOULDBLOCK表示暂没有数据，否则表示出现异常
                            if(WSAGetLastError() != WSAEWOULDBLOCK)     
                            {   
                                printf("WSARecv()   failed   with   error   %d\n",   WSAGetLastError());   
                                FreeSocketInformation(i);       // 释放套接字信息
                            }   
                            continue;   
                        }     
                        else   // 接收数据
                        {   
                            SocketInfo->BytesRECV = RecvBytes;      // 记录接收数据的字节数                           
                            if(RecvBytes == 0)                                  // 如果接收到0个字节，则表示对方关闭连接
                            {   
                                FreeSocketInformation(i);   
                                continue;   
                            }   
                            else                                                            // 如果成功接收数据，则打印收到的数据
                            {
                                printf(SocketInfo->DataBuf.buf);
                                printf("\n");

                                //
                            }
                        }
                    }   
                }
            }
            else
            {
                // 如果当前套接字在WriteSet集合中，则表明该套接字的内部数据缓冲区中有数据可以发送
                if(FD_ISSET(SocketInfo->Socket,  &WriteSet))   
                {   
                    Total--;            // 减少一个处于就绪状态的套接字
                    SocketInfo->DataBuf.buf = SocketInfo->Buffer + SocketInfo->BytesSEND;           // 初始化缓冲区位置
                    SocketInfo->DataBuf.len = SocketInfo->BytesRECV - SocketInfo->BytesSEND;    // 初始化缓冲区长度
                    if(SocketInfo->DataBuf.len > 0)     // 如果有需要发送的数据，则发送数据
                    {
                        if(WSASend(SocketInfo->Socket, &(SocketInfo->DataBuf), 1, &SendBytes, 0,   
                                        NULL, NULL) == SOCKET_ERROR)   
                        {   
                            // 错误编码等于WSAEWOULDBLOCK表示暂没有数据，否则表示出现异常
                            if(WSAGetLastError() != WSAEWOULDBLOCK)   
                            {   
                                printf("WSASend()   failed   with   error   %d\n", WSAGetLastError());   
                                FreeSocketInformation(i);       // 释放套接字信息
                            }   
                            continue;   
                        }   
                        else   
                        {   
                            SocketInfo->BytesSEND += SendBytes;         // 记录发送数据的字节数
                            // 如果从客户端接收到的数据都已经发回到客户端，则将发送和接收的字节数量设置为0
                            if (SocketInfo->BytesSEND   ==   SocketInfo->BytesRECV)   
                            {   
                                SocketInfo->BytesSEND   =   0;   
                                SocketInfo->BytesRECV   =   0;   
                            }   
                        }   
                    }
                }               

            }   // 如果ListenSocket未就绪，并且返回的错误不是WSAEWOULDBLOCK（该错误表示没有接收的连接请求），则出现异常

        }           

    }   
    // 暂停，按任意键退出
    system("pause");
    return 0;
}

client：

// TcpClient.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <Winsock2.H>   
#include <string>
#include <iostream>

#pragma comment(lib,"WS2_32.lib")   
#define BUF_SIZE    64          // 缓冲区大小  

int _tmain(int argc, _TCHAR* argv[])
{
    WSADATA     wsd;                    // 用于初始化Windows Socket   
    SOCKET      sHost;                  // 与服务器进行通信的套接字   
    SOCKADDR_IN servAddr;           // 服务器地址   
    char        buf[BUF_SIZE];          // 用于接受数据缓冲区   
    int         retVal;                         // 调用各种Socket函数的返回值   
    // 初始化Windows Socket
    if(WSAStartup(MAKEWORD(2,2),&wsd) != 0)   
    {   
        printf("WSAStartup failed !\n");   
        return 1;   
    }     
    // 创建套接字   
    sHost = socket(AF_INET,SOCK_STREAM,IPPROTO_IP);   
    if(INVALID_SOCKET == sHost)   
    {   
        printf("socket failed !\n");   
        WSACleanup();   
        return -1;   
    }    

    // 设置服务器地址   
    servAddr.sin_family = AF_INET;   
    servAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");     // 用户需要根据实际情况修改
    servAddr.sin_port = htons(9990);                                                    // 在实际应用中，建议将服务器的IP地址和端口号保存在配置文件中
    int sServerAddlen = sizeof(servAddr);                                               // 计算地址的长度       
    // 循环等待
    while(true)
    {
        // 连接服务器   
        Sleep( 200 );
        retVal = connect(sHost,(LPSOCKADDR)&servAddr,sizeof(servAddr));   
        Sleep( 200 );
        if(SOCKET_ERROR == retVal)   
        {   
            int err = WSAGetLastError();
            if(err == WSAEWOULDBLOCK || err == WSAEINVAL)           // 无法立即完成非阻塞套接字上的操作
            {
                //Sleep(500);
                continue;
            }
            else if(err == WSAEISCONN)                                              // 已建立连接
            {
                break;
            }
            else
            {
                                continue;

                //printf("connect failed !\n");   
                //closesocket(sHost);   
                //WSACleanup();   
                //return -1;   
            }
        }   
    }
    // 循环向服务器发送字符串，并显示反馈信息。
    // 发送quit将使服务器程序退出，同时客户端程序自身也将退出
    while(true)
    {
        // 向服务器发送数据   
        printf("Please input a string to send: ");
        // 接收输入的数据
        std::string str;
        std::getline(std::cin, str);
        // 将用户输入的数据复制到buf中
        ZeroMemory(buf,BUF_SIZE);  
        ZeroMemory(buf,BUF_SIZE);   
        strcpy(buf,str.c_str());   
        // 循环等待
        while(true)
        {
            // 向服务器发送数据
            retVal = send(sHost,buf,strlen(buf),0);   
            if(SOCKET_ERROR == retVal)   
            {   
                int err = WSAGetLastError();
                if(err == WSAEWOULDBLOCK)           // 无法立即完成非阻塞套接字上的操作
                {

                    continue;
                }
                else
                {
                    printf("send failed !\n");   
                    closesocket(sHost);   
                    WSACleanup();   
                    return -1;   
                }
            }
            break;
        }     

        while(true)
        {
            ZeroMemory(buf,BUF_SIZE);                       // 清空接收数据的缓冲区
            retVal = recv(sHost,buf,sizeof(buf)+1,0);   // 接收服务器回传的数据   
            if(SOCKET_ERROR == retVal)   
            {   
                int err = WSAGetLastError();                // 获取错误编码
                if(err == WSAEWOULDBLOCK)           // 接收数据缓冲区暂无数据
                {
                    Sleep(100);
                    printf("waiting back msg !\n");
                    continue;
                }
                else if(err == WSAETIMEDOUT || err == WSAENETDOWN)
                {
                    printf("recv failed !\n");   
                    closesocket(sHost);   
                    WSACleanup();   
                    return -1;
                }
                break;
            }   
            break;
        }   
        //ZeroMemory(buf,BUF_SIZE);                     // 清空接收数据的缓冲区
        //retVal = recv(sHost,buf,sizeof(buf)+1,0);   // 接收服务器回传的数据   

        printf("Recv From Server: %s\n",buf);   
        // 如果收到quit，则退出
        if(strcmp(buf, "quit") == 0)
        {
            printf("quit!\n");
            break;
        }
    }
    // 释放资源   
    closesocket(sHost);   
    WSACleanup();   
    // 暂停，按任意键继续
    system("pause");
    return 0;  
}
Recar
关注
专栏目录
C语言实现select
GXJ2425620644的博客
12-19 1649
缺点： 1.select同时监听的文件描述符的上限是1024个，如果非要改就重新编译Linux内核。 优点： 1.可以跨平台 头文件： #include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <unistd.h> #include <std
【socket】C语言的Socket网络编程
小鱼菜鸟的博客
10-04 7655
目录 Socket网络编程 1、网络知识 网络中进程之间如何通信？ 什么是Socket？ socket一词的起源 怎么理解端口？ 怎么理解socket ？ 2. 客户/服务器模式 2.1 服务器端： 2.2 客户端： 4. 套接字函数 4.1 创建套接字──sock...
select模型C语言开发基于select IO模型的远程目录浏览与多线程文件下载.pdf
04-25
select模型C语言开发基于select IO模型的远程目录浏览与多线程文件下载.pdf很好的学习文档！珍藏版
C-socket编程-Select()模型
wwzhang0307的博客
03-21 564
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <arpa/inet.h> #include <ctype.h>#include "wrap.h"#define SERV_PORT 6666int main() { int i,j,n,maxi;
并发之C语言中的select函数技术详解
最新发布
极客代码
08-12 1216
select函数是C语言网络编程中一个重要的工具，它通过监控多个文件描述符的状态，实现了高效的非阻塞式IO操作。本文详细介绍了select函数的基本使用和工作原理，并通过代码案例展示了其应用方法。在下一部分，我们将进一步探讨select函数的高级用法和优化策略。本部分深入探讨了select函数的高级用法和优化策略，并通过实际应用案例展示了其在网络编程中的强大功能。select作为一个多平台支持的IO多路复用技术，虽然有其局限性，但在许多场景下仍然是实现高性能网络应用的关键工具。通过合理地使用select。
C语言 select
Claroja
04-24 627
#include <sys/select.h> int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); 参数 描述 nfds 监听文件描述符中最大的+1,或者填1024 readfds 读集合 writefds...
select模型代码实现
10-23
基于select模型的服务端，客户端也有，可直接打开工程运行
用C语言实现SPI通信协议
05-04
总结来说，用C语言实现SPI通信协议在FPGA中涉及到硬件描述语言编程、FPGA配置、C语言驱动开发以及SPI协议的具体操作。通过这些步骤，可以构建高效、灵活的SPI通信系统，满足不同应用场景的需求。
关于C语言协程与网络编程的分析
12-22
C语言虽然本身并不直接支持协程，但可以通过库函数或自定义的编程方式实现协程的模拟。协程是一种轻量级的并发执行单元，它们在用户空间中运行，允许程序在执行过程中暂停并保存状态，然后在合适的时间点恢复执行。...
C语言项目开发 网络通信编程
01-22
在这个“C语言项目开发 网络通信编程”中，我们将深入探讨如何利用C语言来实现基本的点对点通信，以及通过服务器作为中转的通信模式。C语言因其低级特性和高效性能，常被用于系统级编程，如网络通信库的开发。 首先...
运动会成绩管理系统c语言实现
01-30
总结，"运动会成绩管理系统C语言实现"项目综合了C语言编程、数据结构、数据库设计与管理等多个IT领域的知识。通过实际操作，不仅可以加深对理论的理解，还能提升编程技能，为今后的软件开发打下坚实基础。
select选择模型 windows套接字I/O模型
05-13
select选择模型 windows套接字I/O模型 网络程序设计 运行此程序 还有个客户端程序（上传的TCP里面有）
c语言套接字用select实现多用户连接
04-12
c语言套接字用select实现多用户连接
构造select集 编译原理 C语言版本
01-12
构造select集 编译原理 C语言版本构造select集 编译原理 C语言版本
C语言实现select-数组版
果果
12-01 2204
select函数demo #include <stdio.h> #include <sys/socket.h> #include <sys/types.h> #include <netinet/in.h> #include <arpa/inet.h> #include <string.h> #include <unistd.h> #define MAX_SELECT_CLIENT 4096 int select_dem
select学习(c/c++)
Micheal的博客
12-04 1305
使用select()函数实现socket服务端多客户端通信
Socket编程知识必学/SELECT 编程
maopig的专栏
02-19 9516
Select在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用Select写程序，他们只是习惯写诸如 connect、accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回）。可是使用Select就可以完成非阻塞（所谓非阻塞方
网络编程之select 模式开发实例
风铃中的刀声
11-18 1830
在网络上看到太多关于select i/o用法，都不是非常的详细。 经过摸索，把我实现的例子张贴上来，供大家参考。 描述： 服务器：实现并发tcp服务器，最多允许64 个客户端连接。 客户端：与服务器建立tcp连接，发送数据给服务器。服务器接收数据。 服务器代码：（红色为我的代码） // SelectServerDlg.h : header file // #if !defined(
网络编程之Select模式
ProgramVAE的博客
05-10 645
今天总结下Select模式下网络编程模型，首先我们要知道一个高级的技术，绝对不是凭空产生的，它一定是在原来的技术上由于满足不了需求，然后经过不断的打磨，一步步走向今天这个样子。那么Select模式的由来是什么呢？之前又是因为哪些原因，让我们提出了这种IO多路复用的模式呢？ 首先，对于常规下的网络编程，我们知道，服务器在某个端口监听之后，就等着客户端去链接。即使我们的accept函数使用非阻塞的，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值