基于TCP/IP协议的网络通信实例——文件传输

C++实现的TCP文件传输服务器与客户端
原创 于 2021-11-11 15:32:11 发布 · 3.2k 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#tcp/ip #文件传输

这是一个使用C++编写的TCP文件传输系统，包括服务端和客户端。服务端通过监听指定端口接收客户端连接，设定接收和发送缓冲区大小，接收并保存客户端发送的文件。客户端则连接到服务端，发送文件名和文件内容，接收服务器反馈。代码中包含了接收文件名称、文件长度、文件内容的处理逻辑，并具备错误处理和缓冲区大小调整功能。

一、服务端代码：MyServer.cpp

// MyServer.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
using namespace std;

#include<stdlib.h>
#include<winsock2.h>//引用头文件
#pragma comment(lib,"ws2_32.lib")//引用库文件

//最大连接数
#define g_MaxConnect  20
int g_Connect = 0;

struct sock_params
{
	SOCKET hsock;
	int nSockIndex;
};

//线程实现函数
DWORD WINAPI threadpro(LPVOID pParam)
{
	sock_params* sockPam = (sock_params*)pParam;
	SOCKET hsock = sockPam->hsock;
	int nSockIndex = sockPam->nSockIndex;

	char aIndex[4];
	_itoa_s(nSockIndex, aIndex, 10);

	char buffer[1024];
	char sendBuffer[1024];
	if(hsock != INVALID_SOCKET)
	{
		cout<<"客户端 "<< nSockIndex << " 加入服务器!" <<endl;
	}
	
	// 设定接收缓冲区大小
	int nRecvBufLen = 1024* 1024; //默认设置为1024K
	int nStaus = setsockopt(hsock ,SOL_SOCKET,SO_RCVBUF,(const char*)&nRecvBufLen,sizeof(int));
	if (nStaus == SOCKET_ERROR)
	{
		hcDebugLog(_T("ZLY:设定接收缓冲区大小失败！"));
	}

	// 设定发送缓冲区大小
	int nSendBufLen = 1024* 1024; //默认设置为1024K
	nStaus = setsockopt(hsock ,SOL_SOCKET,SO_SNDBUF,(const 		char*)&nSendBufLen,sizeof(int));
	if (nStaus == SOCKET_ERROR)
	{
		hcDebugLog(_T("ZLY:设定发送缓冲区大小失败！"));
	}
	
	//循环接收发送的文件内容
	int nErrorNum = 0;
	while (1)
	{
		// 服务端接收文件名称数据
		FileName fn;
		memset(&fn, 0, sizeof(FileName));
		int nRecvSize = recv(clientSocket, (char*)&fn, sizeof(fn), 0);
		if (sizeof(fn) != nRecvSize)
		{
			if (nRecvSize != 0 && nErrorNum <= MAX_ERROR_NUM)
			{
				printf("接收文件名称失败！错误码:%d\n", WSAGetLastError());
				nErrorNum++;
				continue;
			}
			else
			{
				break;
			}
		}

		char chPath[_MAX_PATH];
		memset(chPath, 0, sizeof(char)*_MAX_PATH);
		strcpy_s(chPath, sizeof(chPath), fn.serverDir);
		int len = strlen(chPath);
		if (chPath[len - 1] != '\\')
		{
			chPath[len] = '\\';
			len++;
		}

		strcat_s(chPath, fn.dir);
		len = strlen(chPath);
		if (chPath[len - 1] != '\\')
		{
			chPath[len] = '\\';
			len++;
		}

		// 创建对应目录
		g_lock.Lock();
		CreateDir(chPath);
		g_lock.UnLock();
		strcat_s(chPath, fn.Fname);

		// 创建文件
		FILE* fp = NULL;
		errno_t err = fopen_s(&fp, chPath, "wb");
		if (err != 0)
		{
			printf("创建文件失败：%s, 错误码:%d\n", chPath, GetLastError());
			continue;
		}

		// 服务端接收文件长度
		long long nSize;
		nRecvSize = recv(clientSocket, (char*)&nSize, sizeof(nSize), 0);
		if (sizeof(nSize) != nRecvSize)
		{
			if (fp)
			{
				fclose(fp);
				fp = NULL;
			}

			if (nRecvSize != 0 && nErrorNum <= MAX_ERROR_NUM)
			{
				printf("接收文件长度失败！错误码:%d\n", WSAGetLastError());
				nErrorNum++;
				continue;
			}
			else
			{
				break;
			}
		}

		// 循环接受文件内容
		int num;
		char buff[MAX_PACK_SIZE];
		while (nSize > 0)
		{
			if (nSize >= MAX_PACK_SIZE)
			{
				num = recv(clientSocket, buff, MAX_PACK_SIZE, 0);
			}
			else
			{
				num = recv(clientSocket, buff, nSize, 0);
			}

			fwrite(buff, (int)num, 1, fp);
			nSize -= num;
			memset(buff, 0, sizeof(char)*MAX_PACK_SIZE); //将buff清空
		}

		// 关闭文件
		if (fp)
		{
			fclose(fp);
			fp = NULL;
		}

		// 发送文件接受成功状态
		int nRecvStatus = 0;
		send(clientSocket, (char*)&nRecvStatus, sizeof(int), 0);
	}

	return 0;
}

//主函数
void main()
{
	WSADATA wsd;//定义WSADATA对象
	WSAStartup(MAKEWORD(2,2),&wsd);
	SOCKET m_SockServer;
	sockaddr_in serveraddr;

	sockaddr_in serveraddrfrom;
	SOCKET m_Server[g_MaxConnect];

	serveraddr.sin_family = AF_INET;//设置服务器地址
	serveraddr.sin_port = htons(4600);//设置端口号
	serveraddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
	m_SockServer = socket(AF_INET,SOCK_STREAM,0);
	int nStatus = bind(m_SockServer,(sockaddr*)&serveraddr,sizeof(serveraddr));
	if (nStatus == 0)
	{
		cout << "服务端启动成功!" <<endl;
	}
	else
	{
		cout << "服务端启动失败!" <<endl;
		return;
	}

	int iLisRet = 0;
	int len = sizeof(sockaddr);
	while(1)
	{
		iLisRet = listen(m_SockServer,0);//进行监听
		m_Server[g_Connect] = accept(m_SockServer,(sockaddr*)&serveraddrfrom,&len);

		//同意连接
		if(m_Server[g_Connect] != INVALID_SOCKET)
		{
			if(g_Connect > g_MaxConnect-1)
			{
				char WarnBuf[50]="客户端连接个数:超限!";
				int ires = send(m_Server[g_Connect],WarnBuf,sizeof(WarnBuf),0);
			}
			else
			{
				char cIndex[4];
				_itoa_s(g_Connect, cIndex, 10);
				char buf[50]="你的服务端ID: ";
				strcat_s(buf, cIndex);

				int ires = send(m_Server[g_Connect],buf,sizeof(buf),0);//发送字符过去
				//cout << buf <<endl;

				HANDLE m_Handel;	//线程句柄
				DWORD nThreadId=0;	//线程ID

				sock_params sockPam;
				sockPam.hsock = m_Server[g_Connect];
				sockPam.nSockIndex = g_Connect;

				m_Handel = (HANDLE)::CreateThread(NULL,0,threadpro,&sockPam,0,&nThreadId);
				CloseHandle(m_Handel);
			}

			++g_Connect;
		}
	}

	WSACleanup();
}

二、客户端：MyClient.cpp

// MyClient.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>

using namespace std;

#include<stdlib.h>
#include<stdio.h>
#include"winsock2.h"
#include<time.h>
#pragma comment(lib,"ws2_32.lib")

void main()
{
	WSADATA wsd;//定义WSADATA对象
	WSAStartup(MAKEWORD(2,2),&wsd);
	SOCKET m_SockClient;
	sockaddr_in clientaddr;

	clientaddr.sin_family = AF_INET;	//设置服务器地址
	clientaddr.sin_port = htons(4600);  //设置服务器端口号
	clientaddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
	m_SockClient = socket(AF_INET,SOCK_STREAM,0);
	
	if (m_SockClient == INVALID_SOCKET)
	{
		printf("Sock 初始化失败: %d\n", WSAGetLastError());
		WSACleanup();
		return ;
	}
	// 获取发送缓冲区和接送缓冲区大小
	{
		int optlen = 0;
		int optval = 0;

		optlen = sizeof(optval);
		getsockopt(m_SockClient, SOL_SOCKET, SO_SNDBUF, (char*)&optval, &optlen);
		printf("send buf len is %d\n",optval);           //64位 默认发送缓冲区64k
		getsockopt(m_SockClient, SOL_SOCKET, SO_RCVBUF, (char*)&optval, &optlen);
		printf("Recv buf len is %d\n",optval);          //64位 默认接收缓冲区64k
	}
	
	// 设定接收缓冲区大小
	int nRecvBufLen = 1024* 1024; //默认设置为1024K
	int nStaus = setsockopt(pSocketData->clientSocket,SOL_SOCKET,SO_RCVBUF,(const char*)&nRecvBufLen,sizeof(int));
	if (nStaus == SOCKET_ERROR)
	{
		hcDebugLog(_T("ZLY:设定接收缓冲区大小失败！"));
	}

	// 设定发送缓冲区大小
	int nSendBufLen = 1024* 1024; //默认设置为1024K
	nStaus = setsockopt(pSocketData->clientSocket,SOL_SOCKET,SO_SNDBUF,(const 		char*)&nSendBufLen,sizeof(int));
	if (nStaus == SOCKET_ERROR)
	{
		hcDebugLog(_T("ZLY:设定发送缓冲区大小失败！"));
	}
    
	int nSuccess = connect(m_SockClient,(sockaddr*)&clientaddr,sizeof(clientaddr));//连接超时
	if (nSuccess == 0)
	{
		cout<<"连接服务器成功!"<<endl;
	}
	else
	{
		cout<<"连接服务器失败!"<<endl;
		return;
	}

	char buffer[1024];
	char inBuf[1024];
	int num = 0;
	num = recv(m_SockClient,buffer,1024,0);//阻塞
	if(num > 0)
	{
		cout << /*"Receive from server:"<<*/ buffer<<endl;

		char* pResult = strstr(buffer, "超限");
		if (pResult != NULL)
		{
			cout<<"服务器连接个数超限，不可用！"<<endl;
			system("pause"); 
			return;
		}
		
		//传递文件名称
		char filename[256];

		FILE* m_fp;
		errno_t err = fopen_s(&m_fp, filename, "rb");
		if (err != 0)
		{
			strlog.Format(_T("文件“%s”打开失败，错误码：0x%X"), filename, GetLastError());
			return -1;
		}
		
		// 读取文件名称发送
		if (sizeof(filename) != send(m_sock, &filename, sizeof(filename), 0))
		{
			strLog.Format(_T("文件“%s”发送文件名称失败，错误码：%d。"), (LPCTSTR)CString(m_fn.Fname), WSAGetLastError());
			cout << strLog <<endl;
			fclose(m_fp);
			m_fp = NULL;
			return -1;
		}
		fseek(m_fp, 0, SEEK_END);
		long long nSize = ftell(m_fp);
		fseek(m_fp, 0, SEEK_SET);
		
		// 获取文件长度，发送文件长度(废弃)
		if (sizeof(nSize) != send(m_sock, (char*)&nSize, sizeof(nSize), 0))
		{
			printf(_T("发送文件长度失败，错误码：%d。"), WSAGetLastError());
			fclose(m_fp);
			m_fp = NULL;
			return -1;
		}
		
		//发送文件
		/* 循环发送多个文件貌似会出错
		HANDLE hFile = 	CreateFile(lpszFilePath,GENERIC_READ,FILE_SHARE_READ,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
		TransmitFile(m_Socket,hFile,0,TRANS_FILE_LENGTH,NULL,NULL,TF_DISCONNECT);
		CloseHandle(hFile);
		*/

		// 循环发送文件
		size_t nNum;
		while (1)
		{
			nNum = fread(m_temp, 1, 1024*500, m_fp);
			if (nNum == 0)
				break;

			if (nNum != send(m_sock, m_temp, (int)nNum, 0))
			{
				strLog.Format(_T("文件“%s”发送文件数据失败，错误码:%d。"), (LPCTSTR)CString(m_fn.Fname), WSAGetLastError());
				fclose(m_fp);
				m_fp = NULL;
				return -1;
			}

			memset(m_temp, 0, sizeof(char)*1024*500);
		}

		// 关闭文件
		fclose(m_fp);
		m_fp = NULL;
		
		//接收服务端端反馈的数据
		int recv_len = recv(m_SockClient,buffer,1024,0);
		if(recv_len>=0)
		{
			cout<< buffer <<endl;
		}
	}
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

欧特克_Glodon

很高兴能帮助到您！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值