Windows平台下基于Select模型的服务器

最新推荐文章于 2022-04-06 01:02:57 发布
最新推荐文章于 2022-04-06 01:02:57 发布
阅读量1k 收藏 1
点赞数
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzuhuang/article/details/17440263
版权
//   基于   select   模型的 socket   编程
#include   "stdafx.h"
#include   <winsock2.h>
#include   <iostream>
#pragma   comment (   lib ,   "ws2_32.lib"   )


using   namespace   std ;

enum
{
        MAIN_RETURN_ERROR            =  -1,
      MAIN_RETURN_NORMAL           =   0,
};


BOOL   CreateSocketInformation (   SOCKET   s   );
void   FreeSocketInfomation (   DWORD   Index   );


// WSABUF   是 WinSock2    中定义的   结构体，用于保存缓冲区的长度和地址
// struct _WSABUF
// {
//   u_long    len;   //   缓冲区的长度
//   char FAR* buf;   //   缓冲区的指针
// };

const   static   int   DATA_BUF_SIZE   = 256;
struct   _SOCKET_INFOMATION
{
        char       Buffer   [ DATA_BUF_SIZE ];       //   发送和接收数据缓冲区
        WSABUF     DataBuf   ;                     //   定义发送和接收数据缓冲区，保护缓冲区在内的长度和内容
        SOCKET     Socket   ;                      //   与客户端进行通信的   socket

        DWORD      BytesSEND   ;                   //   保存 socket   发送字节数
        DWORD      BytesRECV   ;                   //   保存 socket   接收字节数
};

typedef   _SOCKET_INFOMATION      SOCKET_INFOMATION ;
typedef   _SOCKET_INFOMATION *    LPSOCKET_INFOMATION ;

const   static   int   BUF_SIZE   = 256;

DWORD   TotalSockets   = 0;
LPSOCKET_INFOMATION   SocketArray [   FD_SETSIZE ];



int   _tmain (   int   argc   ,   _TCHAR *   argv [])
{
        //   初始化 Winsock 2.2
        WSADATA   wsaData   ;
        if (   WSAStartup   (   MAKEWORD ( 2, 2 ), &   wsaData   ) != 0 )
     {
             cout << "WSAStartup   无法初始化   !"   << endl   ;
             return   MAIN_RETURN_ERROR   ;
     }

        //   通过 WinSock   实现网络通信
        SOCKET   AcceptSocket   ;
        SOCKET   ListenSocket   ;
      //   创建用于监听的 Socket
        ListenSocket   =   WSASocket   (   AF_INET ,   SOCK_STREAM , 0,   NULL , 0,   WSA_FLAG_OVERLAPPED   );
        if (   INVALID_SOCKET   ==   ListenSocket   )
     {
             cout << "Socket Failed !"   << " Reson:" <<   WSAGetLastError ()<< endl   ;
             WSACleanup ();
             return   MAIN_RETURN_ERROR   ;
     }

        //   设置服务器 Socket   地址
        SOCKADDR_IN   addrServ   ;
        addrServ . sin_family     =   AF_INET ;
        addrServ . sin_port       =   htons ( 9990 );     //   服务器端口号
        addrServ . sin_addr   . S_un .   S_addr   =   htonl   (   INADDR_ANY   );

        //   绑定
        int       retVal   ;
        retVal   =   bind   (   ListenSocket , (   const   struct   sockaddr   *)& addrServ   ,   sizeof (   SOCKADDR_IN   ) );
        if (   SOCKET_ERROR   ==   retVal   )
     {
             cout << "bind failed !"   << "   Reson: " <<   WSAGetLastError ()<< endl   ;
             closesocket (   ListenSocket   );
             WSACleanup ();
             return   -1;
     }

        //   监听
        retVal   =   listen   (   ListenSocket , 5 );
        if (   SOCKET_ERROR   ==   retVal   )
     {
             cout << "listen failed !"   << " Reson:" <<   WSAGetLastError ()<< endl   ;
             closesocket (   ListenSocket   );
             WSACleanup ();
             return   -1;
     }

        //   设置 socket   其为非阻塞模式   , argp   设为非零值
        int   iModel   = 1; 
        retVal   =   ioctlsocket   (   ListenSocket ,   FIONBIO , ( u_long   FAR * )& iModel   );
        if (   SOCKET_ERROR   ==   retVal   )
     {
             cout << "ioctlsocket failed  Reson :" <<   WSAGetLastError ()<< endl   ;
             WSACleanup ();
             return   MAIN_RETURN_ERROR   ;
     }

        //
        CreateSocketInformation   (   ListenSocket   );

        cout << "TCP Server Start ... ..."   << endl ;
        //   循环等待
        FD_SET   WriteSet   ;
        FD_SET   ReadSet   ;
        DWORD     Total   = 0;
        DWORD     SendBytes   ,   RecvBytes ;
        while (   true   )
     {
             FD_ZERO ( & ReadSet   );
             FD_ZERO ( & WriteSet   );
             FD_SET (   ListenSocket   , & ReadSet   );
             for (   DWORD   i   = 0;   i   <   TotalSockets   ; ++ i   )
          {
                 LPSOCKET_INFOMATION   SocketInfo   =   SocketArray   [ i ];
                 FD_SET (   SocketInfo   -> Socket , &   WriteSet   );
                 FD_SET (   SocketInfo   -> Socket , &   ReadSet   );
          }

             if ( (   Total   =   select ( 0, &   ReadSet , & WriteSet   ,   NULL ,   NULL   ) ) ==   SOCKET_ERROR   )
          {
                 cout << "Select Return with Error " <<   WSAGetLastError ()<< endl   ;
                 return   -1;
          }
          
             for (   DWORD   i   = 0;   i   <   TotalSockets   ; ++ i   )
          {
                 // SocketInfo   为当前要处理的信息
                 LPSOCKET_INFOMATION   SocketInfo   =   SocketArray   [ i ];
                 //   判断当前 socket   的可读性，即是否有接入的连接请求可以接收数据
                 if (   FD_ISSET   (   SocketInfo ->   Socket , & ReadSet   ) )
              {
                      //   对于监听来说，可读表示有新的连接请求
                      if (   SocketInfo   -> Socket   ==   ListenSocket   )
                   {
                           Total --;
                           //   接受连接请求，与客户端进行通信
                           if ( (   AcceptSocket   =   accept (   ListenSocket   ,   NULL ,   NULL   ) ) !=   INVALID_SOCKET   )
                        {
                                int   NonBlock   = 1;
                                if (   ioctlsocket   (   AcceptSocket   ,   FIONBIO , (   u_long   FAR   * )& NonBlock ) ==   SOCKET_ERROR   )
                             {
                                     cout << "ioctlsocket() failed with error " <<   WSAGetLastError ()<< endl   ;
                                     return   -1;
                             }

                                if (   CreateSocketInformation   (   AcceptSocket   ) ==   FALSE   )
                                     return   -1;
                        }
                           else
                        {
                                if (   WSAGetLastError   () !=   WSAEWOULDBLOCK   )
                             {
                                     cout << "accept failed with error " <<   WSAGetLastError ()<< endl   ;
                                     return   -1;
                             }
                        }
                   }
                      //   有新的数据到达
                      else
                   {
                           //   如果当前在 ReadSet 集合中，表明有数据可读
                           if (   FD_ISSET   (   SocketInfo ->   Socket , & ReadSet   ) )
                        {
                             --   Total ;
                                memset (   SocketInfo   -> Buffer ,   ' ' ,   DATA_BUF_SIZE   );
                                SocketInfo -> DataBuf   . buf   =   SocketInfo   -> Buffer ;
                                SocketInfo -> DataBuf   . len   =   DATA_BUF_SIZE   ;

                                //   接收数据
                                DWORD   Flags   = 0;
                                if (   WSARecv   (   SocketInfo   -> Socket , &(   SocketInfo -> DataBuf   ), 1, & RecvBytes   , & Flags ,   NULL ,   NULL   ) ==   SOCKET_ERROR   )
                             {
                                     if (   WSAEWOULDBLOCK   !=   WSAGetLastError   () )
                                  {
                                         cout << "WSARecv failed with error " <<   WSAGetLastError ()<< endl   ;
                                          FreeSocketInfomation   (   i   );
                                  }

                                     continue ;
                             }
                                else
                             {
                                     SocketInfo -> BytesRECV   =   RecvBytes   ;
                                     if (   RecvBytes   == 0 )
                                  {
                                          FreeSocketInfomation   (   i   );
                                         continue ;
                                  }
                                     else
                                  {
                                          cout << SocketInfo   -> DataBuf .   buf << endl   ;
                                  }
                             }
                        }
                   }
              }
                 else
              {
                      //   发送数据
                      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   )
                             {
                                     if (   WSAGetLastError   () !=   WSAEWOULDBLOCK   )
                                  {
                                         cout << "WSASend failed with error " <<   WSAGetLastError ()<< endl   ;
                                          FreeSocketInfomation   (   i   );
                                  }

                                     continue ;
                             }
                                else
                             {
                                     SocketInfo -> BytesSEND   +=   SendBytes   ;
                                     if (   SocketInfo   -> BytesSEND   ==   SocketInfo -> BytesRECV   )
                                  {
                                          SocketInfo -> BytesRECV   = 0;
                                          SocketInfo -> BytesSEND   = 0;
                                  }
                             }
                        }
                   }
              }
          }
     }
          
        //   最后做一些清理工作
        closesocket (   ListenSocket   );
        closesocket (   AcceptSocket   );
        WSACleanup ();
        system ( "pause"   );
        return   MAIN_RETURN_NORMAL   ;
}



//   创建   SOCKET
BOOL   CreateSocketInformation (   SOCKET   s   )
{
        LPSOCKET_INFOMATION   SI   ;
        //   为 SI   分配空间
        if ( (   SI   = ( LPSOCKET_INFOMATION )   GlobalAlloc (   GPTR   ,   sizeof   (   SOCKET_INFOMATION   ) ) ) ==   NULL   )
     {
             cout << "GlobalAlloc Failed with Error " <<   GetLastError ();
             return   FALSE   ;
     }

        SI -> Socket          =   s ;
        SI -> BytesSEND       = 0;
        SI -> BytesRECV       = 0;

        SocketArray [ TotalSockets   ] =   SI ;
     ++   TotalSockets ;

        return   TRUE   ;
}

void   FreeSocketInfomation (   DWORD   Index   )
{
        LPSOCKET_INFOMATION   SI   =   SocketArray [   Index ];
        DWORD   i   ;
        closesocket (   SI   -> Socket   );
        GlobalFree (   SI   );
        for (   i   =   Index ;   i   <   TotalSockets   ; ++ i   )
             SocketArray [ i   ] =   SocketArray [   i +1];

     --   TotalSockets ;
}



客户端1：


客户端2




服务器：

没有实现收到 服务端把数据发回客户端。
郑祖煌
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单HTTP服务器(select模型)
异度空间
05-19 1115
server.c #include #include #include #include #include #include #include #include #include #include #define SERVER_NAME "IAMCAP-SERVER" #define PROTOCOL "HTTP/1.1" #define REQUESTLEN 409
windows网络编程之tcp/ip
01-20
适用人群windows网络编程的初学者课程概述课程简介：这部教程是windows网络编程课程的第一部分课程：tcp/ip协议后续会有第二部分课程：udp/ip协议以及第三部分课程http协议的课程发布。希望能够帮助到大家。课程内容：c/s模型的编码，5种windows网络模型：select，异步选择，事件选择，重叠io，完成端口，以及基础理论知识的讲解。课程分八章，总课时100课时左右，每日更新2~5节.课程代码会带大家一行一行书写，保证大家都能够学会。课程适合人群：网络编程爱好者，网络编程初学者课程章节：第一章 c/s模型的讲解以及代码实现第二章 select模型的讲解以及代码实现第三章 异步选择模型的讲解以及代码实现第四章 事件选择模型的讲解以及代码实现第五章 重叠i/o模型的讲解以及代码实现第六章 完成端口模型的讲解以及代码实现第七章 tcp/ip基础知识的讲解，包括网络分层，三次握手，四次挥手，协议头等等。
windows平台select使用
技术之路
08-05 4620
服务器端 #include #include #include #define InternetAddr "127.0.0.1" #define iPort 6000 #pragma comment(lib, "ws2_32.lib") void main() { WSADATA wsa; WSAStartup(MAKEWORD(2, 2), &wsa);
基于select模型的socket服务器
06-12
一个基于select模型的socket服务器示例，支持多客户端连接请求。
windows TCP/IP 网络编程（二）5种windows网络模型(1) select模型
weixin_39303983的博客
04-06 4385
1 select 模型原理介绍 fd_set结构的意义和应用 各种 Windows 套接字函数和服务提供程序（如 select 函数）使用fd_set结构将套接字放入"set"中，用于各种目的，例如使用 select 函数的 readfds 参数测试给定套接字的可读性。 注意 ...
Windows下的TCP回显多线程服务器.pdf
最新发布
10-27
本文将深入探讨Windows下基于TCP的阻塞模型的并发回显服务器的构建，以及与Unix Socket API的比较。 一、TCP回显服务器原理 TCP回显服务器是一种简单的网络服务，它接收客户端发送的数据，然后原样返回。这种...
select模型_c++网络通信模型_
10-02
在IT行业中，网络通信是软件开发的一个重要领域，特别是在分布式...在Windows环境下，通过Winsock库，我们可以方便地实现基于select的网络通信。在实际开发中，还需要注意兼容性和性能优化，确保程序的健壮性和效率。
windows下的socket模型
01-15
Select模型是最传统的I/O模型之一，它允许程序监视多个套接字的状态，以确定哪些套接字准备好了读取、写入或有异常发生。通过调用`select`函数，程序可以等待一组套接字中的任何一个准备好执行特定操作。这种模型...
Win32 Socket 基于Select的服务程序
10-23
在项目"TestWin32Select"中，可以看到一个典型的基于Select的服务器实现。源代码包含以下关键步骤： 1. 初始化Socket，创建监听Socket，并设置好地址和端口。 2. 创建一个描述符集合，将监听Socket添加进去。 3. ...
UNIX网络编程——使用select函数编写客户端和服务器
weixin_34210740的博客
07-24 303
首先看原先《UNIX网络编程——并发服务器（TCP）》的代码，服务器代码serv.c：#include<stdio.h> #include<sys/types.h> #include<sys/socket.h> #include<unistd.h> #include<stdlib.h> #include<errno.h...
Windows IO模型-Select模型（同步阻塞模型）
xiaobangkuaipao的博客
09-07 1682
参考博客：http://zxxapple.iteye.com/blog/1554692    套接字Select 阻塞和非阻塞的区别在于：进程访问数据时，数据未就绪，进行是否需要等待。阻塞：进程等到有结果再返回，函数返回。非阻塞：请求完立即返回，不论是否接收到数据。 异步和同步的区别在于：主动查看还是被动通知的区别，访问数据的机制不同。同步：主动请求，并等待I\O操作完毕，当数据读写时阻塞。异
WinSocket的select函数的用法(windows套接字比较研究)
BIGBurning
02-07 9774
总体上来说select函数的作用： 确定一个或多个套接口的状态，本函数用于确定一个或多个套接口的状态，对每一个套接口，调用者可查询它的可读性、可写性及错误状态信息，用fd_set结构来表示一组等待检查的套接口，在调用返回时，这个结构存有满足一定条件的套接口组的子集，并且select()返回满足条件的套接口的数目。 简单来说select用来填充一组可用的socket句柄，当满足下列之
基于Select模型的Socket服务器
Richard Liang的专栏
06-15 2826
　　Select模型是WinSocket中最常见的I/O模型。select模型的核心便是select函数，select函数可对多个socket组成的集合的所有操作进行管理。Select函数所原型如下：  int select(int nfds,fd_set FAR *readfds,fd_set FAR * writefds,                     fd_set FAR
Windows与Linux下的select网络模型对比分析
走在成长的路上
10-25 2125
详尽分析了Windows与Linux下的select模型的不同，各自的实现原理，各自的优点以及一些改进的建议。附有封装好的模型代码和相关注释
突破Windows下select网络模型64个连接的限制
qq_38688701的博客
09-18 1745
在Windows使用select模型时，发现当连接数超过64个时，服务端完全接收不到数据，带着疑惑跳转到了fd_set的实现文件。 原来Windows在实现的过程中将fd_set的大小限制成了64个。 而通过观察他的宏定义不难发现我们还是可以修改他的大小的，因为只有FD_SETSIZE没有定义的情况下，Windows才会将FD_SETSIZE的大小设置为64，所以只要我们在之前就将FD_SETS...
select模型
Masimaro的专栏
09-15 2637
在Windows中所有的socket函数都是阻塞类型的，也就是说只有网络中有特定的事件发生时才会返回，在没有发生事件时会一直等待，虽说我们将它们设置为非阻塞状态，但是在对于服务器段而言，肯定会一直等待客户端的消息，也就是说即使设置为非阻塞状态，时间到了函数返回，但是程序不能结束，需要一个循环不断的侦听，特别是对于有多个客户端需要管理的时候，每一个与客户端通信的socket都需要一个侦听，这样管理起
（C++服务器学习笔记）：windows下使用select模型
baidu_41388533的博客
01-09 1340
目录 服务端升级为select模型 Socket的select模型 客户端转为Select模型 服务端升级为select模型 Socket的select模型 select( _In_ int nfds, _Inout_opt_ fd_set FAR * readfds, _Inout_opt_ fd_set FAR * writefds, _Inout_opt_ fd_set FAR * exceptfds, .
Web服务器（Nginx,Apache）和I/O模型
jeremy_ke的博客
12-11 786
Nginx 工作原理 常用配置 特点分析 Apache 工作原理 常用配置 特点分析 Nginx+Apache搭建高性能服务器集群 工作原理

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值