首页 > 编程语言> 文章详细

实验2 基于数据报套接字的网络程序设计（计算机网络Ⅱ）

2020-11-12 20:34:07 阅读：278 来源： 互联网

标签：SOCKADDR return Servaddr 计算机网络 printf 服务器接字报套

一、实验环境

操作系统：Win10

开发工具：VS2017

使用语言：C

二、实验内容

1.设计思路

（1）基于数据报套接字的循环服务器回射程序设计

实现基于数据报套接字的循环服务器回射程序编程模型如（1）数据报套接字编程模型。对于数据报循环服务器，服务器每次接收到一个客户的请求并处理后，继续接收进入套接字接收缓冲区的其他请求，因此调用recvfrom()，而后调用sendto()回射数据是循环进行的。这是最常见的无连接服务器的形式，适用于要求对每个请求进行少量处理的服务器设计。

（2）基于数据报套接字的并发服务器回射程序设计

对于并发服务器，则要求当服务器与一个客户进行通信的过程中，可以同时接收其他客户的服务请求，并且服务器要为每一个客户创建一个单独的子线程。

为了实现客户与服务器多次交互数据的并发服务器，本实验采取让服务器在新线程中为每个客户创建一个新的套接字，在其上绑定一个临时端口，然后使用这个套接字处理该客户的后续所有数据交互。而新客户的请求还是用服务器最初创建的套接字以及绑定的端口号进行接收。交互过程如图2-2所示。

图2-2 多次交互的客户请求过程

首先客户端向服务器绑定源端口4502发送请求报文，服务器接收后为其创建子线程，并在线程中创建新的套接口，绑定临时端口号4503（代码具体实现中，每个临时端口依次递增1），之后便可以进行正确的并发服务和通信，即recvfrom()接收数据，sendto()回射消息。

（3）无连接应用程序丢包率测试

用户可以在客户端设置好发包次数sCount，调用sCount次sendto()函数将缓冲区数据发送给服务器。

服务器通过套接字选项SO_RCVBUF选项设置缓冲区大小，通过SO_RCVTIMEO选项设置超时时间，然后开始每隔1000ms接收一次数据。统计接收次数，即收到的数据报个数，最后在服务器计算出丢包率。

2.程序清单（要求有详细的注释）

（1）基于数据报套接字的循环服务器回射程序设计

①服务器

#include <stdio.h>
#include "winsock2.h"
#pragma comment(lib, "ws2_32.lib")
#define SERVER_PORT 4501
#define MAXLINE 1024 //缓冲区长度
int main()
{
WSADATA wsd; //WSADATA变量
SOCKET sConnfd;//连接套接字
sockaddr_in Cliaddr, Servaddr;//通信地址
char sendBuf[MAXLINE]; //发送缓冲区
char recvBuf[MAXLINE];//接收缓冲区
int len = sizeof(SOCKADDR);
int dwError;
//初始化套结字动态库
if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
{
printf("WSAStartup failed!\n");
return -1;
}
if (LOBYTE(wsd.wVersion) != 2 ||HIBYTE(wsd.wVersion) != 2)
{
WSACleanup();
return -1;
}
//创建监听套接字
sConnfd = socket(AF_INET, SOCK_DGRAM, 0);
if (INVALID_SOCKET == sConnfd)
{
printf("socket failed!\n");
WSACleanup();//释放套接字资源;
return -1;
}
memset(&Servaddr, 0, sizeof(Servaddr));
//服务器监听套接字地址
Servaddr.sin_family = AF_INET;
Servaddr.sin_port = htons(SERVER_PORT);
Servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//将IP地址指定为INADDR_ANY，允许套接字向任何分配给本地机器的IP地址发送或接收数据。
//绑定监听套接字
if (SOCKET_ERROR == bind(sConnfd, (SOCKADDR *)&Servaddr, sizeof(Servaddr)))
{
dwError = WSAGetLastError();
printf("bind函数调用错误，错误号: %d\n", dwError);
closesocket(sConnfd); //关闭套接字
WSACleanup(); //释放套接字资源
return -1;
}
for(;;)
{
//接收数据，连接套接字，接收缓冲区，缓冲区长度，正常发送方式，源地址指针，地址大小
if(SOCKET_ERROR==(recvfrom(sConnfd, recvBuf, MAXLINE, 0, (SOCKADDR*)&Cliaddr, &len)))
{
printf("recvfrom函数调用错误，错误号: %d\n", WSAGetLastError());
closesocket(sConnfd); //关闭套接字
WSACleanup(); //释放套接字资源
return -1;
}
sprintf(sendBuf, "echo: %s",recvBuf);
printf("%s\n", sendBuf);
//回射消息
if(SOCKET_ERROR==(sendto(sConnfd, recvBuf, strlen(recvBuf) + 1, 0, (SOCKADDR*)&Cliaddr, len)))
{
printf("sendto函数调用错误，错误号: %d\n", WSAGetLastError());
closesocket(sConnfd); //关闭套接字
WSACleanup(); //释放套接字资源
return -1;
}
}
closesocket(sConnfd);
WSACleanup();
return 0;
}

②客户端

#include <stdio.h>
#include "winsock2.h"
#pragma comment(lib, "ws2_32.lib")
#define SERVER_PORT 4501
#define MAXLINE 1024 //接收缓冲区长度
int main()
{
WSADATA wsd; //WSADATA变量
SOCKET cConnfd;//连接套接字
sockaddr_in Servaddr;//通信地址
char sendBuf[MAXLINE]; //发送缓冲区
char recvBuf[MAXLINE];//接收缓冲区
int len = sizeof(SOCKADDR);
//初始化套结字动态库
if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
{
printf("WSAStartup failed!\n");
return -1;
}
if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2)
{
WSACleanup();
return -1;
}
//创建监听套接字
cConnfd = socket(AF_INET, SOCK_DGRAM, 0);
if (INVALID_SOCKET == cConnfd)
{
printf("socket failed!\n");
WSACleanup();//释放套接字资源;
return -1;
}
memset(&Servaddr, 0, sizeof(Servaddr));
//设置服务器地址
Servaddr.sin_family = AF_INET;
Servaddr.sin_port = htons(SERVER_PORT);
Servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
for(;;)
{
gets_s(sendBuf);
if (sendBuf[0] == 'q')
{
printf("程序退出\n");
return -1;
}
sendto(cConnfd, sendBuf, strlen(sendBuf) + 1, 0,(SOCKADDR*)&Servaddr, len);//发送数据
recvfrom(cConnfd, recvBuf, MAXLINE, 0, (SOCKADDR*)&Servaddr, &len);//接收数据
printf("echo: %s\n", recvBuf);
}
closesocket(cConnfd);
WSACleanup();
return 0;
}

（2）基于数据报套接字的并发服务器回射程序设计

①服务器

#include <stdio.h>
#include <winsock2.h>
#pragma comment(lib, "WS2_32") // 链接到WS2_32.lib
#define SERVER_PORT 4502
#define MAXLINE 1024
int tempPort = SERVER_PORT;//临时端口号
DWORD WINAPI str_echo(LPVOID sd)
{
char recvBuf[MAXLINE];
char szBuf[MAXLINE];
SOCKADDR_IN Cliaddr;
int iClilen = sizeof(SOCKADDR);
int tmp = tempPort;
int retVal = 0;
//在新的套接口上绑定临时端口
SOCKET tempSocket = socket(AF_INET, SOCK_DGRAM, 0);
SOCKADDR_IN Servaddr;
Servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
Servaddr.sin_family = AF_INET;
Servaddr.sin_port = htons(tmp);
//绑定
if (SOCKET_ERROR == bind(tempSocket, (SOCKADDR *)&Servaddr, sizeof(Servaddr)))
{
printf("bind函数调用错误，错误号: %d\n", WSAGetLastError());
closesocket(tempSocket); //关闭套接字
WSACleanup(); //释放套接字资源
return -1;
}
for(;;)
{
retVal = recvfrom(tempSocket, recvBuf, MAXLINE, 0, (SOCKADDR*)&Cliaddr, &iClilen);
if (retVal == SOCKET_ERROR)
{
printf("recvfrom函数调用错误，错误号: %d\n", WSAGetLastError());
closesocket(tempSocket);
WSACleanup();
return -1;
}
sprintf_s(szBuf, "%d echo：%s", ntohs(Servaddr.sin_port),recvBuf);
printf("%s\n", szBuf);
retVal = sendto(tempSocket, szBuf, strlen(szBuf) + 1, 0, (SOCKADDR*)&Cliaddr, iClilen);
if (SOCKET_ERROR == retVal)
{
printf("sendto函数调用错误，错误号: %d\n", WSAGetLastError());
closesocket(tempSocket);
WSACleanup();
return -1;
}
}
closesocket(tempSocket);
return 0;
}
int main()
{
WSADATA wsd; //WSADATA变量
SOCKET sSocket;//监听套接字\连接套接字
sockaddr_in Cliaddr, Servaddr;//通信地址
DWORD dwError = 0;
int iClilen = sizeof(SOCKADDR);//客户端地址长度
char sendBuf[MAXLINE];//发送缓冲区
char recvBuf[MAXLINE];//接收缓冲区
HANDLE hThread = NULL; //新线程
//初始化套结字动态库
if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
{
printf("WSAStartup failed!\n");
return -1;
}
//创建监听套接字
sSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (INVALID_SOCKET == sSocket)
{
printf("socket failed!\n");
WSACleanup();//释放套接字资源;
return -1;
}
memset(&Servaddr, 0, sizeof(Servaddr));
memset(&Cliaddr, 0, sizeof(Cliaddr));
//建立套接字
Servaddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
Servaddr.sin_family = AF_INET;
Servaddr.sin_port = htons(SERVER_PORT);
//绑定监听套接字
if (SOCKET_ERROR == bind(sSocket, (SOCKADDR *)&Servaddr, sizeof(Servaddr)))
{
dwError = WSAGetLastError();
printf("bind函数调用错误，错误号: %d\n", dwError);
closesocket(sSocket); //关闭套接字
WSACleanup(); //释放套接字资源
return -1;
}
for(;;)
{
recvfrom(sSocket, recvBuf, MAXLINE, 0, (SOCKADDR*)&Cliaddr, &iClilen);
++tempPort;//给新客户的临时端口号
sprintf_s(sendBuf, "%d", tempPort);
//将临时端口号发给客户端
sendto(sSocket, sendBuf, sizeof(sendBuf), 0, (SOCKADDR*)&Cliaddr, iClilen);
sprintf_s(sendBuf, "%d echo：%s",tempPort, recvBuf);
printf("%s\n", sendBuf);
sendto(sSocket, sendBuf, sizeof(sendBuf), 0, (SOCKADDR*)&Cliaddr, iClilen);
//利用新的端口号建立新线程
hThread = CreateThread(NULL, 0, str_echo, (LPVOID)sSocket, 0, NULL);
if (hThread == NULL)
{
printf("创建线程失败！\n");
return -1;
}
}
closesocket(sSocket);
WSACleanup();
return 0;
}

②客户端

#include <Winsock2.h>
#include <stdio.h>
#pragma comment(lib,"wsock32.lib")
#define MAXLINE 1024
#define SERVER_PORT 4502
int main()
{
WSADATA wsd; //WSADATA变量
SOCKET cSocket;//连接套接字
sockaddr_in Servaddr;//通信地址
DWORD dwError = 0;
int retVal = 0;
int srvLen = sizeof(SOCKADDR);
char sendBuf[MAXLINE];//发送缓冲区
char recvBuf[MAXLINE];//接收缓冲区
int tempPort = SERVER_PORT;
//初始化套结字动态库
if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
{
printf("WSAStartup failed!\n");
return -1;
}
//创建监听套接字
cSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (INVALID_SOCKET == cSocket)
{
printf("socket failed!\n");
WSACleanup();//释放套接字资源;
return -1;
}
memset(&Servaddr, 0, sizeof(Servaddr));
//设置服务器地址
Servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
Servaddr.sin_family = AF_INET;
Servaddr.sin_port = htons(SERVER_PORT);
gets_s(sendBuf);
// printf("%s",sendBuf);
if (SOCKET_ERROR == sendto(cSocket, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR*)&Servaddr, srvLen))
{
printf("sendto函数调用错误，错误号: %d\n", WSAGetLastError());
closesocket(cSocket);
WSACleanup();
return -1;
}
recvfrom(cSocket, recvBuf, MAXLINE, 0, (SOCKADDR*)&Servaddr, &srvLen);
tempPort = atoi(recvBuf);
//回射
recvfrom(cSocket, recvBuf, MAXLINE, 0, (SOCKADDR*)&Servaddr, &srvLen);
printf("%s\n", recvBuf);
memset(&Servaddr, 0, sizeof(Servaddr));
Servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
Servaddr.sin_family = AF_INET;
Servaddr.sin_port = htons(tempPort);
for(;;)//循环接收数据
{
gets_s(sendBuf);
if (sendBuf[0] == 'q')
{
printf("程序退出\n");
return -1;
}
//发送响应数据
retVal = sendto(cSocket, sendBuf, strlen(sendBuf) + 1, 0,(SOCKADDR*)&Servaddr, srvLen);
if (SOCKET_ERROR == retVal)
{
printf("sendto函数调用错误，错误号: %d\n", WSAGetLastError());
closesocket(cSocket);
WSACleanup();
return -1;
}
//接收请求数据
retVal = recvfrom(cSocket, recvBuf, 100, 0, (SOCKADDR*)&Servaddr, &srvLen);
if (retVal == SOCKET_ERROR)
{
printf("recvfrom函数调用错误，错误号: %d\n", WSAGetLastError());
closesocket(cSocket);
WSACleanup();
return -1;
}
//打印收到的回显字符串
printf("%s\n", recvBuf);
}
closesocket(cSocket);
WSACleanup();
return 0;
}

（3）无连接应用程序丢包率测试

①服务器

#include <stdio.h>
#include "winsock2.h"
#pragma comment(lib, "ws2_32.lib")
#define SERVER_PORT 6888
int main()
{
WSADATA wsd; //WSADATA变量
SOCKET sSocket;//连接套接字
sockaddr_in Servaddr;//通信地址
DWORD dwError = 0;
int retVal = 0;
int srvLen = sizeof(SOCKADDR);
//初始化套结字动态库
if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
{
printf("WSAStartup failed!\n");
return -1;
}
//创建监听套接字
sSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (INVALID_SOCKET == sSocket)
{
printf("socket failed!\n");
WSACleanup();//释放套接字资源;
return -1;
}
memset(&Servaddr, 0, sizeof(Servaddr));
//服务器监听套接字地址
Servaddr.sin_family = AF_INET;
Servaddr.sin_port = htons(SERVER_PORT);
Servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//将IP地址指定为INADDR_ANY，允许套接字向任何分配给本地机器的IP地址发送或接收数据
//绑定监听套接字
if (SOCKET_ERROR == bind(sSocket, (SOCKADDR *)&Servaddr, sizeof(Servaddr)))
{
dwError = WSAGetLastError();
printf("bind 函数调用错误，错误号: %d\n", dwError);
closesocket(sSocket); //关闭套接字
WSACleanup(); //释放套接字资源
return -1;
}
//设置缓冲大小及超时时间
int recvBufLen;
int len = sizeof(recvBufLen);
printf("请设置接收缓冲区大小：");
scanf("%d", &recvBufLen);
if (setsockopt(sSocket, SOL_SOCKET, SO_RCVBUF, (const char *)&recvBufLen, len) < 0)
{
printf("setsockopt error\n");
return -1;
}
if (getsockopt(sSocket, SOL_SOCKET, SO_RCVBUF, (char *)&recvBufLen, &len) < 0)
{
printf("getsockopt error\n");
return -1;
}
//设置套接字的接收超时时间
int nTimeOver;
printf("请设置接收超时时间：");
scanf("%d", &nTimeOver);
if (setsockopt(sSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&nTimeOver, sizeof(nTimeOver)) < 0)
{
printf("setsockopt error\n");
return -1;
}
printf("\n系统接收缓存大小被设置为: %d bytes\n", recvBufLen);
printf("系统接收超时时间被设置为: %d ms\n", nTimeOver);
SOCKADDR_IN addrClient;
int addrlen = sizeof(SOCKADDR);
char recvBuf[10];
memset(recvBuf, 0, 10);
double dropRate;//丢包率
int count = 0;
int udpClientCount;
char cCount[10];
recvfrom(sSocket, cCount, 10, 0, (SOCKADDR *)&addrClient, &addrlen);
udpClientCount = atoi(cCount);
printf("客户端一共发送了%d个数据包\n", udpClientCount);
do {
memset(recvBuf, 0, 10);
Sleep(1000);
//接收数据
retVal = recvfrom(sSocket, recvBuf, 10, 0, (SOCKADDR *)&addrClient, &addrlen);
if (retVal > 0) {
count++;
}
else if (retVal == 0)
{
break;
}
else
{
int err = WSAGetLastError();
printf("recvfrom 函数调用错误，错误号: %d\n", err);
}
} while (retVal > 0);
printf("服务器端总共收到%d个数据报\n", count);
dropRate = 1 - ((double)count) /udpClientCount;
dropRate = dropRate * 100;
printf("丢包率 = %lf\n", dropRate);
closesocket(sSocket);
WSACleanup();
return 0;
}

②客户端

#include <Winsock2.h>
#include <stdio.h>
#pragma comment(lib,"wsock32.lib")
#define SERVER_PORT 6888
int main()
{
WSADATA wsd; //WSADATA变量
SOCKET cSocket;//连接套接字
sockaddr_in Servaddr;//通信地址
DWORD dwError = 0;
int retVal = 0;
int srvLen = sizeof(SOCKADDR);
//初始化套结字动态库
if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
{
printf("WSAStartup failed!\n");
return -1;
}
//创建监听套接字
cSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (INVALID_SOCKET == cSocket)
{
printf("socket failed!\n");
WSACleanup();//释放套接字资源;
return -1;
}
memset(&Servaddr, 0, sizeof(Servaddr));
//设置服务器地址
Servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
Servaddr.sin_family = AF_INET;
Servaddr.sin_port = htons(SERVER_PORT);
char sendBuf[10];
memset(sendBuf, 'h', 9);
sendBuf[9] = 0;
int sCount;
int i = 0;
char sendCount[10];
printf("请设置客户端发送数据包次数：");
scanf("%d", &sCount);
sprintf_s(sendCount, "%d", sCount);
sendto(cSocket, sendCount, sizeof(sendCount), 0, (SOCKADDR*)&Servaddr, sizeof(SOCKADDR));
while (i<sCount)
{
retVal = sendto(cSocket, sendBuf, sizeof(sendBuf), 0, (SOCKADDR*)&Servaddr, sizeof(SOCKADDR));
if (SOCKET_ERROR == retVal)
{
printf("sendto 函数调用错误，错误号： %d\n", WSAGetLastError());
return -1;
}
i++;
}
closesocket(cSocket);
WSACleanup();
return 0;
}

3.用户使用说明（输入 / 输出规定）

（1）基于数据报套接字的循环服务器回射程序设计

输入：在客户端输入要发送的消息或字符’q’，按“回车”键；

输出：客户端显示“echo：”并连接刚刚发送的消息。若输入为“q”，则显示“程序退出！”。

（2）基于数据报套接字的并发服务器回射程序设计

输入：在客户端输入要发送的消息或字符’q’，按“回车”键；

输出：客户端显示“端口号 echo：”并连接刚刚发送的消息。若输入为“q”，则显示“程序退出！”。

（3）无连接应用程序丢包率测试

输入：在客户端输入要发送数据包的数量，按“回车”键；在服务器根据提示依次输入设置的缓冲区大小以及超时时间，按“回车”键。

输出：客户端显示“端口号 echo：”并连接刚刚发送的消息。若输入为“q”，则显示“程序退出！”。

4.运行结果（要求截图）

（1）基于数据报套接字的循环服务器回射程序设计

基于数据报套接字的循环服务器回射程序如图2-3所示。

图2-3 数据库套接字的循环服务器-客户端运行结果截图

a．在客户端输入消息“你好呀”，按“回车”键，服务器显示“echo：你好呀”，同时客户端回射消息“你好呀”；

b．如同a，用户依次发送消息 “hiahia”、“helloWorld”，并回射相应消息；

c．用户最后输入“q”，则显示“程序退出！”，服务器端继续等待新的请求。

（2）基于数据报套接字的并发服务器回射程序设计

基于数据报套接字的并发服务器-客户端运行结果如图2-4所示。

图2-4 并发服务器-客户端运行结果截图

a．首先打开服务器等待请求，接着打开三个客户端，服务器为其创建三个线程；

b．端口号为4503的用户首先与服务器进行通信，发送“你好呀”，按“回车”键，服务器显示“4503 echo：你好呀”，同时客户端回射消息“4503 echo：你好呀”；

c．如同b，不同用户依次发送消息 “hiahia”、“helloWorld”、 “嘻嘻”，并在对应用户窗口回射相应的端口号连接“echo：”连接刚刚发送的消息；

d．其中端口号为4504用户最后输入“q”，则显示“程序退出！”，服务器端则断开与端口号为4504的用户的连接；

e．端口号为4505的用户继续与服务器进行通信，发送“哈哈”，按“回车”键，服务器显示“4505 echo：哈哈”，同时客户端回射消息“4505 echo：哈哈”，服务器与其他用户通信正常。

（3）无连接应用程序丢包率测试

无连接应用程序丢包率测试结果如图2-5所示。

图2-5 无连接应用程序丢包率测试结果截图

a．客户端设置好要发送的数据包个数“10”，按“回车”键，此时数据包放入套接字缓冲区；

b．服务器设置好缓冲区大小，以及系统接收超时时间，按“回车”键；

c．服务器返回客户端发包数，和服务器收包数，并计算出丢包率。

超时时间一定，nTimeOver=1000 ms，服务器接收数据包的速度是1000ms/次，改变缓冲区大小，测得数据如表2-1所示。

表2-1 服务器在接收缓存取不同值时的丢包率

缓冲区大小/bytes	超时时间/ms	客户端发包/个	服务器收包/个	丢包率/%
9	1000	10	1	90
10	1000	10	1	90
20	1000	10	2	80
30	1000	10	3	70
40	1000	10	4	60
50	1000	10	5	50
60	1000	10	6	40
70	1000	10	7	30
80	1000	10	8	20
90	1000	10	9	10
100	1000	10	10	0
110	1000	10	10	0
120	1000	10	10	0

在该实验代码中，客户端一次发送10个10 bytes的包，由于UDP是面向报文，一次交付的，会将一次发送的全部报文放入缓冲区，超出缓冲区的部分报文丢掉，因此在设置10、20、…、100 bytes的套接字缓冲区后，服务器收包个数是1、2、…、10个，根据丢包率计算公式丢包率=1-(服务器收到的报文个数/客户端发送的报文个数)×100%，丢包率依次是90%、80%、…、0%。

对于小于一个数据包大小的缓冲区，比如上表中的9 bytes，同样由于UDP数据处理特点，使服务器可以收到1个数据包的9bytes；对于超过发送报文的全部大小的缓冲区，在服务器接收速度为1000ms/次的条件下，服务器可以把全部包都接收到，丢包率为0%。

//多有不妥，欢迎指正

标签：SOCKADDR,return,Servaddr,计算机网络,printf,服务器,接字,报套
来源： https://www.cnblogs.com/pandazheng/p/13966075.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

实验2 基于数据报套接字的网络程序设计（计算机网络Ⅱ）