哈工大计网实验二

最新推荐文章于 2023-12-11 11:04:28 发布
最新推荐文章于 2023-12-11 11:04:28 发布
阅读量761 收藏 17
点赞数
文章标签： 课程设计 p2p 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63087948/article/details/131335702
版权

SR_client，需要在目录下创建一个test的txt文本。

#include <stdlib.h>
#include <time.h>
#include <WinSock2.h>
#include <WS2tcpip.h>
#include <fstream>
#pragma comment(lib,"ws2_32.lib")
#define SERVER_PORT 12340 // 接收数据的端口号
#define SERVER_IP "127.0.0.1" // 服务器的 IP 地址
#define BUFFER_SIZE 1024 // 缓冲区大小
#define SEQ_SIZE 16 // 序列号个数
#define SWIN_SIZE 8 // 发送窗口大小
#define RWIN_SIZE 8 // 接收窗口大小
#define LOSS_RATE 0.8 // 丢包率0.2=1-0.8
using namespace std;

//代码基本结构与服务器端一致，不在本份代码中做过多注释


char cmdBuffer[50];
char buffer[BUFFER_SIZE];
char cmd[10];
char fileName[40];
char filePath[50];
char file[1024 * 1024];
int len = sizeof(SOCKADDR);
int recvSize;
int Deliver(char* file, int ack);
int Send(ifstream& infile, int seq, SOCKET socket, SOCKADDR* addr);
int MoveSendWindow(int seq);
int Read(ifstream& infile, char* buffer);
struct Cache {
	bool used;
	char buffer[BUFFER_SIZE];
	Cache() {
		used = false;
		ZeroMemory(buffer, sizeof(buffer));
	}
}recvWindow[SEQ_SIZE];
struct DataFrame {
	clock_t start;
	char buffer[BUFFER_SIZE];
	DataFrame() {
		start = 0;
		ZeroMemory(buffer, sizeof(buffer));
	}
}sendWindow[SEQ_SIZE];
int main(int argc, char* argv[]) {
	// 加载套接字库
	WORD wVersionRequested;
	WSADATA wsaData;
	// 版本 2.2
	wVersionRequested = MAKEWORD(2, 2);
	int err = WSAStartup(wVersionRequested, &wsaData);
	if (err != 0) {
		printf("Winsock.dll 加载失败，错误码: %d\n", err);
		return -1;
	}
	if (LOBYTE(wsaData.wVersion) != LOBYTE(wVersionRequested) || HIBYTE(wsaData.wVersion) != HIBYTE(wVersionRequested)) {
		printf("找不到 %d.%d 版本的 Winsock.dll\n", LOBYTE(wVersionRequested), HIBYTE(wVersionRequested));
		WSACleanup();
		return -1;
	}
	else {
		printf("Winsock %d.%d 加载成功\n", LOBYTE(wVersionRequested), HIBYTE(wVersionRequested));
	}
	// 创建客户端套接字
	SOCKET socketClient = socket(AF_INET, SOCK_DGRAM, 0);
	// 设置为非阻塞模式
	int iMode = 1;
	ioctlsocket(socketClient, FIONBIO, (u_long FAR*) & iMode);
	SOCKADDR_IN addrServer;
	inet_pton(AF_INET, SERVER_IP, &addrServer.sin_addr);
	addrServer.sin_family = AF_INET;
	addrServer.sin_port = htons(SERVER_PORT);
	srand((unsigned)time(NULL));
	int status = 0;
	clock_t start;
	clock_t now;
	int seq;
	int ack;
	while (true) {
		gets_s(cmdBuffer, 50);
		sscanf_s(cmdBuffer, "%s%s", cmd, sizeof(cmd) - 1, fileName, sizeof(fileName) - 1);
		if (!strcmp(cmd, "upload")) {
			printf("申请上传文件: %s\n", fileName);
			strcpy_s(filePath, "./");
			strcat_s(filePath, fileName);
			ifstream infile(filePath);
			ack = 1;
			start = clock();
			seq = 0;
			status = 0;
			sendWindow[0].buffer[0] = 10;
			strcpy_s(sendWindow[0].buffer + 1, strlen(cmdBuffer) + 1, cmdBuffer);
			sendWindow[0].start = start - 1000L;
			while (true) {
				recvSize = recvfrom(socketClient, buffer, BUFFER_SIZE, 0, (SOCKADDR*)&addrServer, &len);
				switch (status)
				{
				case 0:
					if (recvSize > 0 && buffer[0] == 100) {
						if (!strcmp(buffer + 1, "OK")) {
							printf("申请通过, 开始上传...\n");
							start = clock();
							status = 1;
							sendWindow[0].start = 0L;
							continue;
						}
						else if (!strcmp(buffer + 1, "NO")) {
							status = -1;
							break;
						}
					}
					now = clock();
					if (now - sendWindow[0].start >= 1000L) {
						sendWindow[0].start = now;
						sendto(socketClient, sendWindow[0].buffer, strlen(sendWindow[0].buffer) + 1, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
					}
					break;
				case 1:
					if ((float)rand() / RAND_MAX > LOSS_RATE && buffer[0] == 101 && recvSize > 0) {
						ack = buffer[1];
						ack--;
						recvSize = 0;
						buffer[0] = 0;
						printf(" ack = %d丢失, 当前起始 seq = %d\n", ack + 1, seq + 1);
						break;
					}
					if (recvSize > 0 && buffer[0] == 101) {
						start = clock();
						ack = buffer[1];
						ack--;
						sendWindow[ack].start = -1L;
						if (ack == seq) {
							seq = MoveSendWindow(seq);
						}
						printf("接收 ack = %d, 当前起始 seq = %d\n", ack + 1, seq + 1);
					}
					if (!Send(infile, seq, socketClient, (SOCKADDR*)&addrServer)) {
						printf("上传完毕...\n");
						status = 2;
						start = clock();
						sendWindow[0].buffer[0] = 10;
						strcpy_s(sendWindow[0].buffer + 1, 7, "Finish");
						sendWindow[0].start = start - 1000L;
						continue;
					}
					break;
				case 2:
					if (recvSize > 0 && buffer[0] == 100) {
						if (!strcmp(buffer + 1, "OK")) {
							buffer[0] = 10;
							strcpy_s(buffer + 1, 3, "OK");
							sendto(socketClient, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
							status = 3;
							break;
						}
					}
					now = clock();
					if (now - sendWindow[0].start >= 1000L) {
						sendWindow[0].start = now;
						sendto(socketClient, sendWindow[0].buffer, strlen(sendWindow[0].buffer) + 1, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
					}
				default:
					break;
				}
				if (status == -1) {
					printf("服务器拒绝请求\n");
					infile.close();
					break;
				}
				if (status == 3) {
					printf("上传成功，结束通信\n");
					infile.close();
					break;
				}
				if (clock() - start >= 5000L) {
					printf("通信超时，结束通信\n");
					infile.close();
					break;
				}
				if (recvSize <= 0) {
					Sleep(200);
				}
			}
		}
		else if (!strcmp(cmd, "download")) {
			printf("申请下载文件 %s\n", fileName);
			strcpy_s(filePath, "./");
			strcat_s(filePath, fileName);
			ofstream outfile(filePath);
			start = clock();
			ack = 1;
			ack = 0;
			status = 0;
			sendWindow[0].buffer[0] = 10;
			strcpy_s(sendWindow[0].buffer + 1, strlen(cmdBuffer) + 1, cmdBuffer);
			sendWindow[0].start = start - 1000L;
			while (true) {
				recvSize = recvfrom(socketClient, buffer, BUFFER_SIZE, 0, (SOCKADDR*)&addrServer, &len);
				switch (status)
				{
				case 0:
					if (recvSize > 0 && buffer[0] == 100) {
						if (!strcmp(buffer + 1, "OK")) {
							printf("申请通过, 准备下载...\n");
							start = clock();
							status = 1;
							sendWindow[0].buffer[0] = 10;
							strcpy_s(sendWindow[0].buffer + 1, 3, "OK");
							sendWindow[0].start = start - 1000L;
							continue;
						}
						else if (!strcmp(buffer + 1, "NO")) {
							status = -1;
							break;
						}
					}
					now = clock();
					if (now - sendWindow[0].start >= 1000L) {
						sendWindow[0].start = now;
						sendto(socketClient, sendWindow[0].buffer, strlen(sendWindow[0].buffer) + 1, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
					}
					break;
				case 1:
					if (recvSize > 0 && (unsigned char)buffer[0] == 200) {
						printf("开始下载...\n");
						start = clock();
						seq = buffer[1];
						printf("接收数据帧 seq = %d, data = %s, 发送ack = %d，起始 ack = %d\n", seq, buffer + 2, seq, seq + 1);
						seq--;
						recvWindow[seq].used = true;
						strcpy_s(recvWindow[seq].buffer, strlen(buffer + 2) + 1, buffer + 2);
						if (ack == seq) {
							ack = Deliver(file, ack);
						}
						status = 2;
						buffer[0] = 11;
						buffer[1] = seq + 1;
						buffer[2] = 0;
						sendto(socketClient, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
						continue;
					}
					now = clock();
					if (now - sendWindow[0].start >= 1000L) {
						sendWindow[0].start = now;
						sendto(socketClient, sendWindow[0].buffer, strlen(sendWindow[0].buffer) + 1, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
					}
					break;
				case 2:
					if ((float)rand() / RAND_MAX > LOSS_RATE && recvSize > 0 && (unsigned char)buffer[0] == 200) {
						recvSize = 0;
						buffer[0] = 0;
						seq = buffer[1];
						int temp = seq - 1 - ack;
						if (temp < 0) {
							temp += SEQ_SIZE;
						}
						start = clock();
						seq--;
						if (temp < RWIN_SIZE) {
							if (!recvWindow[seq].used) {
								recvWindow[seq].used = true;
								strcpy_s(recvWindow[seq].buffer, strlen(buffer + 2) + 1, buffer + 2);
							}
						}
						printf("接收数据帧 seq = %d失败， 起始 ack = %d\n", seq + 1, ack + 1);
						buffer[0] = 11;
						buffer[1] = seq + 1;
						buffer[2] = 0;
						break;
					}
					if (recvSize > 0) {
						if ((unsigned char)buffer[0] == 200) {
							seq = buffer[1];
							int temp = seq - 1 - ack;
							if (temp < 0) {
								temp += SEQ_SIZE;
							}
							start = clock();
							seq--;
							if (temp < RWIN_SIZE) {
								if (!recvWindow[seq].used) {
									recvWindow[seq].used = true;
									strcpy_s(recvWindow[seq].buffer, strlen(buffer + 2) + 1, buffer + 2);
								}
								if (ack == seq) {
									ack = Deliver(file, ack);
								}
							}
							printf("接收数据帧 seq = %d, data = %s, 发送 ack = %d, 起始 ack = %d\n", seq + 1, buffer + 2, seq + 1, ack + 1);
							buffer[0] = 11;
							buffer[1] = seq + 1;
							buffer[2] = 0;
							sendto(socketClient, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
						}
						else if (buffer[0] == 100 && !strcmp(buffer + 1, "Finish")) {
							status = 3;
							outfile.write(file, strlen(file));
							buffer[0] = 10;
							strcpy_s(buffer + 1, 3, "OK");
							sendto(socketClient, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
							continue;
						}
					}
					break;
				default:
					break;
				}
				if (status == -1) {
					printf("服务器拒绝请求\n");
					outfile.close();
					break;
				}
				if (status == 3) {
					printf("下载成功, 结束通信\n");
					outfile.close();
					break;
				}
				if (clock() - start >= 5000L) {
					printf("通信超时, 结束通信\n");
					outfile.close();
					break;
				}
				if (recvSize <= 0) {
					Sleep(20);
				}
			}
		}
		else if (!strcmp(cmd, "quit")) {
			break;
		}
	}
	closesocket(socketClient);
	printf("关闭套接字\n");
	WSACleanup();
	return 0;
}

int Read(ifstream& infile, char* buffer) {
	if (infile.eof()) {
		return 0;
	}
	infile.read(buffer, 3);
	int cnt = infile.gcount();
	buffer[cnt] = 0;
	return cnt;
}

int Deliver(char* file, int ack) {
	while (recvWindow[ack].used) {
		recvWindow[ack].used = false;
		strcat_s(file, strlen(file) + strlen(recvWindow[ack].buffer) + 1, recvWindow[ack].buffer);
		ack++;
		ack %= SEQ_SIZE;
	}
	return ack;
}

int Send(ifstream& infile, int seq, SOCKET socket, SOCKADDR* addr) {
	clock_t now = clock();
	for (int i = 0; i < SWIN_SIZE; i++) {
		int j = (seq + i) % SEQ_SIZE;
		if (sendWindow[j].start == -1L) {
			continue;
		}
		if (sendWindow[j].start == 0L) {
			if (Read(infile, sendWindow[j].buffer + 2)) {
				sendWindow[j].start = now;
				sendWindow[j].buffer[0] = 20;
				sendWindow[j].buffer[1] = j + 1;
			}
			else if (i == 0) {
				return 0;
			}
			else {
				break;
			}
		}
		else if (now - sendWindow[j].start >= 1000L) {
			sendWindow[j].start = now;
		}
		else {
			continue;
		}
		printf("发送数据帧 seq = %d, data = %s\n", j + 1, sendWindow[j].buffer + 2);
		sendto(socket, sendWindow[j].buffer, strlen(sendWindow[j].buffer) + 1, 0, addr, sizeof(SOCKADDR));
	}
	return 1;
}

int MoveSendWindow(int seq) {
	while (sendWindow[seq].start == -1L) {
		sendWindow[seq].start = 0L;
		seq++;
		seq %= SEQ_SIZE;
	}
	return seq;
}

SR_server，在目录下创建一个test1的txt文本

#include <stdlib.h>
#include <time.h>
#include <WinSock2.h>
#include <WS2tcpip.h>
#include <fstream>
#pragma comment(lib,"ws2_32.lib")
#define SERVER_PORT 12340 // 端口号
#define SERVER_IP "0.0.0.0" // IP 地址
#define SEQ_SIZE 16 // 序列号个数
#define SWIN_SIZE 8 // 发送窗口大小
#define RWIN_SIZE 8 // 接收窗口大小
#define BUFFER_SIZE 1024 // 缓冲区大小
#define LOSS_RATE 0.8 //丢包率0.2=1-0.8
using namespace std;
struct recv {
	bool used;
	char buffer[BUFFER_SIZE];
	recv() {
		used = false;
		ZeroMemory(buffer, sizeof(buffer));
	}
}recvWindow[SEQ_SIZE];
struct send {
	clock_t start;//由于使用的是SR，因此每一个窗口位置都需要设置一个计时器
	char buffer[BUFFER_SIZE];
	send() {
		start = 0;
		ZeroMemory(buffer, sizeof(buffer));
	}
}sendWindow[SEQ_SIZE];
char cmdBuffer[50];
char buffer[BUFFER_SIZE];
char cmd[10];
char fileName[40];
char filePath[50];
char file[1024 * 1024];
int len = sizeof(SOCKADDR);
int recvSize;
int Deliver(char* file, int ack);
int Send(ifstream& infile, int seq, SOCKET socket, SOCKADDR* addr);
int MoveSendWindow(int seq);
int Read(ifstream& infile, char* buffer);
//主函数
int main(int argc, char* argv[]) {
	// 加载套接字库
	WORD wVersionRequested;
	WSADATA wsaData;
	// 版本 2.2
	wVersionRequested = MAKEWORD(2, 2);
	int err = WSAStartup(wVersionRequested, &wsaData);
	if (err != 0) {
		printf("Winsock.dll 加载失败，错误码: %d\n", err);
		return -1;
	}
	if (LOBYTE(wsaData.wVersion) != LOBYTE(wVersionRequested) || HIBYTE(wsaData.wVersion) != HIBYTE(wVersionRequested)) {
		printf("找不到 %d.%d 版本的 Winsock.dll\n", LOBYTE(wVersionRequested), HIBYTE(wVersionRequested));
		WSACleanup();
		return -1;
	}
	else {
		printf("Winsock %d.%d 加载成功\n", LOBYTE(wVersionRequested), HIBYTE(wVersionRequested));
	}
	// 创建服务器套接字
	SOCKET socketServer = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	// 设置为非阻塞模式
	int iMode = 1;
	ioctlsocket(socketServer, FIONBIO, (u_long FAR*) & iMode);
	SOCKADDR_IN addrServer;
	inet_pton(AF_INET, SERVER_IP, &addrServer.sin_addr);
	addrServer.sin_family = AF_INET;
	addrServer.sin_port = htons(SERVER_PORT);
	// 绑定端口
	if (err = bind(socketServer, (SOCKADDR*)&addrServer, sizeof(SOCKADDR))) {
		err = GetLastError();
		printf("绑定端口 %d 失败，错误码: % d\n", SERVER_PORT, err);
		WSACleanup();
		return -1;
	}
	else {
		printf("绑定端口 %d 成功", SERVER_PORT);
	}
	SOCKADDR_IN addrClient;
	int status = 0;
	clock_t start;
	clock_t now;
	int seq;
	int ack;
	ofstream outfile;
	ifstream infile;
	//进入接收状态，注意服务器主要处理的任务是接收客户机请求，共有上载和下载两种任务
	while (true) {
		recvSize = recvfrom(socketServer, buffer, BUFFER_SIZE, 0, ((SOCKADDR*)&addrClient), &len);
		switch (status)
		{
		case 0://接收请求
			if (recvSize > 0 && buffer[0] == 10) {
				char addr[100];
				ZeroMemory(addr, sizeof(addr));
				inet_ntop(AF_INET, &addrClient.sin_addr, addr, sizeof(addr));
				sscanf_s(buffer + 1, "%s%s", cmd, sizeof(cmd) - 1, fileName, sizeof(fileName) - 1);
				if (strcmp(cmd, "upload") && strcmp(cmd, "download")) {
					continue;
				}
				strcpy_s(filePath, "./");
				strcat_s(filePath, fileName);
				printf("收到来自客户端 %s 的请求: %s\n", addr, buffer);
				printf("是否同意该请求(Y/N)?");
				gets_s(cmdBuffer, 50);
				if (!strcmp(cmdBuffer, "Y")) {
					buffer[0] = 100;
					strcpy_s(buffer + 1, 3, "OK");
					if (!strcmp(cmd, "upload")) {
						file[0] = 0;
						start = clock();
						ack = 0;
						status = 1;
						outfile.open(filePath);
					}
					else if (!strcmp(cmd, "download")) {
						start = clock();
						seq = 0;
						status = -1;
						infile.open(filePath);
					}
				}
				else {
					buffer[0] = 100;
					strcpy_s(buffer + 1, 3, "NO");
				}
				sendto(socketServer, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR));
			}
			break;
		case 1://客户机请求上传，也就是服务器端是接收方
			if ((float)rand() / RAND_MAX > LOSS_RATE && recvSize > 0 && buffer[0] == 20) {
				seq = buffer[1];
				int temp = seq - 1 - ack;
				if (temp < 0) {
					temp += SEQ_SIZE;
				}
				seq--;
				if (temp < RWIN_SIZE) {
					if (!recvWindow[seq].used) {
						recvWindow[seq].used = true;
						strcpy_s(recvWindow[seq].buffer, strlen(buffer + 2) + 1, buffer + 2);
					}
				}
				recvSize = 0;
				buffer[0] = 0;
				printf("数据帧 seq = %d丢失, 起始 ack = %d\n", seq + 1, ack + 1);
				buffer[0] = 101;
				buffer[1] = seq + 1;
				buffer[2] = 0;
				break;
			}
			if (recvSize > 0) {
				if (buffer[0] == 20) {
					seq = buffer[1];
					int temp = seq - 1 - ack;
					if (temp < 0) {
						temp += SEQ_SIZE;
					}
					start = clock();
					seq--;
					if (temp < RWIN_SIZE) {
						if (!recvWindow[seq].used) {
							recvWindow[seq].used = true;
							strcpy_s(recvWindow[seq].buffer, strlen(buffer + 2) + 1, buffer + 2);
						}
						if (ack == seq) {
							ack = Deliver(file, ack);
						}
					}
					printf("接收数据帧 seq = %d, data = %s, 发送 ack = %d, 起始 ack = %d\n", seq + 1, buffer + 2, seq + 1, ack + 1);
					buffer[0] = 101;
					buffer[1] = seq + 1;
					buffer[2] = 0;
					sendto(socketServer, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR));
				}
				else if (buffer[0] == 10) {
					if (!strcmp(buffer + 1, "Finish")) {
						printf("传输完毕...\n");
						start = clock();
						sendWindow[0].start = start - 1000L;
						sendWindow[0].buffer[0] = 100;
						strcpy_s(sendWindow[0].buffer + 1, 3, "OK");
						outfile.write(file, strlen(file));
						status = 2;
					}
					buffer[0] = 100;
					strcpy_s(buffer + 1, 3, "OK");
					sendto(socketServer, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR));
				}
			}
			break;
		case 2://接收完成
			if (recvSize > 0 && buffer[0] == 10 && !strcmp(buffer + 1, "OK")) {
				printf("传输成功，结束通信\n");
				status = 0;
				outfile.close();
			}
			now = clock();
			if (now - sendWindow[0].start >= 1000L) {
				sendWindow[0].start = now;
				sendto(socketServer, sendWindow[0].buffer, strlen(sendWindow[0].buffer) + 1, 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR));
			}
			break;
		case -1://客户机请求下载，也就是服务器端充当发送方
			if (recvSize > 0) {
				if (buffer[0] == 10) {
					if (!strcmp(buffer + 1, "OK")) {
						printf("开始传输...\n");
						start = clock();
						status = -2;
					}
					buffer[0] = 100;
					strcpy_s(buffer + 1, 3, "OK");
					sendto(socketServer, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR));
				}
			}
			break;
		case -2://服务器端发送数据
			if ((float)rand() / RAND_MAX > LOSS_RATE && recvSize > 0 && buffer[0] == 11) {
				ack = buffer[1];
				ack--;
				recvSize = 0;
				buffer[0] = 0;
				printf(" ack = %d丢失, 当前起始 seq = %d\n", ack + 1, seq + 1);
				break;
			}
			if (recvSize > 0 && buffer[0] == 11) {
				start = clock();
				ack = buffer[1];
				ack--;
				sendWindow[ack].start = -1L;
				if (ack == seq) {
					seq = MoveSendWindow(seq);
				}
				printf("接收 ack = %d, 当前起始 seq = %d\n", ack + 1, seq + 1);
			}
			if (!Send(infile, seq, socketServer, (SOCKADDR*)&addrClient)) {
				printf("传输完毕...\n");
				status = -3;
				start = clock();
				sendWindow[0].buffer[0] = 100;
				strcpy_s(sendWindow[0].buffer + 1, 7, "Finish");
				sendWindow[0].start = start - 1000L;
			}
			break;
		case -3://请求完成
			if (recvSize > 0 && buffer[0] == 10) {
				if (!strcmp(buffer + 1, "OK")) {
					printf("传输成功，结束通信\n");
					infile.close();
					status = 0;
					break;
				}
			}
			now = clock();
			if (now - sendWindow[0].start >= 1000L) {
				sendWindow[0].start = now;
				sendto(socketServer, sendWindow[0].buffer, strlen(sendWindow[0].buffer) + 1, 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR));
			}
		default:
			break;
		}
		if (status != 0 && clock() - start > 5000L) {
			printf("通信超时, 结束通信\n");
			status = 0;
			outfile.close();
			continue;
		}
		if (recvSize <= 0) {
			Sleep(20);
		}
	}
	//关闭套接字，卸载库
	closesocket(socketServer);
	WSACleanup();
	return 0;
}
int Read(ifstream& infile, char* buffer) {
	//从文件中读取需要发送的数据
	if (infile.eof()) {
		return 0;
	}
	infile.read(buffer, 3);
	int cnt = infile.gcount();
	buffer[cnt] = 0;
	return cnt;
}
int Deliver(char* file, int ack) {
	while (recvWindow[ack].used) {
		recvWindow[ack].used = false;
		strcat_s(file, strlen(file) + strlen(recvWindow[ack].buffer) + 1, recvWindow[ack].buffer);
		ack++;
		ack %= SEQ_SIZE;
	}
	return ack;
}
int Send(ifstream& infile, int seq, SOCKET socket, SOCKADDR* addr) {
	//发送数据
	clock_t now = clock();
	for (int i = 0; i < SWIN_SIZE; i++) {
		int j = (seq + i) % SEQ_SIZE;
		if (sendWindow[j].start == -1L) {//传输超时，不需要
			continue;
		}
		if (sendWindow[j].start == 0L) {//开始计时
			if (Read(infile, sendWindow[j].buffer + 2)) {
				sendWindow[j].start = now;
				sendWindow[j].buffer[0] = 200;
				sendWindow[j].buffer[1] = j + 1;
			}
			else if (i == 0) {
				return 0;
			}
			else {
				break;
			}
		}
		else if (now - sendWindow[j].start >= 1000L) {//更新时间
			sendWindow[j].start = now;
		}
		else {
			continue;
		}
		printf("发送数据帧 seq = %d, data = %s\n", j + 1, sendWindow[j].buffer + 2);
		sendto(socket, sendWindow[j].buffer, strlen(sendWindow[j].buffer) + 1, 0, addr, sizeof(SOCKADDR));
	}
	return 1;
}

int MoveSendWindow(int seq) {
	//移动窗口
	while (sendWindow[seq].start == -1L) {
		sendWindow[seq].start = 0L;
		seq++;
		seq %= SEQ_SIZE;
	}
	return seq;
}

圣灵魔闪光
关注
  • 0
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
哈工大计算机网络实验二的代码
10-29
哈工大计算机网络实验二的代码
哈工大计算机网络2018实验二（报告丢失）
01-20
这一次的实验报告被我弄丢了 实在是抱歉了学弟学妹们 ，代码可以使用，但是没有报告，如果学弟学妹们需要报告请不要下载！
哈工大计网实验一
qq_63087948的博客
06-22 1314
鼠鼠我呀，做实验的时候的虽然也是找源码，但是这个🐎是这个报错，那个不对，这改改那看看，所以鼠鼠我直接把我调试好的代码直接发出来。
哈工大计算机网络实验三——利用 Wireshark 进行协议分析
最新发布
m0_62249876的博客
12-11 1803
在显示筛选规则中输入“tcp”,可以看到在本地主机和服务器之间传输的一系列tcp和http报文，你应该能看到包含SYN报文的三次握手。也可以看到有主机向服务器发送的一个HTTP POST报文和一系列的“http continuation”报文。启动Web浏览器和Wireshark，选择“capture”下拉菜单中的“Capture Options”命令，设置分组俘获的选项后，开始分组捕获。
哈工大计算机网络实验1 Java实现
Lockede的博客
04-08 788
最后的最后说一下我没有解决的问题，就是有的工大网站我确实访问不进去，好像其他同学用C写的是可以进去的，比如今日哈工大和哈工大官网，我也不知道是什么原因，验收的时候灵活选择了一下演示的网页，助教也不会特意让我访问别的网站。然后就是最主要的部分了，用于实现缓存以及报文的转发和响应。之后就要获得服务器的响应了，如果没更新会返回一个304，有更新的话就是正常的200，所以可以接收比较小的一部分报文，判断里面含不含304，如果含的话就直接把缓存发给浏览器就好了，要是不含的话还得把服务器的响应读完，更新缓存并转发。
哈工大计算机网络实验四——简单网络组建及配置
m0_62249876的博客
11-07 3688
在完成一个简单校园网的基本建设、配置工作，完成终端设备参数配置、各层设备配置、路由表配置和VLAN配置，使校园网各区域能够完成通信。宿舍区与办公区、教学区隔离，即宿舍区的设备只能访问服务器区的资源；其他区域的设备可以互相访问。配置无线局域网，包括无线路由和笔记本的设置。在不考虑冗余链路的前提下，可将网络拓扑结构简化如下。同时，为了管理方便，以及提高网络的高性能，减少不必要的流量消耗，还应该根据需求设计IP地址分配方案，用户需求如下：中心机房（即服务器区），需要分配至少20个。
哈工大计算机网络测试二
cobracanary的博客
11-25 1572
测试二的试题总体来说质量还是比较高的，来分析一下测试二里面每一题的解答： 考察GBN协议窗口的大小，不难。当数据帧序列号为n比特时，GBN协议的窗口大小是2n−12^n-12n−1，而SR协议的窗口大小是2n−12^{n-1}2n−1 停等协议的信道利用速率是 传输时间/传输时间+RTT SYN=1,Y=1000+1=1001，ack=1000+100+1=1001(下一个想要收到的...
哈工大计算机网络实验一-HTTP代理服务器的设计与实现
qq_53191991的博客
10-14 2555
HTTP协议实现java
哈工大威海计网实验.zip
03-12
哈工大威海计网实验17级，刘扬老师版，自己做的，希望能给下载的同学一点帮助与指导。
哈工大计科数据库实验四
07-03
【哈工大计科数据库实验四】是一个针对哈尔滨工业大学计算机科学专业学生的实验项目，主要目的是让学生深入了解数据库的物理实现层面。在这个实验中，学生将有机会亲手模拟数据库的底层存储和管理机制，以此来增强对...
HIT-Computer-Network:哈工大计算机网络实验
05-11
HIT-Computer-Network 2018哈工大计算机网络实验
哈工大计算机网络2018实验一及报告
01-20
哈尔滨工业大学16级的计算机网络实验一 截止到2019年初这是最新的版本！！ 实验及报告清晰明了 （已经过TA验收）可以直接上交
哈工大计算机网络实验一
12-04
哈工大计算机网络实验一，TCP套接字的服务器跟客户端
哈工大计算机网络2018实验四及报告
01-20
哈尔滨工业大学16级的计算机网络实验一 截止到2019年初这是最新的版本！！ 实验报告清晰明了 （已经过TA验收）可以直接上交 这一次实验是使用wireshark 所以只有报告就可以了，没有代码
哈工大计科数据库实验三源码
07-03
【哈工大计科数据库实验三源码】是哈尔滨工业大学计算机科学专业的一项实验任务，旨在让学生深入理解并实践数据库查询技术。在这个实验中，学生被要求设计和实现一个类似于QQ的交流工具，以此来锻炼他们对数据库操作...
哈工大计算机网络实验一：HTTP代理服务器（Java语言实现）
m0_61108725的博客
10-07 1930
否则可以直接将缓存中的数据返回。循环体中，我们对请求报文做一些解析用来提取一些必要的信息，然后建立与目标服务器的连接后，监听浏览器到服务器的数据传送，同时监听服务器到浏览器的数据传送。在Java中socket网络编程，慕课里也讲过，socket是点对点的，代理服务器程序在一次循环中，分别与浏览器客户端，目标服务器维持一个socket连接，那么数据流就可以在这条通路上传输。事实上，我们在浏览器地址栏上输入我们想访问的网址，到浏览器展示给我们丰富的页面，即使我们只访问一次，浏览器还是会发送许许多多的请求。
哈工大计算机网络实验四——简单网络组建配置 Cisco Packet Tracer 使用指南
热门推荐
qq_28383747的博客
04-23 1万+
做实验四时，本来希望能够借助实验指导书上的内容速通，但尝试了一个上午后发现行不通发现遍地都是bug，于是便花了半天的时间认真学习了一下其中的运行机制，晚上又把所有的switch全都重写了一遍，最后终于成功。这篇博客详细介绍了该实验中使用Cisco Packet Tracer组建校园网的过程以及注意事项，希望能够帮助到大家。本人才疏学浅 ，对Cisco Packet Tracer的使用亦只有一天的经验，内容难免会有纰漏。文章内容仅供参考，如有不当之处希望大家多多指正。
哈工大2022秋计算机网络实验4
砥砺前行，持之以恒
10-30 696
计算机网络实验4
哈工大计算机网络实验二——可靠数据传输协议的设计与实现
m0_62249876的博客
12-11 2130
如果输入为“-testgbn_recv [X][Y]”，则进入等待握手阶段（客户端处于0状态），当收到来自服务器的205状态码后，向服务器发送200状态码，同时初始化已收到的序列号recvSeq为0和等待收到的序列号waitSeq为1，进入等待传输阶段（1状态）当客户端开始请求数据，即服务器端接收到“-testgbn”报文的话，就会进入握手阶段，建立连接状态后（并不是真正的连接，只是一种类似连接的数据发送的状态），将数据打包成数据报文发送，然后等待客户端的ACK信息，同时启动计时器。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值