转：socket select模型示例

最新推荐文章于 2024-06-09 20:35:27 发布
最新推荐文章于 2024-06-09 20:35:27 发布
阅读量99 收藏
点赞数
文章标签： 网络 操作系统
原文链接：http://www.cnblogs.com/zkliuym/archive/2010/04/30/1724742.html
版权
// selectSocketMode.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
/*
问题： 
1.listen(ListenSocket, 5) 
是表明这个程序可同时处理5个客户端接入的请求
如果有6个客户端同时接入请求会发生什么情况？不知道我的理解对不对？

2.定义LPSOCKET_INFORMATION SocketArray[FD_SETSIZE]; // FD_SETSIZE=64  
这里能说明程序可以处理64个（读/写）请求操作？
如果是那么如果有多于64个的请求会发生什么呢？ 

3.如何测试这个服务程序的接入能力呢？它能接入多少个客户端？ 

4.客户端的程序如何写？没有这方面经验不知道如何入手，不知大家是怎么测试的？ 
我是刚开始接触网络编程，没有经验，希望大家能够踊跃讨论帮我解决问题

1、超过则连接的客户端会收到WSAECONNREFUSED的错误，也就是连接被拒绝。   

2、如果只定义了SOCKET类型数组的数量为64，那多于你就没变量罗！
要不你把第65个覆盖掉以前的，要不你如果用SocketArrar[64]来保存第65个就会崩掉罗，
因为数组越界了！呵呵！   

3、写个各户端试验就行了罗！   

4、我没仔细看你上面的程序，看你的介绍应该是TCP连接，客户端你就创建一个SOCKET
然后connect到服务端就行了啊！成功后你就可能通过send和recv来和服务器进行通讯了！

SELECT模型并不适合并发连接比较多的情况。如果是高并发的情况，推荐使用Overlap或IOCP.
默认Select是64，少于64的连接用Select是很方便的，你可以自己去改头文件的定义，
如果是连接有几百个以上的话，建议用Overlap或IOCP
*/

// Module Name: select.cpp 
// 
// Description:
// This sample illustrates how to develop a simple echo server Winsock 
// application using the select() API I/O model. This sample is 
// implemented as a console-style application and simply prints 
// messages when connections are established and removed from the server. 
// The application listens for TCP connections on port 5150 and accepts 
// them as they arrive. When this application receives data from a client, 
// it simply echos (this is why we call it an echo server)the data back in 
// it's original form until the client closes the connection. 
// 
// Compile: // 
// cl -o select select.cpp ws2_32.lib 
// 
// Command Line Options:
// select.exe 
// Note: There are no command line options for this sample. 
// 

#include <winsock2.h> 
#include <windows.h> 
#include <mswsock.h> 
#include <stdio.h> 

// 将ws2_32.lib连接到工程，也可以在工程选项中的连接中设置
#pragma comment(lib, "ws2_32.lib") 

#define PORT 5150 
#define DATA_BUFSIZE 8192 

typedef struct _SOCKET_INFORMATION { 
    CHAR Buffer[DATA_BUFSIZE]; 
    WSABUF DataBuf; 
    SOCKET Socket; 
    OVERLAPPED Overlapped; 
    DWORD BytesSEND; 
    DWORD BytesRECV; 
} SOCKET_INFORMATION, * LPSOCKET_INFORMATION; 

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

DWORD TotalSockets = 0; 
LPSOCKET_INFORMATION SocketArray[FD_SETSIZE]; 

void main(void) 
{ 
    SOCKET ListenSocket; 
    SOCKET AcceptSocket; 
    SOCKADDR_IN InternetAddr; 
    WSADATA wsaData; 
    INT Ret; 
    FD_SET WriteSet; 
    FD_SET ReadSet; 
    DWORD i; 
    DWORD Total; 
    ULONG NonBlock; 
    DWORD Flags; 
    DWORD SendBytes; 
    DWORD RecvBytes;     
    
    // WSAStartup即WSA(Windows SocKNDs Asynchronous，
    // Windows套接字异步)的启动命令
    // 该函数的第一个参数指明程序请求使用的Socket版本
    // 操作系统利用第二个参数返回请求的Socket的版本信息
    if ((Ret = WSAStartup(0x0202,&wsaData)) != 0) 
    { 
        printf("WSAStartup() failed with error %d\n", Ret); 
        WSACleanup(); 
        return; 
    } 
    
    // Prepare a socket to listen for connections.     
    // 创建一个与指定传送服务提供者捆绑的套接口
    if (INVALID_SOCKET == (ListenSocket = WSASocket(AF_INET, // int af 地址族描述。
            SOCK_STREAM,    // int type 新套接口的类型描述
            0,              // int protocol 套接口使用的特定协议
            NULL,           // LPPROTOCOL_INFO lpProtocolInfo 一个指向PROTOCOL_INFO结构的指针
            0,              // Group g 套接口组的描述字
            WSA_FLAG_OVERLAPPED)))   // int iFlags 套接口属性描述
    { 
        printf("WSASocket() failed with error %d\n", WSAGetLastError()); 
        return; 
    } 
    
    InternetAddr.sin_family = AF_INET; 
    InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY); 
    InternetAddr.sin_port = htons(PORT); 
    
    // 将socket绑定到一个端口
    if (bind(ListenSocket, (PSOCKADDR) &InternetAddr, sizeof(InternetAddr)) 
        == SOCKET_ERROR) 
    { 
        printf("bind() failed with error %d\n", WSAGetLastError()); 
        return; 
    } 
    
    // 监听这个端口，这个程序可同时处理5个客户端接入的请求
    if (listen(ListenSocket, 5)) 
    { 
        printf("listen() failed with error %d\n", WSAGetLastError()); 
        return; 
    } 
    
    // Change the socket mode on the listening socket from blocking to 
    // non-block so the application will not block waiting for requests.     
    NonBlock = 1; 
    // 本函数可用于任一状态的任一套接口。它用于获取与套接口相关的操作参数，
    // 而与具体协议或通讯子系统无关。FIONBIO：允许或禁止套接口s的非阻塞模式。
    if (ioctlsocket(ListenSocket, FIONBIO, &NonBlock) == SOCKET_ERROR) 
    { 
        printf("ioctlsocket() failed with error %d\n", WSAGetLastError()); 
        return; 
    } 
    
    while(TRUE) 
    { 
        // Prepare the Read and Write socket sets for network I/O notification. 
        FD_ZERO(&ReadSet); // 将set初始化为空集NULL。
        FD_ZERO(&WriteSet); // 
        
        // Always look for connection attempts.         
        FD_SET(ListenSocket, &ReadSet); // 向集合添加描述字。
        
        // Set Read and Write notification for each socket based on the 
        // current state the buffer. If there is data remaining in the 
        // buffer then set the Write set otherwise the Read set.         
        for (i = 0; i < TotalSockets; i++) 
        {// FD_SET 向集合添加描述字。
            if (SocketArray[i]->BytesRECV > SocketArray[i]->BytesSEND) 
                FD_SET(SocketArray[i]->Socket, &WriteSet); 
            else 
                FD_SET(SocketArray[i]->Socket, &ReadSet); 
        }
        
        if ((Total = select(0, &ReadSet, &WriteSet, NULL, NULL)) == SOCKET_ERROR)  
        { 
            printf("select() returned with error %d\n", WSAGetLastError()); 
            return; 
        } 
        
        // Check for arriving connections on the listening socket. 
        // FD_ISSET(int fd, fd_set *set)；用来测试描述词组set中相关fd的位是否为真
        if (FD_ISSET(ListenSocket, &ReadSet)) 
        { 
            Total--; 
            if ((AcceptSocket = accept(ListenSocket, NULL, NULL)) != INVALID_SOCKET)  
            {                     
                // Set the accepted socket to non-blocking mode so the server will 
                // not get caught in a blocked condition on WSASends                     
                NonBlock = 1; 
                if (ioctlsocket(AcceptSocket, FIONBIO, &NonBlock) == SOCKET_ERROR) 
                { 
                    printf("ioctlsocket() failed with error %d\n", WSAGetLastError()); 
                    return; 
                } 
                
                if (CreateSocketInformation(AcceptSocket) == FALSE) 
                    return;                     
            }
            else 
            {  
                if (WSAGetLastError() != WSAEWOULDBLOCK) 
                { 
                    printf("accept() failed with error %d\n", WSAGetLastError()); 
                    return; 
                } 
            } 
        } 
        
        // Check each socket for Read and Write notification until the number 
        // of sockets in Total is satisfied.             
        for (i = 0; Total > 0 && i < TotalSockets; i++) 
        { 
            LPSOCKET_INFORMATION SocketInfo = SocketArray[i]; 
            
            // If the ReadSet is marked for this socket then this means data 
            // is available to be read on the socket.                 
            if (FD_ISSET(SocketInfo->Socket, &ReadSet)) 
            { 
                Total--; 
                
                SocketInfo->DataBuf.buf = SocketInfo->Buffer; 
                SocketInfo->DataBuf.len = DATA_BUFSIZE; 
                
                Flags = 0; 
                if (WSARecv(SocketInfo->Socket, &(SocketInfo->DataBuf), 1, &RecvBytes, 
                    &Flags, NULL, NULL) == SOCKET_ERROR) 
                { 
                    if (WSAGetLastError() != WSAEWOULDBLOCK) 
                    { 
                        printf("WSARecv() failed with error %d\n", WSAGetLastError());                             
                        FreeSocketInformation(i); 
                    }                         
                    continue; 
                }   
                else 
                { 
                    SocketInfo->BytesRECV = RecvBytes;                         
                    // If zero bytes are received, this indicates the peer closed the 
                    // connection. 
                    if (RecvBytes == 0) 
                    { 
                        FreeSocketInformation(i); 
                        continue; 
                    } 
                } 
            } 
            
            
            // If the WriteSet is marked on this socket then this means the internal 
            // data buffers are available for more data.                 
            if (FD_ISSET(SocketInfo->Socket, &WriteSet)) 
            { 
                Total--; 
                
                SocketInfo->DataBuf.buf = SocketInfo->Buffer + SocketInfo->BytesSEND; 
                SocketInfo->DataBuf.len = SocketInfo->BytesRECV - SocketInfo->BytesSEND; 
                
                if (WSASend(SocketInfo->Socket, &(SocketInfo->DataBuf), 1, &SendBytes, 0, 
                    NULL, NULL) == SOCKET_ERROR) 
                { 
                    if (WSAGetLastError() != WSAEWOULDBLOCK) 
                    { 
                        printf("WSASend() failed with error %d\n", WSAGetLastError());                             
                        FreeSocketInformation(i); 
                    }                         
                    continue; 
                } 
                else 
                { 
                    SocketInfo->BytesSEND += SendBytes;                         
                    if (SocketInfo->BytesSEND == SocketInfo->BytesRECV) 
                    { 
                        SocketInfo->BytesSEND = 0; 
                        SocketInfo->BytesRECV = 0; 
                    } 
                } 
            } 
        } 
    } 
} 
  
BOOL CreateSocketInformation(SOCKET s) 
{ 
    LPSOCKET_INFORMATION SI; 

    printf("Accepted socket number %d\n", s); 

    if ((SI = (LPSOCKET_INFORMATION) GlobalAlloc(GPTR, 
      sizeof(SOCKET_INFORMATION))) == NULL) 
    { 
        printf("GlobalAlloc() failed with error %d\n", GetLastError()); 
        return FALSE; 
    } 

    // Prepare SocketInfo structure for use. 
    SI->Socket = s; 
    SI->BytesSEND = 0; 
    SI->BytesRECV = 0; 

    SocketArray[TotalSockets] = SI; 

    TotalSockets++; 

    return(TRUE); 
}   
  
void FreeSocketInformation(DWORD Index) 
{ 
    LPSOCKET_INFORMATION SI = SocketArray[Index]; 
    DWORD i; 

    closesocket(SI->Socket); 

    printf("Closing socket number %d\n", SI->Socket); 

    GlobalFree(SI); 

    // Squash the socket array 
    // 调整SocketArray的位置，填补队列中的空缺
    for (i = Index; i < TotalSockets; i++) 
    { 
        SocketArray[i] = SocketArray[i + 1]; 
    } 

    TotalSockets--; 
} 

  

转载于:https://www.cnblogs.com/zkliuym/archive/2010/04/30/1724742.html

weixin_30271335
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
socket编程以及select、epoll、poll示例详解
Hyacinth_Dy
06-11 2万+
socket编程socket这个词可以表示很多概念，在TCP/IP协议中“IP地址 + TCP或UDP端口号”唯一标识网络通讯中的一个进程，“IP + 端口号”就称为socket。在TCP协议中，建立连接的两个进程各自有一个socket来标识，那么两个socket组成的socket pair就唯一标识一个连接。
linux socket的select函数示例
mmdev
01-25 134
使用select函数可以以非阻塞的方式和多个socket通信。程序只是演示select函数的使用，功能非常简单，即使某个连接关闭以后也不会修改当前连接数，连接数达到最大值后会终止程序。 1. 程序使用了一个数组fd_A，通信开始后把需要通信的多个socket描述符都放入此数组。 2. 首先生成一个叫sock_fd的socket描述符，用于监听端口。 3. 将sock_fd和数组fd_A中不为...
socket 五种模型理解之一---------select模型
有梦，有追求
08-12 1983
一、选择模型，即select模型； Echo服务器 #include #include  #definePORT       5150 #defineMSGSIZE    1024  #pragmacomment(lib, "ws2_32.lib")  int    g_iTotalConn= 0; SOCKETg_CliSocketArr[FD_SETSIZE];  DWO
socket 的select函数例子
jia_zhengshen的专栏
09-18 3216
好久没有写博客了，主要最近也没有学啥新的可以写博客的东西 select函数是通过设置FD_SET来实现在一个线程中实现读写网口的，下面这段代码主要是实现绑定端口-》监听-》设置socket为非阻塞-》读取网口-》回写网口的。缺点是只能有一个socket连接，优点是代码简单，便于入门。在这里鄙视一下 《socket编程之select()》的博主，写个代码还故意整点bug，不过他写的文字还是很好的，
socket编程之select
背着行囊去远方的博客
08-30 2685
Linux编程之select： select作用是：在一段指定的时间内，监听用户感兴趣的文件描述符上可读、可写和异常等事件。 1、socket阻塞模式 通常在socket编程中，我们习惯于写connect、accept、recv、recvfrom这样的阻塞程序。如果事件不发生，程序就一直阻塞在那里，无法返回。 2、socket非阻塞模式：select 用select就可以完成...
基于select模型的socket服务器
06-12
一个基于select模型的socket服务器示例，支持多客户端连接请求。
windows下六种socket I/O模型示例
07-05
windows下六种socket I/O模型示例,例子很详细地描绘出各种模式的用法，适合windows下网络编程的人
HP-Socket 3.0.1
11-15
3、客户端组件 CUdpClient 采用 Event Select 通信模型 4、UDP 通信组件的接口与原 TCP 通信组件一致，简单实用 5、UDP 通信组件内置通信线路自动监测机制 6、新增 UDP 通信组件示例工程 TestEcho-UDP > 代码重构与...
Python示例-从基础到高手PDF
10-25
第 23 章 python 实现 select 和 epoll 模型 socket 网络编程 第 24 章 对 Python-memcache 分布式散列和调用的实现 第 25 章 Parallel Python 实现程序的并行多 cpu 多核利用【pp 模块】 第 26 章 关于 python ...
糖儿飞教你学C++ Socket网络编程——28. 使用select模型实现一对多通信
03-10 2379
在项目10中，采用多线程技术实现了TCP协议的一对多通信，但如果客户端过多，就会导致服务器端的线程数量膨胀，使得服务器的资源占用过大。能不能让TCP程序在一个线程中同时与多个客户端进行通信呢？答案是可以的，这需要用到I/O复用模型，I/O复用模型的核心是select()函数，select()函数可以管理多个套接字，使服务器端在单个线程中仍然能够处理多个套接字的I/O事件，达到跟多线程操作类似的效果...
深入理解socket中的select模型
08-09
对于套接字socket 的 select 模型，做了几种模式的解释，为SOCKET编程提供参考指导
socket I O模型 model 之 Select 模型例子
02-25
http://blog.csdn.net/infoworld/article/details/43935853 项目代码
【转】你真的懂select Socket模型吗？
weixin_30786617的博客
12-10 78
转自：http://www.cppblog.com/xvsdf100/archive/2013/12/10/204689.html 只要接触过c/c++网路编程人都可能会知道select io 模式，网络书籍都说 fd_set {int num; SOCKET arr[64]} 有所限制，因为数组的长度只有64，那么超过64你就不能放，要么你就是用多线程分别实用select...
socket笔记3 select模型
番茄锅涮代码
02-24 191
2.17 服务器/客户端升级为select模型处理多客户端 select 函数：int select(int n,fd_set * readfds,fd_set * writefds,fd_set * exceptfds,struct timeval * timeout); 第一个参数是一个整数，指fd_set集合中所有socket的范围，而不是数量。即是所有描述符最大值+1，在windows...
利用select异步I/O模型实现群聊
ChenYitian
03-20 1756
之前所有写的socket程序都是“同步阻塞”的，这里的“同步”是指，应用中的函数调用与相应的操作系统内核中的函数是同步的，“阻塞”指的是当accept，recv，send等函数还没有确认/接收/发送时，相应的线程处于等待状态，无法继续往下执行。 “同步阻塞”虽然易于理解与实现，但是是一种效率很低的模式，因为当阻塞的时候，这个线程是不能干任何事情的，因此，“异步非阻塞”是一种效率更高的方式。 利
windows下比较好的select模型.
山水人间。
01-05 1745
原文转载自:https://www.cnblogs.com/qiyueliuguang/archive/2013/12/31/3498705.html #include #include using namespace std; #pragma comment(lib, "ws2_32") int main(int argc, char **argv)
#include <winsock2.h>报错的问题
ghevinn欢迎您光临
02-04 9415
#define PORT 5150 #define DATA_BUFSIZE 8192 typedef struct _SOCKET_INFORMATION { CHAR Buffer[DATA_BUFSIZE]; WSABUF DataBuf; SOCKET Socket; WSAOVERLAPPED Overlapped; DWORD BytesSEND; DWORD By
Select模型及tcp select模型
weixin_34161029的博客
06-26 173
 参考：http://m.blog.csdn.net/article/details?id=51420015 一、套接字模式 套接字模式简单的决定了操作套接字时，Winsock函数是如何运转的。Winsock以两种模式执行I/O操作：阻塞和非阻塞。 在阻塞模式下，执行I/0的Winsock调用(如send和recv)一直到操作完成才返回。 非阻塞模式下，Winsock函数会立刻返回 1.阻塞模...
网络安全技术实验一 信息收集和漏洞扫描
最新发布
zzzfff__的博客
06-09 963
了解信息搜集和漏洞扫描的一般步骤，利用Nmap等工具进行信息搜集并进行综合分析；掌握TCP全连接扫描、TCP SYN扫描的原理,利用Scapy编写网络应用程序，开发端口扫描功能模块；使用漏洞扫描工具发现漏洞并进行渗透测试。
用c++写一个TCP服务器，使用select模型
09-18
下面是一个简单的TCP服务器代码，使用select模型： ```c #include #include #include #include #include #include <sys/socket.h> #include #include #include #define MAX_CLIENT 10 #define BUF_SIZE ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值