socket通信流程

image.png

tcp

server side:
socket()->bind()->listen()->accept()->send()/recv()->closesocket()

client:
socket()->connet()->send()/recv()->closesocket()

udp

server:
socket()->bind()->sendto()/recvfrom()->closesocket()

client:
socket()->sendto()/recvfrom()/closesocket()

winsock

库文件

tcp server

  1. #ifndef WIN32_LEAN_AND_MEAN
  2. #define WIN32_LEAN_AND_MEAN  //此宏用于预防 winsock.h 和winsock2.h 冲突
  3. #endif
  5. #include <winsock2.h>
  6. #include <ws2tcpip.h>
  7. #include <stdio.h>
  9. #pragma comment(lib, "Ws2_32.lib")

tcpclient

  1. #define WIN32_LEAN_AND_MEAN
  3. #include <windows.h>
  4. #include <winsock2.h>
  5. #include <ws2tcpip.h>
  6. #include <stdlib.h>
  7. #include <stdio.h>
  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")

初始化winsock

使用winsock 编程前需要对winsock初始化，使用完毕后需要释放。

winsock初始化函数

  1. int WSAStartup(WORD wVersionRequire,LPWSADATA lpWSAData);
  2. /*
  3. wVersionRequire 是winsock 初始换版本号 ，winsock有多个版本 常用 2.2
  4. lpWSAData         是一个指向WSAdata 的结构体指针
  5. 函数返回值        0 成功 ，其他值 失败
  7. */

winsock 释放函数

  1. int WSACleanup(void);

示例代码

  1. int iResult;
  2. //创建WSADATA 对象
  3. WSADATA wsaData;
  4. //...
  5. // 初始化winsock
  6. iResult = WSAStartup(MAKEWORD(2,2),&wsaData);
  7. if(iResult != 0){
  8.     printf("WSAStart failed : %d",iResult);
  9.     return 1;
  11. }

TCP

server

创建addrinfo
示例代码

  1. #define DEFAULT_PORT "27015"
  3. struct addrinfo *result = NULL, *ptr = NULL, hints;
  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;
  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. }

socket创建与关闭

scoket(),closesocket()

  1. SOCKET socket(int af,int type,int protocol);
  2. // af代表地址簇， 
  3. //type 为套接字类型 stream , dgram,raw 代表流套接字，数据包套接字，原始协议接口
  4. //protocol 协议类型 tcp,udp,icmp ,etc
  6. int closesocket(SOCKET s);

示例代码

  1. SOCKET ListenSocket = INVALID_SOCKET;
  2. // Create a SOCKET for the server to listen for client connections
  4. ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
  6. //检查是否有错
  7. if (ListenSocket == INVALID_SOCKET) {
  8.     printf("Error at socket(): %ld\n", WSAGetLastError());
  9.     freeaddrinfo(result);
  10.     WSACleanup();
  11.     return 1;
  12. }

绑定socket

  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.     }

侦听套接字

  1. if ( listen( ListenSocket, SOMAXCONN ) == SOCKET_ERROR ) {  //SOMAXCONN 最大连接数
  2.     printf( "Listen failed with error: %ld\n", WSAGetLastError() );
  3.     freeaddrinfo(result);
  4.     closesocket(ListenSocket);
  5.     WSACleanup();
  6.     return 1;
  7. }

接受连接

创建ClientSocket 临时socket对象，接受客户端的连接

有几种不同的编程技术使用 Winsock，可用于侦听多个客户端连接。 一种编程方法是创建一个连续循环，该循环使用 侦听 函数检查连接请求 (请参阅 在套接字) 上进行侦听 。 如果出现连接请求，应用程序将调用 accept、 AcceptEx或 WSAAccept 函数，并将工作传递到另一个线程来处理请求。

  1. SOCKET ClientSocket;
  2. ClientSocket  = INVALID_SOCKET;
  3. CleintSocket = accept(ListenSocket,NULL,NULL);
  4. if(ClientSocket == INVALID_SOCKET){
  5.     printf("accept failed %d\n",WSAGetLastError());
  6.     WSACleanup();
  7.     return 1;
  8. }

当客户端连接被接受后，服务器应用程序通常会将接受的客户端套接字传递 (上述示例代码中的 ClientSocket 变量) 到工作线程或 i/o 完成端口，并继续接受其他连接。
还有许多其他编程技术可用于侦听和接受多个连接。 其中包括使用 select 函数或 WSAPoll 函数。

收发数据

  1. #define DEFAULT_BUFLEN 512
  3. char recvbuf[DEFAULT_BUFLEN];
  4. int iResult, iSendResult;
  5. int recvbuflen = DEFAULT_BUFLEN;
  7. // Receive until the peer shuts down the connection
  8. do {
  10.     iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
  11.     if (iResult > 0) {
  12.         printf("Bytes received: %d\n", iResult);
  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.     }
  32. } while (iResult > 0);

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

关闭套接字

当服务器将数据发送到客户端时，可以调用 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. }

完整代码

  1. #undef UNICODE
  3. #define WIN32_LEAN_AND_MEAN
  5. #include <windows.h>
  6. #include <winsock2.h>
  7. #include <ws2tcpip.h>
  8. #include <stdlib.h>
  9. #include <stdio.h>
  11. // Need to link with Ws2_32.lib
  12. #pragma comment (lib, "Ws2_32.lib")
  13. // #pragma comment (lib, "Mswsock.lib")
  15. #define DEFAULT_BUFLEN 512
  16. #define DEFAULT_PORT "27015"
  18. int __cdecl main(void) 
  19. {
  20.     WSADATA wsaData;
  21.     int iResult;
  23.     SOCKET ListenSocket = INVALID_SOCKET;
  24.     SOCKET ClientSocket = INVALID_SOCKET;
  26.     struct addrinfo *result = NULL;
  27.     struct addrinfo hints;
  29.     int iSendResult;
  30.     char recvbuf[DEFAULT_BUFLEN];
  31.     int recvbuflen = DEFAULT_BUFLEN;
  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.     }
  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;
  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.     }
  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.     }
  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.     }
  73.     freeaddrinfo(result);
  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.     }
  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.     }
  92.     // No longer need server socket
  93.     closesocket(ListenSocket);
  95.     // Receive until the peer shuts down the connection
  96.     do {
  98.         iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
  99.         if (iResult > 0) {
  100.             printf("Bytes received: %d\n", iResult);
  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.         }
  121.     } while (iResult > 0);
  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.     }
  132.     // cleanup
  133.     closesocket(ClientSocket);
  134.     WSACleanup();
  136.     return 0;
  137. }

client

创建socket

声明一个包含 sockaddr结构的 addrinfo对象并初始化这些值

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

调用 getaddrinfo 函数，请求在命令行上传递的服务器名称的 IP 地址。 在此示例中，客户端将连接到的服务器上的 TCP 端口被默认 _ 端口定义为27015。 Getaddrinfo 函数以检查是否有错误的整数的形式返回其值

  1. #define DEFAULT_PORT "27015"
  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. }

创建ConnectSocket

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

检查错误

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

连接socket

调用 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. }
  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
  13. freeaddrinfo(result);
  15. if (ConnectSocket == INVALID_SOCKET) {
  16.     printf("Unable to connect to server!\n");
  17.     WSACleanup();
  18.     return 1;
  19. }

getaddrinfo函数用于确定 sockaddr 结构中的值。 本示例使用 getaddrinfo 函数返回的第一个 IP 地址来指定 传递给连接的 sockaddr 结构。 如果 第 一个 IP 地址的连接调用失败，请尝试从 getaddrinfo 函数返回的链接列表中的下一个 addrinfo结构

收发数据

  1. #define DEFAULT_BUFLEN 512
  3. int recvbuflen = DEFAULT_BUFLEN;
  5. const char *sendbuf = "this is a test";
  6. char recvbuf[DEFAULT_BUFLEN];
  8. int iResult;
  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. }
  19. printf("Bytes Sent: %ld\n", iResult);
  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. }
  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函数都分别返回发送或接收的字节数的整数值或错误。 每个函数也采用相同的参数：活动套接字、 字符 缓冲区、要发送或接收的字节数以及使用的任何标志。

断开连接

客户端完成向服务器发送数据后，可以调用 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. }

客户端应用程序收到数据后，将调用 closesocket 函数来关闭套接字。
使用套接字 DLL 完成客户端Windows，将调用 WSACleanup函数以释放资源

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

完整代码

  1. #define WIN32_LEAN_AND_MEAN
  3. #include <windows.h>
  4. #include <winsock2.h>
  5. #include <ws2tcpip.h>
  6. #include <stdlib.h>
  7. #include <stdio.h>
  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")
  16. #define DEFAULT_BUFLEN 512
  17. #define DEFAULT_PORT "27015"
  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.     const char *sendbuf = "this is a test";
  27.     char recvbuf[DEFAULT_BUFLEN];
  28.     int iResult;
  29.     int recvbuflen = DEFAULT_BUFLEN;
  31.     // Validate the parameters
  32.     if (argc != 2) {
  33.         printf("usage: %s server-name\n", argv[0]);
  34.         return 1;
  35.     }
  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.     }
  44.     ZeroMemory( &hints, sizeof(hints) );
  45.     hints.ai_family = AF_UNSPEC;
  46.     hints.ai_socktype = SOCK_STREAM;
  47.     hints.ai_protocol = IPPROTO_TCP;
  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.     }
  57.     // Attempt to connect to an address until one succeeds
  58.     for(ptr=result; ptr != NULL ;ptr=ptr->ai_next) {
  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.         }
  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.     }
  79.     freeaddrinfo(result);
  81.     if (ConnectSocket == INVALID_SOCKET) {
  82.         printf("Unable to connect to server!\n");
  83.         WSACleanup();
  84.         return 1;
  85.     }
  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.     }
  96.     printf("Bytes Sent: %ld\n", iResult);
  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.     }
  107.     // Receive until the peer closes the connection
  108.     do {
  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());
  118.     } while( iResult > 0 );
  120.     // cleanup
  121.     closesocket(ConnectSocket);
  122.     WSACleanup();
  124.     return 0;
  125. }

udp

server

  2. #include <winsock2.h>
  3. #include<iostream>
  4. #pragma comment(lib,"ws2_32.lib")
  5. using namespace std;
  6. int main()
  7. {
  8.     WORD wVersion;
  9.     WSADATA wsaData;
  10.     int er;
  11.     //1.初始化版本信息
  12.     wVersion = MAKEWORD(1, 1);
  13.     //加载套接字库
  14.     er = WSAStartup(wVersion, &wsaData);
  15.     if (er != 0)
  16.     {
  17.         return -1;
  18.     }
  19.     //检测套接字版本信息
  20.     if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
  21.     {
  22.         WSACleanup();
  23.         return -2;
  24.     }
  26.     //2.创建服务器端套接字
  27.     SOCKET sockSer = socket(AF_INET, SOCK_DGRAM, 0);
  28.     SOCKADDR_IN addr_in;
  29.     addr_in.sin_family = AF_INET;//地址族
  30.     addr_in.sin_port = htons(7000);//端口
  31.     addr_in.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//IP
  32.     bind(sockSer, (sockaddr*)&addr_in, sizeof(addr_in));
  34.     SOCKADDR_IN client_addr;
  35.     int len = sizeof(sockaddr_in);
  36.     char recvBuf[1024];
  37.     recvfrom(sockSer, recvBuf, sizeof(recvBuf), 0, (sockaddr*)&client_addr, &len);
  38.     cout << "接受到的数据：" << recvBuf << endl;
  39.     //向客户端发送数据
  40.     sendto(sockSer, recvBuf, sizeof(recvBuf), 0, (sockaddr*)&client_addr, len);
  41.     closesocket(sockSer);
  42.     WSACleanup();
  43.     system("pause");
  44.     return 0;
  45. }

client

  1. #include "stdafx.h"
  2. #include <winsock2.h>
  3. #include<iostream>
  4. #pragma comment(lib,"ws2_32.lib")
  5. using namespace std;
  6. int main()
  7. {
  8.     WORD wVersion;
  9.     WSADATA wsaData;
  10.     int er;
  11.     //1.初始化版本信息
  12.     wVersion = MAKEWORD(1, 1);
  13.     //加载套接字库
  14.     er = WSAStartup(wVersion, &wsaData);
  15.     if (er != 0)
  16.     {
  17.         return -1;
  18.     }
  19.     //检测套接字版本信息
  20.     if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
  21.     {
  22.         WSACleanup();
  23.         return -2;
  24.     }
  26.     //2.创建服务器端套接字
  27.     SOCKET sockSer = socket(AF_INET, SOCK_DGRAM, 0);
  28.     SOCKADDR_IN addr_in;
  29.     addr_in.sin_family = AF_INET;//地址族
  30.     addr_in.sin_port = htons(7000);//端口
  31.     addr_in.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
  32.     bind(sockSer, (sockaddr*)&addr_in, sizeof(addr_in));
  34.     SOCKADDR_IN addr;
  35.     int len = sizeof(addr);
  37.     //向服务器发送数据
  38.     char sendBuf[1024];
  39.     sendto(sockSer, sendBuf, sizeof(sendBuf), 0, (sockaddr*)&addr, len);
  40.     //接受数据
  41.     char recvBuf[1024];
  42.     recvfrom(sockSer, recvBuf, sizeof(recvBuf), 0, (sockaddr*)&addr, &len);
  43.     cout << "接受到服务器端的数据：" << recvBuf << endl;
  44.     closesocket();
  45.     WSACleanup();
  46.     system("pause");
  47.     return 0;
  48. }