使用C++的Socket实现从客户端到服务端，服务端到客户端传输文件

已于 2022-02-07 19:27:00 修改
阅读量1.7k 收藏 14
点赞数 3
分类专栏： 学习中的一点总结 文章标签： 算法 数据结构
于 2021-07-27 11:38:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Keep_Trying_Go/article/details/119136449
版权

使用：
（1）首先运行服务端，待服务端运行起来；
（2）最后运行客户端，输入要传输文件到哪个目标机器的IP地址；
（3）输入传输文件的路径及文件（完成的路径），其中包含文件的类型，也就是后缀需要包含（代表需要传输文件的类型）。
例如：E:/Data(D)/Cat_and_Dog/dog.jpg
参考博主：https://blog.csdn.net/sinat_23118323/article/details/71024351

文档说明：如果接收端（服务端或者客户端）写入文件的地方已经存在了要发送的文件名，那么接收端将不在创建新的文件名，而是覆盖当前文件名，所以在接收端是看不到进度情况，也就是显示百分比的地方，因为就是要写入的文件夹已经存在了要发送的文件名，所以创建新的文件名这段时间就已经省去了，所以接收端会马上受到来自发送端的信息，而来不及处理接收的信息长度，所以显示不出百分比。

客户端：

#pragma once
#ifndef _TCPSOCKET_H_
#define _TCPSOCKET_H_
#include <WinSock2.h> //windows socket的头文件
#include <Windows.h>
#include <iostream>
#include <thread>
#include <process.h>
#include<mutex>
#include<string>
#include<process.h>
#define MAX 1024*10
#define err(errMsg) printf("[error] %s failed,code %d\
line:%d\n",errMsg, WSAGetLastError(),__LINE__)
#pragma comment(lib, "ws2_32.lib") //连接winsock2.h的静态库文件

using namespace std;
#pragma pack(push,1)
typedef struct node {
    int age;
    char id[25];
    char name[25];
    char key[25];
};
#pragma pack(pop)
#pragma pack(push,1)
typedef struct link {
    node tk;
    int td;
    unsigned long long length;
};
#pragma
class Socket {
private:
    SOCKET clientSock;
    int id;
    string ip;
    char wb_file[MAXBYTE];
    unsigned long long g_fileSize;
public:
    //获取ClientSock
    SOCKET Getcientsock();
    //获取当前日期
    void OBTION_TIME();
    //获取开始时间
    double START_TIME();
    //获取结束时间
    double END_TIME();
    //获取文件大小
    void  getByteSize(unsigned long long size);
    //返回以MB为单位的文件大小
    unsigned long long RETURN_MB(unsigned long long size);
    //判断输入IP是否存在
    bool TARGE_FILE(string ip);
    //输入文件
    void SEND_FILE(string file);
    //LPVOID是一个没有类型的指针，也就是说你可以将任意类型的指针赋值给LPVOID类型的变量（一般作为参数传递）
    static DWORD WINAPI transmmit(const LPVOID arg);
    bool INPUT_IP(string ipt);
    //系统的实现以上函数
    int MAIN_SOCKET();
    //清理和关闭网络库
    void CLEAR();
    //对结构体中的初始化
    link initstruct();
    //接收图片
    static DWORD WINAPI run(const LPVOID arg);
    //接收图片的线程
    void Thread();
    //一次性发送的文件
    bool send_once(char*Buffer,int length);
    //接收文件
    int Socket_Recv();
    string TYPE_file();
    void REVER_file(string file1, string file2);
};
//定义结构体用来设置
typedef struct my_file
{
    SOCKET clientSocket; //文件内部包含了一个SOCKET 用于和客户端进行通信
    sockaddr_in clientAddr; //用于保存客户端的socket地址
    int id; //文件块的序号
}F;

#endif // !_TCPSOCKET_H_





#include "tcpSocket.h"
#define MAXBYTES 300*1024
//表示一秒钟会有多少个时钟计时单元
#define CLOCKS_PER_SEC ((clock_t)1000) 
mutex m;
//获取当前日期
void Socket::OBTION_TIME() {
	SYSTEMTIME start; //windows.h中  
	GetLocalTime(&start);//time.h的tm结构体一样的效果  
	cout << start.wYear << "/" << start.wMonth << "/" << start.wDay << " " << start.wHour << ":" << start.wMinute << ":" << start.wSecond << endl;
}
// 获取开始时间
double Socket::START_TIME() {
	DWORD start_time;
	start_time = GetTickCount64();
	return (double)start_time;
}
//获取结束时间
double Socket::END_TIME() {
	DWORD end_time;
	end_time = GetTickCount64();
	return double(end_time);
}
SOCKET Socket::Getcientsock() {
	return clientSock;
}
//获取文件大小
void Socket::getByteSize(unsigned long long size) {
	unsigned long long rest = 0;
	if (size < 1024) {
		cout << size << "B" << endl;
		return;
	}
	else {
		size /= 1024;
	}
	if (size < 1024) {
		cout << size << "KB" << endl;
		return;
	}
	else {
		rest = size % 1024;
		size /= 1024;
	}
	if (size < 1024) {
		size *= 100;
		cout << (size / 100) << "." << (rest * 100 / 1024 % 100) << "MB" << endl;
		return;
	}
	else {
		size = size * 100 / 1024;
		cout << (size / 100) << "." << (size % 100) << "GB" << endl;
		return;
	}
}

void Socket::SEND_FILE(string file) {
	int i = 0;
	char Temporary_file[MAXBYTE] = { 0 };//保存发送文件的格式
	for (i = 0; i < file.length(); i++) {
		wb_file[i] = file[i];
		Temporary_file[i] = file[i];
	}
	wb_file[i] = '\0';
	Temporary_file[i] = '\0';
	send(clientSock, Temporary_file, strlen(Temporary_file), 0);
	struct _stat64 st;
	_stat64(wb_file, &st);
	g_fileSize = st.st_size;
}
//LPVOID是一个没有类型的指针，也就是说你可以将任意类型的指针赋值给LPVOID类型的变量（一般作为参数传递）
DWORD WINAPI Socket::transmmit(const LPVOID arg) {
	//上锁是为了方便看输出
	m.lock();

	//F* temp = (F*)arg;
	Socket* so = (Socket*)arg;
	/*
	获取文件的序号int file_id = temp->id;
	获取客户机的端口号ntohs(temp -> clientAddr.sin_port);
	*/
	cout << "测试开始,等待服务端发送消息..." << endl;
	//从客户端处接受数据
	/*
		char Buffer[MAXBYTE] = { 0 }; //缓冲区
		recv(temp->clientSocket, Buffer, MAXBYTE, 0); //recv方法 从客户端通过clientScocket接收
		cout << "线程" << temp->id << "从客户端的" << ntohs(temp->clientAddr.sin_port) << "号端口收到:" << Buffer << endl;
	*/
	char* file_name; //文件路径
	char File_Alias[100] = { 0 };
	file_name = so->wb_file;
	unsigned long long len_file = 0;
	FILE* fp = fopen(file_name, "rb");

	if (fp == NULL) {
		cout << "文件" << file_name << "出错或不存在" << endl;
	}
	else {
		/*
		获取文件大小
		注意这个地方不能使用unsigned long long,因为当文件传输很大的时候，ftell返回的是long
		fseek(fp, 0, SEEK_END);//将读取的文件指针放到文件末尾
		g_fileSize = ftell(fp);
		fseek(fp, 0, SEEK_SET);//指针移到文件开头*/

		
		string send_file_len;
		send_file_len = to_string(so->g_fileSize);
		send(so->clientSock, send_file_len.c_str(), send_file_len.length(), 0);
		cout << "发送文件时间: ";
		so->OBTION_TIME();
		double start_time = so->START_TIME();
		char Buffer[MAXBYTES] = { 0 }; //文件缓冲区
		unsigned long long  size = 0; //读取的文件长度
		while ((size = fread(Buffer, sizeof(char), MAXBYTES, fp)) > 0) {
			//返回非0值表示send错误
			if (send(so->clientSock, Buffer, (unsigned long long)size, NULL) < 0)
			{
				cout << "传输出错，请检查网络配置。" << endl;
				break;
			}
			len_file += size;

			cout.width(3);//i的输出为3位宽
			if ((len_file * 100 / so->g_fileSize) % 5 > 0) {
				cout << (len_file * 100 / so->g_fileSize) << "%";
				cout << "\b\b\b\b";//回删三个字符，使数字在原地变化
			}
			size = 0;
			//每次读取完之后清空缓存区，以便下一块文件读入
			memset(&Buffer, 0, MAXBYTES);
		}
		const char* t = "end";
		send(so->clientSock, t, strlen(t), NULL);
		cout << so->id << "线程已成功发送" << file_name << endl;

		cout << "发送文件大小: ";
		so->getByteSize(len_file);
		cout << "文件发送结束时间: ";
		so->OBTION_TIME();
		double end_time = so->END_TIME();
		double currentTime = 0;
		currentTime = (double)(end_time - start_time) / CLOCKS_PER_SEC;
		cout << "发送文件耗时: " << currentTime << "s" << endl;
		fclose(fp);
	}
	/*
		发送简单的字符串到客户端
		const char* s = "Server file";
		send(temp->clientSocket, s, strlen(s)*sizeof(char)+1, NULL);
		cout << "线程" << temp->id << "通过客户端的" << ntohs(temp->clientAddr.sin_port) << "号端口发送:" << s << endl;
	*/

	m.unlock();

	return 0;
}
bool Socket::INPUT_IP(string ipt) {
	//客户端socket
	//加载winsock库
	WSADATA wsadata;
	//WSA-windows socket ansyc windows的异步套接字 2.2版本的

	if (WSAStartup(MAKEWORD(2, 2), &wsadata) != 0) {
		err("WSAStartup");
		return 0;
	}
	clientSock = socket(AF_INET, SOCK_STREAM, 0);
	if (clientSock == INVALID_SOCKET) {
		err("SOCKET");
		return 0;
	}
	//初始化socket信息
	sockaddr_in clientAddr;
	memset(&clientAddr, 0, sizeof(SOCKADDR));
	//clientAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	const char* ips = ipt.c_str();
	clientAddr.sin_family = AF_INET;
	clientAddr.sin_port = htons(3725);//将本地字节序转换为网络字节序，大端和小端存储
	clientAddr.sin_addr.s_addr = inet_addr(ips);
	if (connect(clientSock, (SOCKADDR*)&clientAddr, sizeof(SOCKADDR)) == SOCKET_ERROR) {
		err("connect");
		return false;
	}
	return true;
}
//对结构中的变量初始化
link Socket::initstruct() {
	link nod;
	/*
	memset(nod.id, 0, sizeof(nod.id));
	memset(nod.name, 0, sizeof(nod.name));
	memset(nod.key, 0, sizeof(nod.key));*/
	//memcpy(nod.id, "123456", sizeof(nod.id[0])*7);
	strcpy(nod.tk.id, "123456");
	//memcpy(nod.name, "tom", sizeof(nod.name[0])*4);
	strcpy(nod.tk.name, "tom");
	//memcpy(nod.key, "123456", sizeof(nod.key[0])*7);
	strcpy(nod.tk.key, "123456");
	
	nod.tk.age = 18;
	nod.td = 2;
	return nod;
}
//接收和传输文件目录
bool Socket::TARGE_FILE(string ip) {
	bool flag = INPUT_IP(ip);
	if (flag == true)return 1;
	else {
		return 0;
	}
}
DWORD WINAPI Socket::run(const LPVOID arg) {
	Socket* soc = (Socket*)arg;
	char* img;
	while (true) {
		int ret = recv(soc->clientSock, img, strlen(img), NULL);
	}
}
void Socket::Thread() {
	CreateThread(NULL, 0, &run, this, 0, NULL);
}
//一次性发送的文件
bool Socket::send_once(char* Buffer, int length) {
	int len = 0;
	int sum_len = 0;
	while (sum_len < sizeof(link)) {
		if ((len = send(clientSock, Buffer + sum_len, sizeof(link) - sum_len, NULL)) < 0) {
			return false;
		}
		sum_len += len;
	}
	return true;
}
int Socket::MAIN_SOCKET() {
	//建立连接
	//while (true) {
	cout << "已建立连接。" << endl;
	char Buffer[MAXBYTE] = { 0 }; // 文件缓冲区
	char wb_file[100] = { 0 }; //写入的文件
	//“句柄” 类似指针, 但通过指针可读写对象, 通过句柄只是使用对象;
	HANDLE hThread[2];
	for (int i = 0; i < 1; i++) {
		sockaddr_in clntAddr;
		memset(&clntAddr, 0, sizeof(SOCKADDR));
		//使用 API 的 CreateThread, 它执行完入口函数后会自动退出, 无需 ExitThread;
		hThread[i] = CreateThread(NULL, 0, &transmmit, this, 0, NULL);
	}
	//等待子线程完成
	WaitForMultipleObjects(1, hThread, TRUE, INFINITE);
	cout << "错误代码: " << WSAGetLastError() << endl;

	//}

	return 0;
}
int Socket::Socket_Recv() {
	char Buffer[MAXBYTES] = { 0 }; // 文件缓冲区
	char wb_files[MAXBYTE] = { 0 };
	FILE* fp = fopen(wb_file, "wb");
	//如果录入文件不存在的话就创建一个新的文件
	if (fp == NULL) {
		fp = fopen(wb_file, "w");
	}
	unsigned long long len_file = 0;
	if (fp == NULL) {
		cout << "操作文件时出错" << endl;
		system("pause");
	}
	else {
		cout << "接收文件时间: ";
		OBTION_TIME();

		unsigned long long g_fileSizes = 0;
		char rev_buffer[MAXBYTES] = { 0 };//接收文件的长度
		int rev_len = recv(clientSock, rev_buffer, MAXBYTE, 0);
		if (rev_len > 0) {
			rev_buffer[rev_len] = '\0';
			for (int i = 0; i < strlen(rev_buffer); i++) {
				g_fileSizes = g_fileSizes * 10 + ((unsigned long long)rev_buffer[i] - 48);
			}
		}
		double start_time = START_TIME();
		memset(&Buffer, 0, MAXBYTES);
		unsigned long long  size = 0;
		//当成功接收文件（size > 0）时，判断写入的时候文件长度是否等于接收的长度
		while ((size = recv(clientSock, Buffer, MAXBYTES, 0)) > 0) {

			if (Buffer[size - 3] == 'e' && Buffer[size - 2] == 'n' && Buffer[size - 1] == 'd')
			{
				char buffer[MAXBYTES] = { 0 };
				for (int i = 0; i < strlen(Buffer) - 3; i++) {
					buffer[i] = Buffer[i];
				}
				len_file += size - 3;
				size -= 3;
				if (fwrite(buffer, sizeof(char), size, fp) < size) {
					cout << "写入出错，部分文件缺失。" << endl;
					break;
				}
				cout.width(3);//i的输出为3位宽
				if ((len_file * 100 / g_fileSizes) % 5 > 0) {
					cout << (len_file * 100 / g_fileSizes) << "%";
					cout << "\b\b\b\b";//回删三个字符，使数字在原地变化
				}
				break;
			}
			else {
				if (fwrite(Buffer, sizeof(char), size, fp) < size) {
					cout << "写入出错，部分文件缺失。" << endl;
					break;
				}
				len_file += size;
			}
			cout.width(3);//i的输出为3位宽
			if ((len_file * 100 / g_fileSizes) % 5 > 0) {
				cout << (len_file * 100 / g_fileSizes) << "%";
				cout << "\b\b\b\b";//回删三个字符，使数字在原地变化
			}
			//清空缓存区以便下一次接收
			memset(&Buffer, 0, MAXBYTE);
		}
		cout << "接收完成" << endl;
		cout << "接受文件大小: ";
		len_file = (unsigned long long)len_file;
		getByteSize(len_file);
		cout << "文件结束接受时间: ";
		OBTION_TIME();
		double end_time = END_TIME();
		double currentTime = 0;
		currentTime = (double)(end_time - start_time) / CLOCKS_PER_SEC;
		cout << "接收文件耗时: " << currentTime << "s" << endl;
		fclose(fp);
	}
	return 0;
}
string Socket::TYPE_file() {
	string end_file = "";
	char Temporary[1024] = { 0 };
	char file[1024] = { 0 };
	int index_last = 0;
	int ret = recv(clientSock, file, 100, 0);
	for (int i = strlen(file) - 1; i >= 0; i--) {
		if (file[i] == '\\') {
			index_last = i;
			break;
		}
	}
	index_last++;
	end_file += "\\";
	if (ret > 0) {
		file[ret] = '\0';
		for (int i = index_last; i < strlen(file); i++) {
			end_file += file[i];
		}
	}
	return end_file;
}
void Socket::REVER_file(string file, string filename) {
	int i = 0;
	memset(wb_file, 0, sizeof(wb_file));
	int len_file = file.length();
	int len_filename = filename.length();
	for (i = 0; i < len_file; i++) {
		wb_file[i] = file[i];
	}
	int j = 0;
	for (i = len_file; i < (len_file + len_filename) && j < len_filename; j++, i++) {
		wb_file[i] = filename[j];
	}
	wb_file[i] = '\0';
}
void Socket::CLEAR() {
	closesocket(clientSock);
	关闭网络库 
	if (WSACleanup() != 0) {
		err("WSACleanup");
		return;
	}
	cout << "客户端连接已关闭。" << endl;
	system("pause");

}

#include"tcpSocket.h"
#define MAXBYTES 1024
int main() {
	Socket* soc = new Socket();
	
	while (true) {
		string ip;
		cout << "请输入目标机器的IP：";
		cin >> ip;
		bool flag = soc->TARGE_FILE(ip);
		if (flag == true)break;
		else {
			cout << "IP地址错误或者目标主机不存在" << endl;
			continue;
		}
	}
	/*
	link nod = soc->initstruct();
	memset(Buffer, 0, sizeof(Buffer));
	memcpy(Buffer, &nod, sizeof(link));
	soc->send_once(Buffer, sizeof(link) + 1);*/
	
	while (true) {
		string wb_file;
		char Tempoary[1024] = { 0 };
		char Buffer[MAXBYTES] = { 0 };
		cout << "首先请客户端输入传输文件路径: ";
		string file;
		cin >> file;
		soc->SEND_FILE(file);
		int ret = recv(soc->Getcientsock(), Tempoary, 10, 0);
		if (ret < 0)continue;
		soc->MAIN_SOCKET();
		cout << "其次请客户端输入想要写入的文件(不用输入文件名): ";
		cin >> wb_file;
		string st = "ESC";
		string end_file = soc->TYPE_file();
		send(soc->Getcientsock(), st.c_str(), st.length(), 0);
		soc->REVER_file(wb_file, end_file);
		soc->Socket_Recv();
	}
	soc->CLEAR();
	delete  soc;
	return 0;
}

服务端：

#pragma once
#ifndef _TCPSERVER_H_
#define _TCPSERVER_H_
#include <WinSock2.h> //windows socket的头文件
#include <Windows.h>
#include <iostream>
#include <thread>
#include <mutex>
#include <process.h>
#include <fstream>
#include <string>
#include<time.h>
#define MAX 10*1024
#define err(errMsg) printf("[error] %s failed,code %d\
line:%d\n",errMsg, WSAGetLastError(),__LINE__)

#pragma comment(lib, "ws2_32.lib") //连接winsock2.h的静态库文件

using namespace std;
class Server {
    private:
        SOCKET clientSock;
        SOCKET servSocket;
        int id;
        char  wb_file[MAXBYTE];//写入文件路径
        char  wb_files[MAXBYTE];//发送文件路径
        char filename[MAXBYTE];
        unsigned long long g_fileSize;
    public:
        //获取clientSock
        SOCKET GetclientSock();
        //获取servSocket
        SOCKET GetservSocket();
        //获取当前日期
        void OBTION_TIME();
        //获取开始时间
        double START_TIME();
        //获取结束时间
        double END_TIME();
        //获取文件大小
        void  getByteSize(unsigned long long size);
        //返回以MB为单位的文件大小
        unsigned long long RETURN_MB(unsigned long long size);
        //绑定和监听
        void TARGE_FILE();
        //返回文件的类型
        string TYPE_file();
        //LPVOID是一个没有类型的指针，也就是说你可以将任意类型的指针赋值给LPVOID类型的变量（一般作为参数传递）
        static DWORD WINAPI transmmit(const LPVOID arg);
        //系统的实现以上函数
        int MAIN_Server();
        //接收文件
        void REVER_file(string file, string fileanme);
        //清理网络库和关闭
        void CLEAR();
        //发送图片
        static DWORD WINAPI run(const LPVOID arg);
        //发送图片的线程
        void Thread();
        //一次性的接收发送的文件等
        bool recv_once(char buffer[], int length);
        //处理接收到的信息
        void solve_file(char buffer[], int length);
        //根据分类来处理信息，鼠标，键盘，文件，图片等
        void do_handle(char Buffer[], int length);
        //发送文件
        int Server_Send();
        //发送文件1
        void SEND_FILE(string file);
};
//定义结构体用来设置
typedef struct my_file {
    SOCKET clientSocket; //文件内部包含了一个SOCKET 用于和客户端进行通信
    sockaddr_in clientAddr; //用于保存客户端的socket地址
    int id; //文件块的序号
}F;
#pragma pack(push,1)
struct node {
    int age;
    char id[25];
    char name[25];
    char key[25];
};
#pragma pack(pop)
#pragma pack(push,1)
typedef struct link {
    node tk;
    int td;
    unsigned long long length;
};
#pragma
#endif // !_TCPSERVER_H_






#include "tcpServer.h"
#define MAXBYTES 300*1024
mutex m;
//获取当前日期
void Server::OBTION_TIME() {
	SYSTEMTIME start; //windows.h中  
	GetLocalTime(&start);//time.h的tm结构体一样的效果  
	cout << start.wYear << "/" << start.wMonth << "/" << start.wDay << " " << start.wHour << ":" << start.wMinute << ":" << start.wSecond << endl;
}
//获取开始时间
double Server::START_TIME() {
	DWORD start_time;
	start_time = GetTickCount64();
	return (double)start_time;
}
//获取结束时间
double Server::END_TIME() {
	DWORD end_time;
	end_time = GetTickCount64();
	return double(end_time);
}
//获取文件大小
void  Server::getByteSize(unsigned long long size) {
	unsigned long long rest = 0;
	if (size < 1024) {
		cout << size << "B" << endl;
		return;
	}
	else {
		size /= 1024;
	}
	if (size < 1024) {
		cout << size << "KB" << endl;
		return;
	}
	else {
		rest = size % 1024;
		size /= 1024;
	}
	if (size < 1024) {
		size *= 100;
		cout << (size / 100) << "." << (rest * 100 / 1024 % 100) << "MB" << endl;

		return;
	}
	else {
		size = size * 100 / 1024;
		cout << (size / 100) << "." << (size % 100) << "GB" << endl;
		return;
	}
}
string Server::TYPE_file() {
	string end_file = "";
	char Temporary[1024] = { 0 };
	char file[1024] = { 0 };
	int index_last = 0;
	int ret = recv(GetclientSock(), file, 100, 0);
	for (int i = strlen(file) - 1; i >= 0; i--) {
		if (file[i] == '\\') {
			index_last = i;
			break;
		}
	}
	index_last++;
	end_file += "\\";
	if (ret > 0) {
		file[ret] = '\0';
		for (int i = index_last; i < strlen(file); i++) {
			end_file += file[i];
		}
	}
	return end_file;
}
void Server::TARGE_FILE() {
	//加载网络库
	WSADATA wsaData;
	//第一个参数是winsocket load的版本号（2.2）
	if (WSAStartup(MAKEWORD(2, 3), &wsaData) != 0) {
		err("WSAStartup");
		return;
	}
	//创建服务器端的socket（协议族， sokcet类型）
	servSocket = socket(AF_INET, SOCK_STREAM, 0);//如果改成SOCK_DGRAM则使用UDP
	if (servSocket == INVALID_SOCKET) {
		err("SOCKET");
		return;
	}
	sockaddr_in servAddr; //服务器的socket地址，包含sin_addr表示IP地址，sin_port保持端口号和sin_zero填充字节
	memset(&servAddr, 0,  sizeof(SOCKADDR)); //初始化socket地址
	servAddr.sin_family = AF_INET; //设置使用的协议族
	servAddr.sin_port = htons(3725); //设置使用的端口
	servAddr.sin_addr.s_addr = INADDR_ANY; //define s_addr = S_un.S_addr
	 //将之前创建的servSocket和端口，IP地址绑定
	if (bind(servSocket, (SOCKADDR*)&servAddr, sizeof(SOCKADDR)) == SOCKET_ERROR) {
		err("bind");
		return;
	}
	HANDLE hThread[2];
	hThread[0]=CreateThread(NULL, 0, &run, this, 0, NULL);
	WaitForMultipleObjects(1, hThread, TRUE, INFINITE);
	/*
	listen(servSocket, 1); //监听服务器端口
	sockaddr_in clntAddr;
	int nSize = sizeof(clntAddr);
	cout << "等待连接..." << endl;
	clientSock = accept(servSocket, (SOCKADDR*)&clntAddr, &nSize);
	if (clientSock == INVALID_SOCKET) {
		err("accept");
	}
	cout << "连接成功" << endl;*/
}
DWORD WINAPI Server::run(const LPVOID arg) {
	Server* ser = (Server*)arg;
	listen(ser->servSocket, 1); //监听服务器端口
	sockaddr_in clntAddr;
	int nSize = sizeof(clntAddr);
	cout << "等待连接..." << endl;
	ser->clientSock = accept(ser->servSocket, (SOCKADDR*)&clntAddr, &nSize);
	if (ser->clientSock == INVALID_SOCKET) {
		err("accept");
	}
	cout << "连接成功" << endl;
	return 0;
}
void Server::REVER_file(string file, string filename) {
	int i = 0;
	int len_file = file.length();
	int len_filename = filename.length();
	for (i = 0; i < len_file; i++) {
		wb_file[i] = file[i];
	}
	int j = 0;
	for (i = len_file; i < (len_file + len_filename) && j < len_filename; j++, i++) {
		wb_file[i] = filename[j];
	}
	wb_file[i] = '\0';
}
SOCKET Server::GetclientSock() {
	return clientSock;
}
SOCKET Server::GetservSocket() {
	return servSocket;
}

bool Server::recv_once(char buffer[], int length) {
	link nod;
	memset(buffer, 0, sizeof(buffer));
	int len = 0;
	int sum_len = 0;
	while (sum_len < sizeof(link)) {
		if ((len = recv(clientSock, buffer + sum_len, sizeof(link) - sum_len, NULL)) < 0) {
			return false;
		}
		nod = *(link*)buffer;
		cout << "strlen(nod.id) = " << strlen(nod.tk.id) << endl;
		cout << "strlen(nod.name) = " << strlen(nod.tk.name) << endl;
		cout << "strlen(nod.key) = " << strlen(nod.tk.key) << endl;

		cout << "link.id = " << nod.tk.id << endl;
		cout << "link.name = " << nod.tk.name << endl;
		cout << "link.key = " << nod.tk.key << endl;
		cout << "link.age = " << nod.tk.age << endl;
		cout << "link.td = " << nod.td << endl;
		cout << "接收的文件长度: " <<nod.length << "B" << endl;
		sum_len += len;
	}
	return true;
}
void Server::do_handle(char Buffer[], int length) {
	link nod = *(link*)Buffer;
	switch (nod.td){
		case 0:
			cout << "图片" << endl;
			break;
		case 1:
			cout << "键盘" << endl;
			break;
		case 2:
			cout << "鼠标" << endl;
			break;
		case 3:
			cout << "文件" << endl;
			break;
		default:
			break;
	}
}
void Server::solve_file(char Buffer[], int length) {
	try {
		if (recv_once(Buffer, sizeof(link) + 1) ){
			do_handle(Buffer,length);
		}
	}
	catch (exception& e) {
		cout << e.what() << endl;
	}
}
void Server::Thread() {
	CreateThread(NULL, 0, &run, this, 0, NULL);
}
void Server::SEND_FILE(string file) {
	int i = 0;
	char Temporary_file[MAXBYTE] = { 0 };//保存发送文件的格式
	memset(wb_file, 0, sizeof(wb_file));
	for (i = 0; i < file.length(); i++) {
		wb_file[i] = file[i];
		Temporary_file[i] = file[i];
	}
	wb_file[i] = '\0';
	Temporary_file[i] = '\0';
	send(clientSock, Temporary_file, strlen(Temporary_file), 0);
	struct _stat64 st;
	_stat64(wb_file, &st);
	g_fileSize = st.st_size;
}
int Server::MAIN_Server() {
	char Buffer[MAXBYTES] = { 0 }; // 文件缓冲区
	char wb_files[MAXBYTE] = { 0 };
	FILE* fp = fopen(wb_file, "wb");
	//如果录入文件不存在的话就创建一个新的文件
	if (fp == NULL) {
		fp = fopen(wb_file, "w");
	}
	unsigned long long len_file = 0;
	if (fp == NULL) {
		cout << "操作文件时出错" << endl;
		system("pause");
	}
	else {
		cout << "接收文件时间: ";
		OBTION_TIME();
		
		unsigned long long g_fileSizes = 0;
		char rev_buffer[MAXBYTES] = { 0 };//接收文件的长度
		int rev_len = recv(clientSock, rev_buffer, MAXBYTE, 0);
		if (rev_len > 0) {
			rev_buffer[rev_len] = '\0';
			for (int i = 0; i < strlen(rev_buffer); i++) {
				g_fileSizes = g_fileSizes * 10 + ((unsigned long long)rev_buffer[i] - 48);
			}
		}
		double start_time = START_TIME();
		memset(&Buffer, 0, MAXBYTES);
		unsigned long long  size = 0;
		//当成功接收文件（size > 0）时，判断写入的时候文件长度是否等于接收的长度
		while ((size = recv(clientSock, Buffer, MAXBYTES, 0)) > 0) {

			if (Buffer[size - 3] == 'e' && Buffer[size - 2] == 'n' && Buffer[size - 1] == 'd')
			{
				char buffer[MAXBYTES] = { 0 };
				for (int i = 0; i < strlen(Buffer) - 3; i++) {
					buffer[i] = Buffer[i];
				}
				len_file += size - 3;
				size -= 3;
				if (fwrite(buffer, sizeof(char), size, fp) < size) {
					cout << "写入出错，部分文件缺失。" << endl;
					break;
				}
				cout.width(3);//i的输出为3位宽
				if ((len_file * 100 / g_fileSizes) % 5 > 0) {
					cout << (len_file * 100 / g_fileSizes) << "%";
					cout << "\b\b\b\b";//回删三个字符，使数字在原地变化
				}
				break;
			}
			else {
				if (fwrite(Buffer, sizeof(char), size, fp) < size) {
					cout << "写入出错，部分文件缺失。" << endl;
					break;
				}
				len_file += size;
			}
			cout.width(3);//i的输出为3位宽
			if ((len_file * 100 / g_fileSizes) % 5 > 0) {
				cout << (len_file * 100 / g_fileSizes) << "%";
				cout << "\b\b\b\b";//回删三个字符，使数字在原地变化
			}
			//清空缓存区以便下一次接收
			memset(&Buffer, 0, MAXBYTE);
		}
		cout << "接收完成" << endl;
		cout << "接受文件大小: ";
		len_file = (unsigned long long)len_file;
		getByteSize(len_file);
		cout << "文件结束接受时间: ";
		OBTION_TIME();
		double end_time = END_TIME();
		double currentTime = 0;
		currentTime = (double)(end_time - start_time) / CLOCKS_PER_SEC;
		cout << "接收文件耗时: " << currentTime << "s" << endl;
		fclose(fp);
	}
	return 0;

}
DWORD WINAPI Server::transmmit(const LPVOID arg) {
	//上锁是为了方便看输出
	m.lock();

	//F* temp = (F*)arg;
	Server* so = (Server*)arg;
	/*
	获取文件的序号int file_id = temp->id;
	获取客户机的端口号ntohs(temp -> clientAddr.sin_port);
	*/
	cout << "测试开始,等待服务端发送消息..." << endl;
	//从客户端处接受数据
	/*
		char Buffer[MAXBYTE] = { 0 }; //缓冲区
		recv(temp->clientSocket, Buffer, MAXBYTE, 0); //recv方法 从客户端通过clientScocket接收
		cout << "线程" << temp->id << "从客户端的" << ntohs(temp->clientAddr.sin_port) << "号端口收到:" << Buffer << endl;
	*/
	char* file_name; //文件路径
	char File_Alias[100] = { 0 };
	file_name = so->wb_file;
	unsigned long long len_file = 0;
	FILE* fp = fopen(file_name, "rb");

	if (fp == NULL) {
		cout << "文件" << file_name << "出错或不存在" << endl;
	}
	else {
		/*
		获取文件大小
		注意这个地方不能使用unsigned long long,因为当文件传输很大的时候，ftell返回的是long
		fseek(fp, 0, SEEK_END);//将读取的文件指针放到文件末尾
		g_fileSize = ftell(fp);
		fseek(fp, 0, SEEK_SET);//指针移到文件开头*/
		
		string send_file_len;
		send_file_len = to_string(so->g_fileSize);
		send(so->clientSock, send_file_len.c_str(), send_file_len.length(), 0);
		cout << "发送文件时间: ";
		so->OBTION_TIME();
		double start_time = so->START_TIME();
		char Buffer[MAXBYTES] = { 0 }; //文件缓冲区
		unsigned long long  size = 0; //读取的文件长度
		while ((size = fread(Buffer, sizeof(char), MAXBYTES, fp)) > 0) {
			//返回非0值表示send错误
			if (send(so->clientSock, Buffer, (unsigned long long)size, NULL) < 0)
			{
				cout << "传输出错，请检查网络配置。" << endl;
				break;
			}
			len_file += size;

			cout.width(3);//i的输出为3位宽
			if ((len_file * 100 / so->g_fileSize) % 5 > 0) {
				cout << (len_file * 100 / so->g_fileSize) << "%";
				cout << "\b\b\b\b";//回删三个字符，使数字在原地变化
			}
			size = 0;
			//每次读取完之后清空缓存区，以便下一块文件读入
			memset(&Buffer, 0, MAXBYTES);
		}
		const char* t = "end";
		send(so->clientSock, t, strlen(t), NULL);
		cout << so->id << "线程已成功发送" << file_name << endl;

		cout << "发送文件大小: ";
		so->getByteSize(len_file);
		cout << "文件发送结束时间: ";
		so->OBTION_TIME();
		double end_time = so->END_TIME();
		double currentTime = 0;
		currentTime = (double)(end_time - start_time) / CLOCKS_PER_SEC;
		cout << "发送文件耗时: " << currentTime << "s" << endl;
		fclose(fp);
	}
	/*
		发送简单的字符串到客户端
		const char* s = "Server file";
		send(temp->clientSocket, s, strlen(s)*sizeof(char)+1, NULL);
		cout << "线程" << temp->id << "通过客户端的" << ntohs(temp->clientAddr.sin_port) << "号端口发送:" << s << endl;
	*/

	m.unlock();

	return 0;
}
int Server::Server_Send() {
	//建立连接
	//while (true) {
	cout << "已建立连接。" << endl;
	char Buffer[MAXBYTES] = { 0 }; // 文件缓冲区
	char wb_file[100] = { 0 }; //写入的文件
	//“句柄” 类似指针, 但通过指针可读写对象, 通过句柄只是使用对象;
	HANDLE hThread[2];
	for (int i = 0; i < 1; i++) {
		sockaddr_in clntAddr;
		memset(&clntAddr, 0, sizeof(SOCKADDR));
		//使用 API 的 CreateThread, 它执行完入口函数后会自动退出, 无需 ExitThread;
		hThread[i] = CreateThread(NULL, 0, &transmmit, this, 0, NULL);
	}
	//等待子线程完成
	WaitForMultipleObjects(1, hThread, TRUE, INFINITE);
	cout << "错误代码: " << WSAGetLastError() << endl;

	//}

	return 0;
}
void Server::CLEAR() {
	//关闭socket，释放winsock
	if (this != nullptr) {
		closesocket(clientSock);
		closesocket(servSocket);
	}
	关闭网络库 
	if (WSACleanup()!=0) {
		err("WSACleanup");
		return;
	}
	cout << "服务器连接已关闭。" << endl;
	system("pause");
}

#include "tcpServer.h"
#define MAXBYTES 1024
int main() {
	Server* ser = new Server();
	ser->TARGE_FILE();
	//unsigned long long length = 0;

	//ser->solve_file(buffer, sizeof(link) + 1);
	
	while (true) {
		char buffer[MAXBYTES] = { 0 };
		string wb_file;
		char Tempoary[MAXBYTES] = { 0 };
		cout << "其次请服务端输入想要写入的文件(不用输入文件名): ";
		cin >> wb_file;
		string st = "ESC";
		string end_file = ser->TYPE_file();
		send(ser->GetclientSock(), st.c_str(), st.length(), 0);
		ser->REVER_file(wb_file, end_file);
		ser->MAIN_Server();
		cout << "首先请服务端传输文件路径: ";
		string file;
		cin >> file;
		ser->SEND_FILE(file);
		int ret = recv(ser->GetclientSock(), Tempoary, 10, 0);
		if (ret < 0)continue;
		ser->Server_Send();
	}
	ser->CLEAR();
	delete ser;
	return 0;
}
Keep_Trying_Go
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
QT中使用C++ socket通信 客户端与服务端的代码实例
05-13
服务端和客户端中分别对socket进行的操作，进行socket连接
C++传输图片给服务端
Lee的博客
03-13 454
【代码】C++传输图片给服务端。
【C++网络编程】Socket基础：网络通讯程序入门级教程
朝花夕拾
03-11 4163
本篇博文介绍了C++网络编程的基础知识，从Socket基础到Epoll的使用，为初学者提供了入门级的教程。读者将学习如何创建套接字、建立连接、发送和接收数据，并深入了解Epoll在高性能网络编程中的应用。
c++ Socket实现客户端与服务器数据传输
Primer5
04-21 2万+
c++ Socket实现客户端与服务器数据传输 这是自己第二次写博客,希望在博客记录自己的学习过程,欢迎大家评论! 实现: 客户端往服务器端发送一条数据,服务器端接收数据并输出; 服务器端再发送出接收到的数据给客户端! 根据自己的脑洞,想一下是否可以通过的改进实现简单的QQ聊天室! 少说废话,上代码 [文字描述都写在注释啦,也就那么点,] 服务器实现 一般情况下,先实现服务端的代码,这样逻辑可能会...
C++ socket网络编程——即时通信系统
热门推荐
斯斯的博客
06-07 5万+
一：项目内容本项目使用C++实现一个具备服务器端和客户端即时通信且具有私聊功能的聊天室。目的是学习C++网络开发的基本概念，同时也可以熟悉下Linux下的C++程序编译和简单MakeFile编写二：需求分析这个聊天室主要有两个程序：1.服务端：能够接受新的客户连接，并将每个客户端发来的信息，广播给对应的目标客户端。2.客户端：能够连接服务器，并向服务器发送消息，同时可以接收服务器发来的消息。即最简...
Socket 学习之 MFC：简单通信 TCP 双向
落日流沙
03-17 1439
最终界面如图所示： 不管客户端还是服务器，头文件添加爱 #include &lt;winsock2.h&gt; #include &lt;ws2tcpip.h&gt; #include &lt;stdio.h&gt; #include &lt;windows.h&gt; #include &lt;string&gt; #include &lt;iostream&gt; #inc...
大型文件传输
12-18
自己写的实现大型文件传输的例子，完整的工程。运行比较稳定，发送采用多线程实现，，局域网的测试发送速度在6.2M每秒。
使用C++实现Socket编程传输文件
Keep_Trying_Go的博客
07-25 4591
客户端： #pragma once #ifndef _TCPSOCKET_H_ #define _TCPSOCKET_H_ #include <WinSock2.h> //windows socket的头文件 #include <Windows.h> #include <iostream> #include <thread> #include <process.h> #include<mutex> #include<string&
C/C++大文件/数据网络传输方法总结
jmppok的专栏
01-16 1万+
在C/C++网络编程中不免会遇到需要传输大数据、大文件的情况，而由于socket本身缓冲区的限制，大概一次只能发送4K左右的数据，所以在传输大数据时客户端就需要进行分包，在目的地重新组包。而实际上已有一些消息/通讯中间件对此进行了封装，提供了直接发送大数据/文件的接口；除此之外，利用共享目录，ftp，ssh等系统命令来实现大文件/数据也不失为一种好的方法。
C++中TCP socket传输文件
u011555996的博客
11-07 2843
C++
C/C++用socket实现简单的TCP文件传输
qq_44184756的博客
04-02 1万+
本文主要用于总结学习到的关于socket网络编程的知识以及回顾项目原理等相关内容，进一步加深了对于TCP通信与实际项目之间联系的理解，也欢迎各位大佬对于文章中的错误理解进行批评指正以及对进一步完善所需要学习了解的知识原理给出重要建议
C++Socket编程实例(服务端跟客户端通信).rar
01-15
C++实现服务端跟客户端通信,已验证 简单例子,适合新手学习 , 创建工程直接运行即可 ,有兴趣的可以共同学习 ,
tcp socket 服务端客户端实现（C++）
11-22
简单tcp socket 客户端 服务端代码实现 附C++代码源码
vc++实现的tcp socket客户端和服务端示例
01-01
int main(){ // initial socket library WORD wVerisonRequested; WSADATA wsaData; int err; wVerisonRequested = MAKEWORD(1, 1); err = WSAStartup(wVerisonRequested, &wsaData); if (err != 0) { ...
Linux环境下C语言Socket编程——客户端向服务端单次发送一个或多个文件的功能
03-23
网上很多有关socket文件传输的源码都是每次只能发送一个文件，如果想传输多个文件，不但需要多次交互，还需要把每个文件的文件名都输入进去，很不方便，所以进行了一个小扩展：即客户端可以将打算传送的多个文件都先...
算法训练营day21
wugong_true的博客
04-23 355
接下来，根据计数count与最大计数maxCount的比较，更新众数的结果数组resList和最大计数maxCount。如果count大于maxCount，则清空resList并将当前节点值添加进去，并更新maxCount为count；接着，根据resList中的众数，创建一个整型数组res，并将其返回作为结果。然后，通过与前一个节点的值进行比较，判断当前节点值出现的次数。如果当前节点与前一个节点的值不同，说明出现了一个新的值，将计数count重置为1；，计算相邻两个元素的差值，并将较小的差值更新到。
力扣HOT100 - 543. 二叉树的直径
qq_61504864的博客
04-23 173
【代码】力扣HOT100 - 543. 二叉树的直径。
【错题集-编程题】数组中的最长连续子序列（排序 + 模拟）
最新发布
Elena's Blog
04-24 260
因为题目不要求位置连续，那么就可以直接想到排序（我把这一块理解错了，导致没有排序去做），接着就是简单的模拟。，然而实际上这道题目要求的是。小心处理数字相同的情况。
二分答案算法
2301_79980806的博客
04-21 1025
跟二分查找类似，当我们要找某个量的最值的时候，可以在这个两最小可能的取值，和最大可能的取值之间二分，来快速找到答案check函数为了验证中间值是否符合题目要求，根据是否来决定下一轮区间界限是作曲兼缩小，还是右区间缩小。
c++中实现websocket客户端和服务端
05-25
在C++中实现WebSocket客户端和服务端，通常需要使用第三方库来简化操作。以下是使用两个流行的C++ WebSocket库的示例代码： 1. 使用Boost.Beast库实现WebSocket客户端和服务端： WebSocket客户端： ```c++ #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值