devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用Winsock：Winsock入门_wsapoll的使用

作者：2023面试高手 | 2024-02-26 20:59:26

赞

踩

wsapoll的使用

以下是Windows套接字编程入门的分步指南。 它旨在提供对基本Winsock函数和数据结构的理解，以及它们如何协同工作。

用于说明的客户端和服务器应用程序是一个非常基本的客户端和服务器。 Microsoft Windows软件开发工具包（SDK）附带的示例中包含更高级的代码示例。

客户端和服务器应用程序的前几个步骤相同。

  • 关于服务器和客户端
  • 创建一个基本的Winsock应用程序
  • 正在初始化Winsock

以下部分描述了创建Winsock客户端应用程序的其余步骤。

  • 为客户端创建套接字
  • 连接到插座
  • 在客户端上发送和接收数据
  • 断开客户端连接

以下部分描述了创建Winsock服务器应用程序的其余步骤。

  • 为服务器创建套接字
  • 绑定套接字
  • 听一个插座
  • 接受连接
  • 在服务器上接收和发送数据
  • 断开服务器连接

这些基本示例的完整源代码。

  • 运行Winsock客户端和服务器代码示例
  • 完整的Winsock客户端代码
  • 完整的Winsock服务器代码

 

高级Winsock实例

Windows SDK附带了几个更高级的Winsock客户端和服务器示例。 默认情况下，Winsock示例源代码由Windows SDK for Windows 7安装在以下目录中：

C:\Program Files\Microsoft SDKs\Windows\v7.0\Samples\NetDs\winsock

在早期版本的Windows SDK中，上述路径中的版本号将更改。 例如，Winsock示例源代码由Windows SDK for Windows Vista安装在以下默认目录中

C:\Program Files\Microsoft SDKs\Windows\v6.0\Samples\NetDs\winsock

以下列出的高级样本按从高到低的顺序排列，可在以下目录中找到：

  • iocp

该目录包含三个使用I / O完成端口的示例程序。 这些程序包括一个使用WSAAccept函数的Winsock服务器（iocpserver），一个使用AcceptEx函数的Winsock服务器（iocpserverex），以及一个用于测试这些服务器中的任何一个的简单多线程Winsock客户端（iocpclient）。 服务器程序支持多个客户端通过TCP / IP连接并发送任意大小的数据缓冲区，然后服务器回送给客户端。 为方便起见，开发了一个简单的客户端程序iocpclient，用于连接并不断向服务器发送数据，以便使用多个线程对其进行压力。 使用I / O完成端口的Winsock服务器提供最强大的性能。

  • overlap

此目录包含使用重叠I / O的示例服务器程序。 示例程序使用AcceptEx函数和重叠I / O来有效地处理来自客户端的多个异步连接请求。 服务器使用AcceptEx函数在单线程Win32应用程序中复用不同的客户端连接。 使用重叠I / O可实现更高的可伸缩性。

  • WSAPoll

该目录包含一个演示WSAPoll函数使用的基本示例程序。 组合的客户端和服务器程序是非阻塞的，并使用WSAPoll函数来确定何时可以无阻塞地发送或接收。 此示例更多用于说明，而不是高性能服务器。‘

  • simple

该目录包含三个基本示例程序，用于演示服务器使用多个线程。 这些程序包括一个简单的TCP / UDP服务器（简单），一个仅使用TCP的服务器（simples_ioctl），它使用Win32控制台应用程序中的select函数来支持多个客户端请求，以及一个客户端TCP / UDP程序（simplec），用于测试服务器。 服务器演示了使用多个线程来处理多个客户端请求。 此方法具有可伸缩性问题，因为为每个客户端请求创建了单独的线程。

  • accept

该目录包含基本样本服务器和客户端程序。 服务器演示如何使用select函数使用非阻塞接受或使用WSAAsyncSelect函数使用异步接受。 此示例更多用于说明，而不是高性能服务器。’

 

 

一、关于服务器和客户端

有两种不同类型的套接字网络应用程序：服务器和客户端。

服务器和客户端有不同的行为; 因此，创建它们的过程是不同的。 以下是创建流式TCP / IP服务器和客户端的一般模型。

 

一）、服务器

  1. 初始化Winsock。
  2. 创建一个套接字。
  3. 绑定套接字。
  4. 听取客户端的套接字。
  5. 接受来自客户端的连接。
  6. 接收和发送数据。
  7. 断开链接。

 

二）、客户端

  1. 初始化Winsock。
  2. 创建一个套接字。
  3. 连接到服务器。
  4. 发送和接收数据。
  5. 断开链接。

 

注意

对于客户端和服务器，某些步骤是相同的。 这些步骤几乎完全相同。 本指南中的某些步骤将特定于正在创建的应用程序类型。

 

 

二、创建一个基本的Winsock应用程序

1、为了创建基本的Winsock应用程序

2、创建一个新的空项目。

3、将空C ++源文件添加到项目中。

4、确保构建环境引用Microsoft Windows软件开发工具包（SDK）或早期平台软件开发工具包（SDK）的Include，Lib和Src目录。确保构建环境链接到Winsock库文件Ws2_32.lib。 使用Winsock的应用程序必须与Ws2_32.lib库文件链接。 #pragma注释向链接器指示需要Ws2_32.lib文件。

5、开始编写Winsock应用程序。 通过包含Winsock 2头文件来使用Winsock API。 Winsock2.h头文件包含大多数Winsock函数，结构和定义。 Ws2tcpip.h头文件包含在针对TCP / IP的WinSock 2协议特定附件文档中引入的定义，其中包括用于检索IP地址的较新功能和结构。

注意

Stdio.h用于标准输入和输出，特别是printf（）函数。

  1. #include <winsock2.h>
  2. #include <ws2tcpip.h>
  3. #include <stdio.h>
  4.  
  5. #pragma comment(lib, "Ws2_32.lib")
  6.  
  7. int main() {
  8.   return 0;
  9. }

注意

如果应用程序正在使用IP Helper API，则需要Iphlpapi.h头文件。 当需要Iphlpapi.h头文件时，Winsock2.h头文件的#include行应该放在Iphlpapi.h头文件的#include行之前。

Winsock2.h头文件内部包含来自Windows.h头文件的核心元素，因此Winsock应用程序中的Windows.h头文件通常没有#include行。 如果Windows.h头文件需要#include行，则应在#define WIN32_LEAN_AND_MEAN宏之前添加#include行。 由于历史原因，Windows.h标头默认包含Windows套接字1.1的Winsock.h头文件。 Winsock.h头文件中的声明将与Windows Sockets 2.0所需的Winsock2.h头文件中的声明冲突。 WIN32_LEAN_AND_MEAN宏可防止Windows.h标头包含Winsock.h。 示例说明如下所示。

  1. #ifndef WIN32_LEAN_AND_MEAN
  2. #define WIN32_LEAN_AND_MEAN
  3. #endif
  4.  
  5. #include <windows.h>
  6. #include <winsock2.h>
  7. #include <ws2tcpip.h>
  8. #include <iphlpapi.h>
  9. #include <stdio.h>
  10.  
  11. #pragma comment(lib, "Ws2_32.lib")
  12.  
  13. int main() {
  14.   return 0;
  15. }

 

 

三、初始化Winsock

调用Winsock函数的所有进程（应用程序或DLL）必须在进行其他Winsock函数调用之前初始化Windows Sockets DLL的使用。 这也确保系统支持Winsock。

为了初始化Winsock

1、创建一个名为wsaData的WSADATA对象。

WSADATA wsaData;

2、调用WSAStartup并将其值作为整数返回并检查错误。

  1. int iResult;
  2.  
  3. // Initialize Winsock
  4. iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
  5. if (iResult != 0) {
  6.     printf("WSAStartup failed: %d\n", iResult);
  7.     return 1;
  8. }

调用WSAStartup函数以启动WS2_32.dll的使用。

WSADATA结构包含有关Windows套接字实现的信息。 WSAStartup的MAKEWORD（2,2）参数在系统上发出对Winsock 2.2版的请求，并将传递的版本设置为调用者可以使用的最高版本的Windows套接字支持。

 

 

四、Winsock客户端应用程序

以下部分描述了创建Winsock客户端应用程序的其余步骤。 以下是创建流式TCP / IP客户端的一般模型。

  • 为客户端创建套接字
  • 连接到插座
  • 在客户端上发送和接收数据
  • 断开客户端连接

 

一）、为客户端创建套接字

初始化之后，必须实例化SOCKET对象以供客户端使用。

为了创建套接字

1、声明包含sockaddr结构的addrinfo对象并初始化这些值。 对于此应用程序，未指定Internet地址系列，以便可以返回IPv6或IPv4地址。 应用程序请求套接字类型为TCP协议的流套接字。

  1. struct addrinfo *result = NULL,
  2.                 *ptr = NULL,
  3.                 hints;
  4.  
  5. ZeroMemory( &hints, sizeof(hints) );
  6. hints.ai_family = AF_UNSPEC;
  7. hints.ai_socktype = SOCK_STREAM;
  8. hints.ai_protocol = IPPROTO_TCP;

2、调用getaddrinfo函数，请求在命令行上传递的服务器名称的IP地址。 客户端将连接到的服务器上的TCP端口在此示例中由DEFAULT_PORT定义为27015。 getaddrinfo函数将其值返回为检查错误的整数。

  1. #define DEFAULT_PORT "27015"
  2.  
  3. // Resolve the server address and port
  4. iResult = getaddrinfo(argv[1], DEFAULT_PORT, &hints, &result);
  5. if (iResult != 0) {
  6.     printf("getaddrinfo failed: %d\n", iResult);
  7.     WSACleanup();
  8.     return 1;
  9. }

3、创建一个名为ConnectSocket的SOCKET对象。

SOCKET ConnectSocket = INVALID_SOCKET;

4、调用套接字函数并将其值返回到ConnectSocket变量。 对于此应用程序，请使用调用getaddrinfo返回的第一个IP地址，该地址与hints参数中指定的地址系列，套接字类型和协议相匹配。 在此示例中，指定了TCP流套接字，其套接字类型为SOCK_STREAM，协议为IPPROTO_TCP。 地址系列未指定（AF_UNSPEC），因此返回的IP地址可以是服务器的IPv6或IPv4地址。

如果客户端应用程序只想使用IPv6或IPv4进行连接，则需要在hints参数中将地址族设置为IPv6的AF_INET6或IPv4的AF_INET。

  1. // Attempt to connect to the first address returned by
  2. // the call to getaddrinfo
  3. ptr=result;
  4.  
  5. // Create a SOCKET for connecting to server
  6. ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, 
  7.     ptr->ai_protocol);

5、检查错误以确保套接字是有效的套接字。

  1. if (ConnectSocket == INVALID_SOCKET) {
  2.     printf("Error at socket(): %ld\n", WSAGetLastError());
  3.     freeaddrinfo(result);
  4.     WSACleanup();
  5.     return 1;
  6. }

传递给套接字函数的参数可以针对不同的实现进行更改。

错误检测是成功的网络代码的关键部分。 如果套接字调用失败，则返回INVALID_SOCKET。 上一代码中的if语句用于捕获创建套接字时可能发生的任何错误。 WSAGetLastError返回与上次发生的错误关联的错误号。

注意

根据应用，可能需要进行更广泛的错误检查。

WSACleanup用于终止WS2_32 DLL的使用。

 

二）、连接到套接字

要使客户端在网络上进行通信，它必须连接到服务器。‘

为了链接套接字

调用connect函数，将创建的套接字和sockaddr结构作为参数传递。

  1. // Connect to server.
  2. iResult = connect( ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
  3. if (iResult == SOCKET_ERROR) {
  4.     closesocket(ConnectSocket);
  5.     ConnectSocket = INVALID_SOCKET;
  6. }
  7.  
  8. // Should really try the next address returned by getaddrinfo
  9. // if the connect call failed
  10. // But for this simple example we just free the resources
  11. // returned by getaddrinfo and print an error message
  12.  
  13. freeaddrinfo(result);
  14.  
  15. if (ConnectSocket == INVALID_SOCKET) {
  16.     printf("Unable to connect to server!\n");
  17.     WSACleanup();
  18.     return 1;
  19. }

’getaddrinfo函数用于确定sockaddr结构中的值。 在此示例中，getaddrinfo函数返回的第一个IP地址用于指定传递给connect的sockaddr结构。 如果连接调用未能通过第一个IP地址，则尝试从getaddrinfo函数返回的链表中的下一个addrinfo结构。

sockaddr结构中指定的信息包括：

  • 客户端将尝试连接的服务器的IP地址。
  • 客户端将连接到的服务器上的端口号。 当客户端调用getaddrinfo函数时，此端口被指定为端口27015。

 

三）、在客户端上发送和接收数据

以下代码演示了建立连接后客户端使用的send和recv函数。

客户端

  1. #define DEFAULT_BUFLEN 512
  2.  
  3. int recvbuflen = DEFAULT_BUFLEN;
  4.  
  5. char *sendbuf = "this is a test";
  6. char recvbuf[DEFAULT_BUFLEN];
  7.  
  8. int iResult;
  9.  
  10. // Send an initial buffer
  11. iResult = send(ConnectSocket, sendbuf, (int) strlen(sendbuf), 0);
  12. if (iResult == SOCKET_ERROR) {
  13.     printf("send failed: %d\n", WSAGetLastError());
  14.     closesocket(ConnectSocket);
  15.     WSACleanup();
  16.     return 1;
  17. }
  18.  
  19. printf("Bytes Sent: %ld\n", iResult);
  20.  
  21. // shutdown the connection for sending since no more data will be sent
  22. // the client can still use the ConnectSocket for receiving data
  23. iResult = shutdown(ConnectSocket, SD_SEND);
  24. if (iResult == SOCKET_ERROR) {
  25.     printf("shutdown failed: %d\n", WSAGetLastError());
  26.     closesocket(ConnectSocket);
  27.     WSACleanup();
  28.     return 1;
  29. }
  30.  
  31. // Receive data until the server closes the connection
  32. do {
  33.     iResult = recv(ConnectSocket, recvbuf, recvbuflen, 0);
  34.     if (iResult > 0)
  35.         printf("Bytes received: %d\n", iResult);
  36.     else if (iResult == 0)
  37.         printf("Connection closed\n");
  38.     else
  39.         printf("recv failed: %d\n", WSAGetLastError());
  40. } while (iResult > 0);

send和recv函数分别返回发送或接收的字节数的整数值或错误。 每个函数也采用相同的参数：活动套接字，字符缓冲区，要发送或接收的字节数，以及要使用的任何标志。

 

四）、断开客户端连接

一旦客户端完成发送和接收数据，客户端将断开与服务器的连接并关闭套接字。

为了断开连接并关闭套接字

1、当客户端完成向服务器发送数据时，可以调用shutdown函数指定SD_SEND以关闭套接字的发送端。 这允许服务器释放此套接字的一些资源。 客户端应用程序仍然可以在套接字上接收数据。

  1. // shutdown the send half of the connection since no more data will be sent
  2. iResult = shutdown(ConnectSocket, SD_SEND);
  3. if (iResult == SOCKET_ERROR) {
  4.     printf("shutdown failed: %d\n", WSAGetLastError());
  5.     closesocket(ConnectSocket);
  6.     WSACleanup();
  7.     return 1;
  8. }

2、当客户端应用程序完成接收数据时，将调用closesocket函数来关闭套接字。

使用Windows套接字DLL完成客户端应用程序时，将调用WSACleanup函数以释放资源。

  1. // cleanup
  2. closesocket(ConnectSocket);
  3. WSACleanup();
  4.  
  5. return 0;

 

 

五、Winsock服务器应用程序

以下部分描述了创建Winsock服务器应用程序的其余步骤。 以下是创建流式TCP / IP服务器的一般模型。

  • 为服务器创建套接字
  • 绑定套接字
  • 听一个插座
  • 接受连接
  • 在服务器上接收和发送数据
  • 断开服务器连接

 

一）、为服务器创建套接字

初始化之后，必须实例化SOCKET对象以供服务器使用。

为服务器创建套接字

1、getaddrinfo函数用于确定sockaddr结构中的值：

  • AF_INET用于指定IPv4地址族。
  • SOCK_STREAM用于指定流套接字。
  • IPPROTO_TCP用于指定TCP协议。
  • AI_PASSIVE标志表示调用者打算在调用bind函数时使用返回的套接字地址结构。 当设置AI_PASSIVE标志并且getaddrinfo函数的nodename参数是NULL指针时，套接字地址结构的IP地址部分对于IPv4地址设置为INADDR_ANY，对于IPv6地址设置为IN6ADDR_ANY_INIT。
  • 27015是与客户端将连接到的服务器关联的端口号。

addadfo结构由getaddrinfo函数使用。

  1. #define DEFAULT_PORT "27015"
  2.  
  3. struct addrinfo *result = NULL, *ptr = NULL, hints;
  4.  
  5. ZeroMemory(&hints, sizeof (hints));
  6. hints.ai_family = AF_INET;
  7. hints.ai_socktype = SOCK_STREAM;
  8. hints.ai_protocol = IPPROTO_TCP;
  9. hints.ai_flags = AI_PASSIVE;
  10.  
  11. // Resolve the local address and port to be used by the server
  12. iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
  13. if (iResult != 0) {
  14.     printf("getaddrinfo failed: %d\n", iResult);
  15.     WSACleanup();
  16.     return 1;
  17. }

2、为服务器创建一个名为ListenSocket的SOCKET对象以侦听客户端连接。

SOCKET ListenSocket = INVALID_SOCKET;

3、调用套接字函数并将其值返回给ListenSocket变量。 对于此服务器应用程序，请使用调用getaddrinfo返回的第一个IP地址，该地址与hints参数中指定的地址系列，套接字类型和协议相匹配。 在此示例中，请求IPv4的TCP流套接字，其地址系列为IPv4，套接字类型为SOCK_STREAM，协议为IPPROTO_TCP。 因此，为ListenSocket请求了一个IPv4地址。

如果服务器应用程序想要侦听IPv6，则需要在hints参数中将地址族设置为AF_INET6。 如果服务器想要同时侦听IPv6和IPv4，则必须创建两个侦听套接字，一个用于IPv6，另一个用于IPv4。 这两个插座必须由应用程序单独处理。

Windows Vista及更高版本提供了创建单个IPv6套接字的功能，该套接字处于双堆栈模式以侦听IPv6和IPv4。 有关此功能的更多信息，请参阅双栈套接字。

  1. // Create a SOCKET for the server to listen for client connections
  2.  
  3. ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);

4、检查错误以确保套接字是有效的套接字。

  1. if (ListenSocket == INVALID_SOCKET) {
  2.     printf("Error at socket(): %ld\n", WSAGetLastError());
  3.     freeaddrinfo(result);
  4.     WSACleanup();
  5.     return 1;
  6. }

 

二）、绑定套接字

要使服务器接受客户端连接，必须将其绑定到系统中的网络地址。 以下代码演示了如何将已创建的套接字绑定到IP地址和端口。 客户端应用程序使用IP地址和端口连接到主机网络。

为了绑定套接字

sockaddr结构保存有关地址系列，IP地址和端口号的信息。

调用bind函数，将从getaddrinfo函数返回的创建的socket和sockaddr结构作为参数传递。 检查一般错误。

  1. // Setup the TCP listening socket
  2.     iResult = bind( ListenSocket, result->ai_addr, (int)result->ai_addrlen);
  3.     if (iResult == SOCKET_ERROR) {
  4.         printf("bind failed with error: %d\n", WSAGetLastError());
  5.         freeaddrinfo(result);
  6.         closesocket(ListenSocket);
  7.         WSACleanup();
  8.         return 1;
  9.     }

调用bind函数后，不再需要getaddrinfo函数返回的地址信息。 调用freeaddrinfo函数以释放getaddrinfo函数为此地址信息分配的内存。

freeaddrinfo(result);

 

三）、监听套接字

套接字绑定到系统上的IP地址和端口后，服务器必须侦听该IP地址和端口以获取传入的连接请求。

为了监听套接字

调用listen函数，将创建的套接字作为参数传递，并将backlog的值，待接受的挂起队列的最大长度作为接受。 在此示例中，backlog参数设置为SOMAXCONN。 此值是一个特殊常量，它指示Winsock提供程序为此套接字允许队列中最大合理数量的挂起连接。 检查一般错误的返回值。

  1. if ( listen( ListenSocket, SOMAXCONN ) == SOCKET_ERROR ) {
  2.     printf( "Listen failed with error: %ld\n", WSAGetLastError() );
  3.     closesocket(ListenSocket);
  4.     WSACleanup();
  5.     return 1;
  6. }

 

四）、接受连接

一旦套接字正在侦听连接，程序必须处理该套接字上的连接请求。

为了接受套接字上的连接

1、创建一个名为ClientSocket的临时SOCKET对象，用于接受来自客户端的连接。

SOCKET ClientSocket;

2、通常，服务器应用程序将被设计为侦听来自多个客户端的连接。 对于高性能服务器，通常使用多个线程来处理多个客户端连接。

使用Winsock有几种不同的编程技术可用于侦听多个客户端连接。 一种编程技术是创建一个连续循环，使用listen函数检查连接请求（请参阅侦听套接字）。 如果发生连接请求，应用程序将调用accept，AcceptEx或WSAAccept函数，并将工作传递给另一个线程来处理请求。 其他几种编程技术也是可能的。

请注意，此基本示例非常简单，不使用多个线程。 该示例也只是侦听并接受单个连接。

  1. ClientSocket = INVALID_SOCKET;
  2.  
  3. // Accept a client socket
  4. ClientSocket = accept(ListenSocket, NULL, NULL);
  5. if (ClientSocket == INVALID_SOCKET) {
  6.     printf("accept failed: %d\n", WSAGetLastError());
  7.     closesocket(ListenSocket);
  8.     WSACleanup();
  9.     return 1;
  10. }

3、当客户端连接被接受时，服务器应用程序通常会将接受的客户端套接字（上面示例代码中的ClientSocket变量）传递给工作线程或I / O完成端口，并继续接受其他连接。 在此基本示例中，服务器继续执行下一步。

有许多其他编程技术可用于侦听和接受多个连接。 这些包括使用select或WSAPoll函数。 Microsoft Windows软件开发工具包（SDK）附带的Advanced Winsock示例中说明了这些各种编程技术中的一些示例。

注意

在Unix系统上，服务器的通用编程技术是用于监听连接的应用程序。 当接受连接时，父进程将调用fork函数来创建一个新的子进程来处理客户端连接，从父进程继承套接字。 Windows不支持此编程技术，因为不支持fork函数。 此技术通常也不适用于高性能服务器，因为创建新进程所需的资源远远大于线程所需的资源。

 

五）、在服务器上接收和发送数据

以下代码演示了服务器使用的recv和send函数。

为了在套接字上接收和发送数据

  1. #define DEFAULT_BUFLEN 512
  2.  
  3. char recvbuf[DEFAULT_BUFLEN];
  4. int iResult, iSendResult;
  5. int recvbuflen = DEFAULT_BUFLEN;
  6.  
  7. // Receive until the peer shuts down the connection
  8. do {
  9.  
  10.     iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
  11.     if (iResult > 0) {
  12.         printf("Bytes received: %d\n", iResult);
  13.  
  14.         // Echo the buffer back to the sender
  15.         iSendResult = send(ClientSocket, recvbuf, iResult, 0);
  16.         if (iSendResult == SOCKET_ERROR) {
  17.             printf("send failed: %d\n", WSAGetLastError());
  18.             closesocket(ClientSocket);
  19.             WSACleanup();
  20.             return 1;
  21.         }
  22.         printf("Bytes sent: %d\n", iSendResult);
  23.     } else if (iResult == 0)
  24.         printf("Connection closing...\n");
  25.     else {
  26.         printf("recv failed: %d\n", WSAGetLastError());
  27.         closesocket(ClientSocket);
  28.         WSACleanup();
  29.         return 1;
  30.     }
  31.  
  32. } while (iResult > 0);

send和recv函数分别返回发送或接收的字节数的整数值或错误。 每个函数也采用相同的参数：活动套接字，字符缓冲区，要发送或接收的字节数，以及要使用的任何标志。

 

六）、断开服务器连接

一旦服务器完成从客户端接收数据并将数据发送回客户端，服务器将断开与客户端的连接并关闭套接字。

为了断开服务器连接

1、当服务器完成向客户端发送数据时，可以调用shutdown函数指定SD_SEND以关闭套接字的发送端。 这允许客户端释放此套接字的一些资源。 服务器应用程序仍然可以在套接字上接收数据。

  1. // shutdown the send half of the connection since no more data will be sent
  2. iResult = shutdown(ClientSocket, SD_SEND);
  3. if (iResult == SOCKET_ERROR) {
  4.     printf("shutdown failed: %d\n", WSAGetLastError());
  5.     closesocket(ClientSocket);
  6.     WSACleanup();
  7.     return 1;
  8. }

2、当客户端应用程序完成接收数据时，将调用closesocket函数来关闭套接字。

使用Windows套接字DLL完成客户端应用程序时，将调用WSACleanup函数以释放资源。

  1. // cleanup
  2. closesocket(ClientSocket);
  3. WSACleanup();
  4.  
  5. return 0;

 

 

六、运行Winsock客户端和服务器代码示例

本节包含TCP / IP客户端和服务器应用程序的完整源代码：

  • 完整的Winsock客户端代码
  • 完整的Winsock服务器代码

应在启动客户端应用程序之前启动服务器应用程序。

要执行服务器，请编译完整的服务器源代码并运行可执行文件。 服务器应用程序侦听TCP端口27015以供客户端连接。 一旦客户端连接，服务器就会从客户端接收数据，并将收到的数据回送（发送）回客户端。 当客户端关闭连接时，服务器会关闭客户端套接字，关闭套接字并退出。

要执行客户端，请编译完整的客户端源代码并运行可执行文件。 客户端应用程序要求在执行客户端时将运行服务器应用程序的计算机的名称或IP地址作为命令行参数传递。 如果客户端和服务器在示例计算机上执行，则可以按如下方式启动客户端：

客户端localhost

客户端尝试在TCP端口27015上连接到服务器。客户端连接后，客户端将数据发送到服务器并接收从服务器发回的任何数据。 然后客户端关闭套接字并退出。

 

一）、完整的Winsock客户端代码

以下是基本Winsock TCP / IP客户端应用程序的完整源代码。

Winsock客户端源代码

  1. #define WIN32_LEAN_AND_MEAN
  2.  
  3. #include <windows.h>
  4. #include <winsock2.h>
  5. #include <ws2tcpip.h>
  6. #include <stdlib.h>
  7. #include <stdio.h>
  8.  
  9.  
  10. // Need to link with Ws2_32.lib, Mswsock.lib, and Advapi32.lib
  11. #pragma comment (lib, "Ws2_32.lib")
  12. #pragma comment (lib, "Mswsock.lib")
  13. #pragma comment (lib, "AdvApi32.lib")
  14.  
  15.  
  16. #define DEFAULT_BUFLEN 512
  17. #define DEFAULT_PORT "27015"
  18.  
  19. int __cdecl main(int argc, char **argv) 
  20. {
  21.     WSADATA wsaData;
  22.     SOCKET ConnectSocket = INVALID_SOCKET;
  23.     struct addrinfo *result = NULL,
  24.                     *ptr = NULL,
  25.                     hints;
  26.     char *sendbuf = "this is a test";
  27.     char recvbuf[DEFAULT_BUFLEN];
  28.     int iResult;
  29.     int recvbuflen = DEFAULT_BUFLEN;
  30.     
  31.     // Validate the parameters
  32.     if (argc != 2) {
  33.         printf("usage: %s server-name\n", argv[0]);
  34.         return 1;
  35.     }
  36.  
  37.     // Initialize Winsock
  38.     iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
  39.     if (iResult != 0) {
  40.         printf("WSAStartup failed with error: %d\n", iResult);
  41.         return 1;
  42.     }
  43.  
  44.     ZeroMemory( &hints, sizeof(hints) );
  45.     hints.ai_family = AF_UNSPEC;
  46.     hints.ai_socktype = SOCK_STREAM;
  47.     hints.ai_protocol = IPPROTO_TCP;
  48.  
  49.     // Resolve the server address and port
  50.     iResult = getaddrinfo(argv[1], DEFAULT_PORT, &hints, &result);
  51.     if ( iResult != 0 ) {
  52.         printf("getaddrinfo failed with error: %d\n", iResult);
  53.         WSACleanup();
  54.         return 1;
  55.     }
  56.  
  57.     // Attempt to connect to an address until one succeeds
  58.     for(ptr=result; ptr != NULL ;ptr=ptr->ai_next) {
  59.  
  60.         // Create a SOCKET for connecting to server
  61.         ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, 
  62.             ptr->ai_protocol);
  63.         if (ConnectSocket == INVALID_SOCKET) {
  64.             printf("socket failed with error: %ld\n", WSAGetLastError());
  65.             WSACleanup();
  66.             return 1;
  67.         }
  68.  
  69.         // Connect to server.
  70.         iResult = connect( ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
  71.         if (iResult == SOCKET_ERROR) {
  72.             closesocket(ConnectSocket);
  73.             ConnectSocket = INVALID_SOCKET;
  74.             continue;
  75.         }
  76.         break;
  77.     }
  78.  
  79.     freeaddrinfo(result);
  80.  
  81.     if (ConnectSocket == INVALID_SOCKET) {
  82.         printf("Unable to connect to server!\n");
  83.         WSACleanup();
  84.         return 1;
  85.     }
  86.  
  87.     // Send an initial buffer
  88.     iResult = send( ConnectSocket, sendbuf, (int)strlen(sendbuf), 0 );
  89.     if (iResult == SOCKET_ERROR) {
  90.         printf("send failed with error: %d\n", WSAGetLastError());
  91.         closesocket(ConnectSocket);
  92.         WSACleanup();
  93.         return 1;
  94.     }
  95.  
  96.     printf("Bytes Sent: %ld\n", iResult);
  97.  
  98.     // shutdown the connection since no more data will be sent
  99.     iResult = shutdown(ConnectSocket, SD_SEND);
  100.     if (iResult == SOCKET_ERROR) {
  101.         printf("shutdown failed with error: %d\n", WSAGetLastError());
  102.         closesocket(ConnectSocket);
  103.         WSACleanup();
  104.         return 1;
  105.     }
  106.  
  107.     // Receive until the peer closes the connection
  108.     do {
  109.  
  110.         iResult = recv(ConnectSocket, recvbuf, recvbuflen, 0);
  111.         if ( iResult > 0 )
  112.             printf("Bytes received: %d\n", iResult);
  113.         else if ( iResult == 0 )
  114.             printf("Connection closed\n");
  115.         else
  116.             printf("recv failed with error: %d\n", WSAGetLastError());
  117.  
  118.     } while( iResult > 0 );
  119.  
  120.     // cleanup
  121.     closesocket(ConnectSocket);
  122.     WSACleanup();
  123.  
  124.     return 0;
  125. }

 

二）、完整的Winsock服务器代码

以下是基本Winsock TCP / IP Server应用程序的完整源代码。

Winsock服务器源代码

  1. #undef UNICODE
  2.  
  3. #define WIN32_LEAN_AND_MEAN
  4.  
  5. #include <windows.h>
  6. #include <winsock2.h>
  7. #include <ws2tcpip.h>
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10.  
  11. // Need to link with Ws2_32.lib
  12. #pragma comment (lib, "Ws2_32.lib")
  13. // #pragma comment (lib, "Mswsock.lib")
  14.  
  15. #define DEFAULT_BUFLEN 512
  16. #define DEFAULT_PORT "27015"
  17.  
  18. int __cdecl main(void) 
  19. {
  20.     WSADATA wsaData;
  21.     int iResult;
  22.  
  23.     SOCKET ListenSocket = INVALID_SOCKET;
  24.     SOCKET ClientSocket = INVALID_SOCKET;
  25.  
  26.     struct addrinfo *result = NULL;
  27.     struct addrinfo hints;
  28.  
  29.     int iSendResult;
  30.     char recvbuf[DEFAULT_BUFLEN];
  31.     int recvbuflen = DEFAULT_BUFLEN;
  32.     
  33.     // Initialize Winsock
  34.     iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
  35.     if (iResult != 0) {
  36.         printf("WSAStartup failed with error: %d\n", iResult);
  37.         return 1;
  38.     }
  39.  
  40.     ZeroMemory(&hints, sizeof(hints));
  41.     hints.ai_family = AF_INET;
  42.     hints.ai_socktype = SOCK_STREAM;
  43.     hints.ai_protocol = IPPROTO_TCP;
  44.     hints.ai_flags = AI_PASSIVE;
  45.  
  46.     // Resolve the server address and port
  47.     iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
  48.     if ( iResult != 0 ) {
  49.         printf("getaddrinfo failed with error: %d\n", iResult);
  50.         WSACleanup();
  51.         return 1;
  52.     }
  53.  
  54.     // Create a SOCKET for connecting to server
  55.     ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
  56.     if (ListenSocket == INVALID_SOCKET) {
  57.         printf("socket failed with error: %ld\n", WSAGetLastError());
  58.         freeaddrinfo(result);
  59.         WSACleanup();
  60.         return 1;
  61.     }
  62.  
  63.     // Setup the TCP listening socket
  64.     iResult = bind( ListenSocket, result->ai_addr, (int)result->ai_addrlen);
  65.     if (iResult == SOCKET_ERROR) {
  66.         printf("bind failed with error: %d\n", WSAGetLastError());
  67.         freeaddrinfo(result);
  68.         closesocket(ListenSocket);
  69.         WSACleanup();
  70.         return 1;
  71.     }
  72.  
  73.     freeaddrinfo(result);
  74.  
  75.     iResult = listen(ListenSocket, SOMAXCONN);
  76.     if (iResult == SOCKET_ERROR) {
  77.         printf("listen failed with error: %d\n", WSAGetLastError());
  78.         closesocket(ListenSocket);
  79.         WSACleanup();
  80.         return 1;
  81.     }
  82.  
  83.     // Accept a client socket
  84.     ClientSocket = accept(ListenSocket, NULL, NULL);
  85.     if (ClientSocket == INVALID_SOCKET) {
  86.         printf("accept failed with error: %d\n", WSAGetLastError());
  87.         closesocket(ListenSocket);
  88.         WSACleanup();
  89.         return 1;
  90.     }
  91.  
  92.     // No longer need server socket
  93.     closesocket(ListenSocket);
  94.  
  95.     // Receive until the peer shuts down the connection
  96.     do {
  97.  
  98.         iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
  99.         if (iResult > 0) {
  100.             printf("Bytes received: %d\n", iResult);
  101.  
  102.         // Echo the buffer back to the sender
  103.             iSendResult = send( ClientSocket, recvbuf, iResult, 0 );
  104.             if (iSendResult == SOCKET_ERROR) {
  105.                 printf("send failed with error: %d\n", WSAGetLastError());
  106.                 closesocket(ClientSocket);
  107.                 WSACleanup();
  108.                 return 1;
  109.             }
  110.             printf("Bytes sent: %d\n", iSendResult);
  111.         }
  112.         else if (iResult == 0)
  113.             printf("Connection closing...\n");
  114.         else  {
  115.             printf("recv failed with error: %d\n", WSAGetLastError());
  116.             closesocket(ClientSocket);
  117.             WSACleanup();
  118.             return 1;
  119.         }
  120.  
  121.     } while (iResult > 0);
  122.  
  123.     // shutdown the connection since we're done
  124.     iResult = shutdown(ClientSocket, SD_SEND);
  125.     if (iResult == SOCKET_ERROR) {
  126.         printf("shutdown failed with error: %d\n", WSAGetLastError());
  127.         closesocket(ClientSocket);
  128.         WSACleanup();
  129.         return 1;
  130.     }
  131.  
  132.     // cleanup
  133.     closesocket(ClientSocket);
  134.     WSACleanup();
  135.  
  136.     return 0;
  137. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/147056
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号