C/C++网络编程--文件分块传输

2024-09-01 19:04
文章标签 c++ 编程 网络 传输 分块

本文主要是介绍C/C++网络编程--文件分块传输，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文件分块传输是网络编程中一个常见的任务，尤其是在处理大文件时，将文件分块可以提高传输效率，简化错误处理，并可以实现并发传输。下面，写个从客户端向服务器发送大型数据的demo。

客户端

客户端有两点需要注意，在传输分两个一个是文件总块数和文件块，。传输文件总块数让服务器知道有多少文件块需要接收，确保所有数据都被完整地发送到服务器，避免因文件块数不对导致文件重组失败。

传输文件总块数

int sendAll(SOCKET s, const char* buf, int len, int flags) {int total = 0;int bytesLeft = len;int n;while (total < len) {n = send(s, buf + total, bytesLeft, flags);if (n == SOCKET_ERROR) {return SOCKET_ERROR;}total += n;bytesLeft -= n;}return total;
}

传输文件块

int sendFileBlock(SOCKET clientSocket, FileBlock* block) {int retry_count = 0;while (retry_count < MAX_RETRY_COUNT) {if (sendAll(clientSocket, (char*)&block->id, sizeof(block->id), 0) == SOCKET_ERROR ||sendAll(clientSocket, (char*)&block->size, sizeof(block->size), 0) == SOCKET_ERROR ||sendAll(clientSocket, block->data, block->size, 0) == SOCKET_ERROR ||sendAll(clientSocket, (char*)&block->crc32, sizeof(block->crc32), 0) == SOCKET_ERROR) {printf("发送块 %lld 失败，重试中...\n", block->id);retry_count++;Sleep(1000);  // 等待1秒后重试} else {return 1;  // 成功发送}}printf("发送块 %lld 失败，已达到最大重试次数\n", block->id);return 0;
}

服务器端

在服务器接收文件块时得做两件事：文件块接收和文件重组。

文件块接收

文件块接收牵扯到是否接收正确的判断，这里可以采用CRC32校验和判断服务器是否有接收正确文件块：

uint32_t calculateCRC32(const char* data, int32_t size) {uint32_t crc = 0xFFFFFFFF;for (int i = 0; i < size; i++) {crc ^= data[i];for (int j = 0; j < 8; j++) {crc = (crc >> 1) ^ (0xEDB88320 & -(crc & 1));}}return ~crc;
}

稍微解释一下，第一个for遍历全部字节，第二个for是得到每一位的crc值，crc = (crc >> 1) ^ (0xEDB88320 & -(crc & 1));，其中0xEDB88320是多项式常数，客户端和服务器应该一致。这个表达式将CRC值右移一位，如果CRC值的最低位是1，则将CRC值与0xEDB88320进行异或操作。

文件重组

文件重组还是比较简单的，首先在服务器目录下建立一个新的文件，遍历每个文件块fwrite写入创建好的文件，但是这里一定要记住在整个客户端和服务器端建立连接通信过程，一定要记得释放缓冲区内存！！！

void reassembleFile(const char* filename) {FILE* file = fopen(filename, "wb"); // 以二进制写模式打开文件if (file == NULL) {perror("无法创建输出文件");return;}// 写入文件for (int i = 0; i < totalBlocksExpected; i++) {fwrite(receivedBlocks[i].data, 1, receivedBlocks[i].size, file);free(receivedBlocks[i].data); // 释放内存}fclose(file); // 关闭文件printf("文件已重组并保存为 %s\n", filename);
}

最后，讲下服务器处理客户端发送的文件，首先接收客户端发来的文件总块数，先开辟相应大小的缓存数组：receivedBlocks = (FileBlock*)malloc(sizeof(FileBlock) * totalBlocksExpected);这里值得一提FileBlock结构体，它是由块ID，data，size，crc32值组成。然后，将接收文件数据放入缓冲数组

 block.data = (char*)malloc(block.size);int totalReceived = 0;while (totalReceived < block.size) {bytesReceived = recv(clientSocket, buffer, (BUFFER_SIZE<block.size - totalReceived?BUFFER_SIZE:block.size - totalReceived), 0);if (bytesReceived <= 0) {free(block.data);goto cleanup;}memcpy(block.data + totalReceived, buffer, bytesReceived);totalReceived += bytesReceived;}

最后验证CRC是否正确，将接收到的块重组成文件。

代码汇总

客户端代码

#include "p2p_common.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>#pragma comment(lib, "ws2_32.lib")
#pragma execution_character_set("utf-8")
#define BUFFER_SIZE 1024
#define MAX_RETRY_COUNT 5void setConsoleCodePage() {SetConsoleOutputCP(65001);SetConsoleCP(65001);
}uint32_t calculateCRC32(const char* data, int32_t size) {uint32_t crc = 0xFFFFFFFF;for (int i = 0; i < size; i++) {crc ^= data[i];for (int j = 0; j < 8; j++) {crc = (crc >> 1) ^ (0xEDB88320 & -(crc & 1));}}return ~crc;
}
//传输总块数
int sendAll(SOCKET s, const char* buf, int len, int flags) {int total = 0;int bytesLeft = len;int n;while (total < len) {n = send(s, buf + total, bytesLeft, flags);if (n == SOCKET_ERROR) {return SOCKET_ERROR;}total += n;bytesLeft -= n;}return total;
}int sendFileBlock(SOCKET clientSocket, FileBlock* block) {int retry_count = 0;while (retry_count < MAX_RETRY_COUNT) {if (sendAll(clientSocket, (char*)&block->id, sizeof(block->id), 0) == SOCKET_ERROR ||sendAll(clientSocket, (char*)&block->size, sizeof(block->size), 0) == SOCKET_ERROR ||sendAll(clientSocket, block->data, block->size, 0) == SOCKET_ERROR ||sendAll(clientSocket, (char*)&block->crc32, sizeof(block->crc32), 0) == SOCKET_ERROR) {printf("发送块 %lld 失败，重试中...\n", block->id);retry_count++;Sleep(1000);  // 等待1秒后重试} else {return 1;  // 成功发送}}printf("发送块 %lld 失败，已达到最大重试次数\n", block->id);return 0;
}void displayProgress(int64_t current, int64_t total) {const int barWidth = 50;float progress = (float)current / total;int pos = barWidth * progress;printf("\r[");for (int i = 0; i < barWidth; ++i) {if (i < pos) printf("=");else if (i == pos) printf(">");else printf(" ");}printf("] %d%%", (int)(progress * 100.0));fflush(stdout);
}
int main() {setConsoleCodePage();WSADATA wsaData;SOCKET clientSocket;struct sockaddr_in serverAddr;char filename[BUFFER_SIZE];if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {printf("WSAStartup 失败！\n");return -1;}printf("请输入要上传的文件名: ");scanf("%s", filename);getchar(); // 清除输入缓冲FILE *fp = fopen(filename, "rb");if (fp == NULL) {perror("无法打开文件");WSACleanup();return -1;}// 获取文件大小,fseek(fp, 0, SEEK_END);long fileSize = ftell(fp);fseek(fp, 0, SEEK_SET);//向上取整int totalBlocks = (fileSize + BLOCK_SIZE - 1) / BLOCK_SIZE;clientSocket = socket(AF_INET, SOCK_STREAM, 0);if (clientSocket == INVALID_SOCKET) {printf("套接字创建失败！\n");fclose(fp);WSACleanup();return -1;}serverAddr.sin_family = AF_INET;serverAddr.sin_port = htons(PORT);serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");if (connect(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {printf("连接失败！\n");closesocket(clientSocket);fclose(fp);WSACleanup();return -1;}printf("已连接到服务器。\n");if (sendAll(clientSocket, (char*)&totalBlocks, sizeof(totalBlocks), 0) == SOCKET_ERROR) {printf("发送总块数失败\n");closesocket(clientSocket);fclose(fp);WSACleanup();return -1;}FileBlock block;for (int64_t i = 0; i < totalBlocks; i++) {block.id = i;block.size = (i == totalBlocks - 1) ? (fileSize % BLOCK_SIZE) : BLOCK_SIZE;if (block.size == 0) block.size = BLOCK_SIZE;block.data = (char*)malloc(block.size);fread(block.data, 1, block.size, fp);block.crc32 = calculateCRC32(block.data, block.size);if (!sendFileBlock(clientSocket, &block)) {printf("\n发送块 %lld 失败，传输中断\n", block.id);free(block.data);closesocket(clientSocket);fclose(fp);WSACleanup();return -1;}displayProgress(i + 1, totalBlocks);free(block.data);}printf("\n文件传输完成。\n");// 等待服务器确认char confirmation[BUFFER_SIZE];int received = recv(clientSocket, confirmation, BUFFER_SIZE, 0);if (received > 0) {confirmation[received] = '\0';printf("服务器响应: %s\n", confirmation);} else {printf("未收到服务器确认\n");}fclose(fp);closesocket(clientSocket);WSACleanup();printf("上传成功。按任意键退出...\n");getchar();return 0;
}

服务器端代码

#include "p2p_common.h" 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <windows.h> 
#include <winsock2.h> // Windows套接字库
#include <ws2tcpip.h> // TCP/IP协议相关库
#include <process.h> #pragma comment(lib, "ws2_32.lib") // 链接ws2_32库
#pragma execution_character_set("utf-8") // 设置执行字符集为UTF-8
#define MAX_BLOCKS 1000000 // 定义最大块数
#define BUFFER_SIZE 1024 // 定义缓冲区大小FileBlock* receivedBlocks = NULL; // 接收到的文件块数组
int blockCount = 0; // 已接收的块数
CRITICAL_SECTION blockMutex; // 用于线程同步的临界区
int serverRunning = 1; // 服务器运行状态标志
int totalBlocksExpected = 0; // 预期接收的总块数// 设置控制台代码页为UTF-8
void setConsoleCodePage() {SetConsoleOutputCP(65001); // 设置输出代码页为UTF-8SetConsoleCP(65001); // 设置输入代码页为UTF-8
}// CRC32校验和计算函数
uint32_t calculateCRC32(const char* data, int32_t size) {uint32_t crc = 0xFFFFFFFF;for (int i = 0; i < size; i++) {crc ^= data[i];for (int j = 0; j < 8; j++) {crc = (crc >> 1) ^ (0xEDB88320 & -(crc & 1));}}return ~crc;
}
// 文件重组函数
void reassembleFile(const char* filename) {FILE* file = fopen(filename, "wb"); // 以二进制写模式打开文件if (file == NULL) {perror("无法创建输出文件");return;}// 写入文件for (int i = 0; i < totalBlocksExpected; i++) {fwrite(receivedBlocks[i].data, 1, receivedBlocks[i].size, file);//fwrite(const void *ptr, size_t size, size_t count, FILE *stream);free(receivedBlocks[i].data); // 释放内存}fclose(file); // 关闭文件printf("文件已重组并保存为 %s\n", filename);
}// 处理客户端连接的线程函数
unsigned __stdcall handleClient(void* arg) {SOCKET clientSocket = *(SOCKET*)arg; // 客户端套接字FileBlock block;char buffer[BUFFER_SIZE];int bytesReceived;// 接收总块数针对服务器的预期if (totalBlocksExpected == 0) {//开始接收文件块之前，服务器需要知道总共有多少个文件块需要接收if (recv(clientSocket, (char*)&totalBlocksExpected, sizeof(totalBlocksExpected), 0) <= 0) {printf("接收总块数失败\n");closesocket(clientSocket);return 0;}printf("预期接收总块数：%d\n", totalBlocksExpected);receivedBlocks = (FileBlock*)malloc(sizeof(FileBlock) * totalBlocksExpected);if (receivedBlocks == NULL) {printf("内存分配失败\n");closesocket(clientSocket);return 0;}}while (1) {// 接收块IDif (recv(clientSocket, (char*)&block.id, sizeof(block.id), 0) <= 0) {break;}// 接收数据大小if (recv(clientSocket, (char*)&block.size, sizeof(block.size), 0) <= 0) {break;}// 分配内存并接收数据block.data = (char*)malloc(block.size);int totalReceived = 0;while (totalReceived < block.size) {bytesReceived = recv(clientSocket, buffer, (BUFFER_SIZE<block.size - totalReceived?BUFFER_SIZE:block.size - totalReceived), 0);if (bytesReceived <= 0) {free(block.data);goto cleanup;}memcpy(block.data + totalReceived, buffer, bytesReceived);totalReceived += bytesReceived;}// 接收CRC32校验和if (recv(clientSocket, (char*)&block.crc32, sizeof(block.crc32), 0) <= 0) {free(block.data);break;}// 验证CRC32校验和uint32_t calculatedCRC32 = calculateCRC32(block.data, block.size);if (calculatedCRC32 != block.crc32) {printf("块 %lld 的CRC32校验和不匹配\n", block.id);free(block.data);continue;}// 将块添加到接收列表EnterCriticalSection(&blockMutex);if (block.id < totalBlocksExpected) {receivedBlocks[block.id] = block;blockCount++;printf("接收到块 %lld，大小：%d 字节（%d/%d）\n", block.id, block.size, blockCount, totalBlocksExpected);if (blockCount == totalBlocksExpected) {printf("已接收所有块，准备重组文件...\n");reassembleFile("demo.mp4");serverRunning = 0;send(clientSocket, "File received successfully", 27, 0);}} else {printf("收到无效的块ID: %lld\n", block.id);free(block.data);}LeaveCriticalSection(&blockMutex);}cleanup:closesocket(clientSocket);return 0;
}// 服务器线程函数
unsigned __stdcall serverThread(void* arg) {SOCKET serverSocket = socket(AF_INET, SOCK_STREAM, 0); // 创建服务器套接字if (serverSocket == INVALID_SOCKET) {perror("无法创建套接字");return 1;}struct sockaddr_in serverAddr;serverAddr.sin_family = AF_INET;serverAddr.sin_port = htons(PORT);serverAddr.sin_addr.s_addr = INADDR_ANY;if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {perror("绑定套接字失败");closesocket(serverSocket);return 1;}if (listen(serverSocket, 5) == SOCKET_ERROR) {perror("监听失败");closesocket(serverSocket);return 1;}printf("服务器正在监听端口 %d\n", PORT);while (serverRunning) {struct sockaddr_in clientAddr;int clientAddrLen = sizeof(clientAddr);SOCKET clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &clientAddrLen);if (clientSocket == INVALID_SOCKET) {if (serverRunning) {perror("接受连接失败");}continue;}unsigned threadId;HANDLE threadHandle = (HANDLE)_beginthreadex(NULL, 0, handleClient, &clientSocket, 0, &threadId);if (threadHandle == NULL) {perror("创建线程失败");closesocket(clientSocket);} else {CloseHandle(threadHandle);}}closesocket(serverSocket);return 0;
}// 主函数
int main() {setConsoleCodePage(); // 设置控制台代码页WSADATA wsaData;if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {perror("WSAStartup 失败");return 1;}InitializeCriticalSection(&blockMutex); // 初始化临界区unsigned threadId;HANDLE serverThreadHandle = (HANDLE)_beginthreadex(NULL, 0, serverThread, NULL, 0, &threadId);if (serverThreadHandle == NULL) {perror("创建服务器线程失败");DeleteCriticalSection(&blockMutex);WSACleanup();return 1;}printf("服务器已启动。等待接收文件块...\n");WaitForSingleObject(serverThreadHandle, INFINITE); // 等待服务器线程结束CloseHandle(serverThreadHandle);DeleteCriticalSection(&blockMutex); // 删除临界区if (receivedBlocks) {free(receivedBlocks); // 释放内存}WSACleanup(); // 清理Winsock库printf("程序已完成。按回车键退出...\n");getchar();return 0;
}

效果展示

请添加图片描述

这篇关于C/C++网络编程--文件分块传输的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1127785。

相关文章

C++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
C++中悬垂引用(Dangling Reference) 的实现

C++中悬垂引用(Dangling Reference) 的实现

《C++中悬垂引用(DanglingReference)的实现》C++中的悬垂引用指引用绑定的对象被销毁后引用仍存在的情况,会导致访问无效内存,下面就来详细的介绍一下产生的原因以及如何避免,感兴趣... 目录悬垂引用的产生原因1. 引用绑定到局部变量，变量超出作用域后销毁2. 引用绑定到动态分配的对象，对象
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
Ubuntu向多台主机批量传输文件的流程步骤

Ubuntu向多台主机批量传输文件的流程步骤

《Ubuntu向多台主机批量传输文件的流程步骤》：本文主要介绍在Ubuntu中批量传输文件到多台主机的方法,需确保主机互通、用户名密码统一及端口开放,通过安装sshpass工具,准备包含目标主机信... 目录Ubuntu 向多台主机批量传输文件1.安装 sshpass2.准备主机列表文件3.创建一个批处理脚
阅读更多...
C++读写word文档(.docx)DuckX库的使用详解

C++读写word文档(.docx)DuckX库的使用详解

《C++读写word文档(.docx)DuckX库的使用详解》DuckX是C++库,用于创建/编辑.docx文件,支持读取文档、添加段落/片段、编辑表格,解决中文乱码需更改编码方案,进阶功能含文本替换... 目录一、基本用法1. 读取文档3. 添加段落4. 添加片段3. 编辑表格二、进阶用法1. 文本替换2
阅读更多...
C++中处理文本数据char与string的终极对比指南

C++中处理文本数据char与string的终极对比指南

《C++中处理文本数据char与string的终极对比指南》在C++编程中char和string是两种用于处理字符数据的类型,但它们在使用方式和功能上有显著的不同,：本文主要介绍C++中处理文本数... 目录1. 基本定义与本质2. 内存管理3. 操作与功能4. 性能特点5. 使用场景6. 相互转换核心区别
阅读更多...
Python实现简单封装网络请求的示例详解

Python实现简单封装网络请求的示例详解

《Python实现简单封装网络请求的示例详解》这篇文章主要为大家详细介绍了Python实现简单封装网络请求的相关知识,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录安装依赖核心功能说明1. 类与方法概览2.NetHelper类初始化参数3.ApiResponse类属性与方法使用实
阅读更多...
C++右移运算符的一个小坑及解决

C++右移运算符的一个小坑及解决

《C++右移运算符的一个小坑及解决》文章指出右移运算符处理负数时左侧补1导致死循环,与除法行为不同,强调需注意补码机制以正确统计二进制1的个数... 目录我遇到了这么一个www.chinasem.cn函数由此可以看到也很好理解总结我遇到了这么一个函数template<typename T>unsigned
阅读更多...
MySQL的JDBC编程详解

MySQL的JDBC编程详解

《MySQL的JDBC编程详解》：本文主要介绍MySQL的JDBC编程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录前言一、前置知识1. 引入依赖2. 认识 url二、JDBC 操作流程1. JDBC 的写操作2. JDBC 的读操作总结前言本文介绍了mysq
阅读更多...
C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2