socket通信实现文件的传输，TCP传输方式，python版与C/C++版。

python版

服务器端代码

TCPserver.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
# -*- coding:utf-8 -*-
import socket
import os
import threading

# 获取本机ip
def get_host_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(('8.8.8.8', 80))
        ip = s.getsockname()[0]
    finally:
        s.close()

    return ip

# 处理客户端请求下载文件的操作（从主线程提出来的代码）
def deal_client_request(ip_port, service_client_socket):
    # 连接成功后，输出“客户端连接成功”和客户端的ip和端口
    print("客户端连接成功", ip_port)
    # 接收客户端的请求信息【recv】
    file_name = service_client_socket.recv(1024)
    # 解码
    file_name_data = file_name.decode("utf-8")
    # 判断文件是否存在
    if os.path.exists(file_name_data):
        #输出文件字节数
        fsize = os.path.getsize(file_name_data)
        #转化为兆单位
        fmb = fsize/float(1024*1024)
        #要传输的文件信息
        senddata = "文件名：%s  文件大小：%.2fMB"%(file_name_data,fmb)
        #发送和打印文件信息【send】
        service_client_socket.send(senddata.encode("utf-8"))
        print("请求文件名：%s  文件大小：%.2f MB"%(file_name_data,fmb))
        #接受客户是否需要下载【recv】
        options = service_client_socket.recv(1024)
        if options.decode("utf-8") == "y":
            # 打开文件
            with open(file_name_data, "rb") as f:
                #　计算总数据包数目
                nums = fsize/1024
                #　当前传输的数据包数目
                cnum = 0

                while True:
                    file_data = f.read(1024)
                    cnum = cnum + 1
                    #progress = cnum/nums*100

                    #print("当前已下载：%.2f%%"%progress,end = "\r")
                    if file_data:
                        # 只要读取到数据，就向客户端进行发送【send】
                        service_client_socket.send(file_data)
                    # 数据读完，退出循环
                    else:
                        print("请求的文件数据发送完成")
                        break
        else:
            print("下载取消！")
    else:
        print("下载的文件不存在！")
    # 关闭服务当前客户端的套接字【close】
    service_client_socket.close()


if __name__ == '__main__':
    # 获取本机ip
    print("TCP文件传输服务器，本机IP:" + get_host_ip())
    
    # 把工作目录切换到data目录下
    os.chdir("./data")
    # 创建套接字【socket】
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定端口号【bind】
    tcp_server_socket.bind(("", 3356))
    # 设置监听，将主动套接字变为被动套接字【listen】
    tcp_server_socket.listen(128)

    # 循环调用【accept】，可以支持多个客户端同时连接，和多个客户端同时下载文件
    while True:
        service_client_socket, ip_port = tcp_server_socket.accept()
        # 连接成功后打印套接字号
        #print(id(service_client_socket))

        # 创建子线程
        sub_thread = threading.Thread(target=deal_client_request, args=(ip_port, service_client_socket))
        # 启动子线程
        sub_thread.start()

客户端代码

TCPclient.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# -*- coding:utf-8 -*-
# 多任务文件下载器客户端
import socket
import os

if __name__ == '__main__':
    # 创建套接字【socket】
    tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 和服务端连接【connect】
    server_ip = input("输入服务器IP：")
    tcp_client_socket.connect((server_ip, 3356))
    # 发送下载文件的请求
    file_name = input("请输入要下载的文件名：")
    # 编码
    file_name_data = file_name.encode("utf-8")
    # 发送文件下载请求数据【send】
    tcp_client_socket.send(file_name_data)
    # 接收要下载的文件信息【recv】
    file_info = tcp_client_socket.recv(1024)
    # 文件信息解码
    info_decode = file_info.decode("utf-8")
    print(info_decode)
    #获取文件大小
    fileszie = float(info_decode.split('：')[2].split('MB')[0])
    fileszie2 = fileszie*1024
    # 是否下载？输入ｙ　确认　输入ｑ 取消
    opts = input("是否下载？(y 确认　q 取消)")
    if opts == 'q':
        print("下载取消！程序退出")
    else:
        print("正在下载　>>>>>>")
        #向服务器确认正在下载【send】
        tcp_client_socket.send(b'y')

        recvpath = "./receive/"
        if not os.path.exists(recvpath):
            os.mkdir(recvpath) 
        
        # 把数据写入到文件里
        with open(recvpath + file_name, "wb") as file:
            #目前接收到的数据包数目
            cnum = 0

            while True:
                # 循环接收文件数据【recv】
                file_data = tcp_client_socket.recv(1024)
                # 接收到数据
                if file_data:
                    # 写入数据
                    file.write(file_data)
                    cnum = cnum+1
                    #progress =cnum/fileszie2*100
                    #print("当前已下载：%.2f%%"%progress,end = "\r")
                # 接收完成
                else:
                    print("下载结束！")
                    break
    # 关闭套接字【close】
    tcp_client_socket.close()

上述程序修改搬运自：Python3使用TCP编写一个简易的文件下载器–Linux公社 ，服务器端添加了一段打印本机IP的代码，客户端添加了一段新建receive文件夹保存接收文件的代码。

程序在Windows和Linux系统上均可运行，测试时需要在服务器程序所在路径新建一个data文件夹并放入用于测试的文件，如图片、视频文件等。

另外，此程序在传输较小的文件(如几KB)时，程序中计算进度的语句会出现除数为0的错误，需要屏蔽传输进度相关语句或作某些修改。另一方面，进度的显示也比较耗时，去掉进度显示可以减小文件传输时间。

测试结果

服务器端(Ubuntu18.04)：

1
2
3
4
5
D...@deeplearning:~/.../TCPsocketTest$ python3 TCPserver.py 
TCP文件传输服务器，本机IP:192.168.1.143
客户端连接成功 ('192.168.1.110', 53114)
请求文件名：1.jpg  文件大小：0.04 MB
请求的文件数据发送完成

客户端(Win10)：

1
2
3
4
5
6
7
8
9
10
============= RESTART: G:\...\TCPsocketTest\TCPclient.py =============
输入服务器IP：192.168.1.143
请输入要下载的文件名：1.jpg
文件名：1.jpg  文件大小：0.04MB
是否下载？(y 确认　q 取消)y
正在下载　>>>>>>
下载结束！
>>> 

G:\TCPsocketTest>

服务器端运行在Ubuntu18.04系统，客户端运行在Win10系统，当然也可以互换运行。另外，实测win10的服务器端程序与Ubuntu10的客户端通信这种情况，win10的服务器端必须在IDLE环境中运行，在cmd命令行中运行无法连接，原因未知。

C/C++版

将python程序改写为C/C++语言，实现类似的文件传输功能，以下程序用到了winsock以及dll库，只能在Windows系统下运行。

服务器端

server.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
// 客户端发送字符串，服务器接收字符串，以相同内容返回 (循环服务)
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <winsock2.h>
#pragma comment (lib, "ws2_32.lib")  //加载 ws2_32.dll

#define BUF_SIZE 1024

int main() {
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);// 加载套接字库

	//创建套接字
	SOCKET servSock = socket(AF_INET, SOCK_STREAM, 0);//【socket】

	//绑定套接字
	sockaddr_in sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));  //每个字节都用0填充
	sockAddr.sin_family = PF_INET;  //使用IPv4地址
	//sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
	sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);//不要这一句好像也行
	sockAddr.sin_port = htons(3356);  //端口
	bind(servSock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));//【bind】

	//进入监听状态
	listen(servSock, 20);//【listen】

	//接收客户端请求
	SOCKADDR clntAddr;
	int nSize = sizeof(SOCKADDR);
	char buffer[BUF_SIZE] = { 0 };  //接收缓冲区
	char sbuffer[BUF_SIZE] = { 0 };

	// 本机IP
	char ip[20] = { 0 };
	struct hostent *phostinfo = gethostbyname("");
	char *p = inet_ntoa(*((struct in_addr *)(*phostinfo->h_addr_list)));
	strncpy(ip, p, sizeof(ip) - 1);
	ip[sizeof(ip) - 1] = '\0';
	printf("This is TCP file server(IP:%s)\n", ip);
	printf("waiting connect...\n");

	while (1)
	{
		SOCKET clntSock = accept(servSock, (SOCKADDR*)&clntAddr, &nSize);//【accept】
		// 获取客户端的IP的端口号
		struct sockaddr_in *sock = (struct sockaddr_in*)&clntAddr;
		printf("client(IP:%s, PORT:%d)connect ok\n", inet_ntoa(sock->sin_addr), ntohs(sock->sin_port));
		
		int strLen = recv(clntSock, buffer, BUF_SIZE, 0);  //接收客户端发来的数据 【recv】
		//printf("%s\n", buffer);
		// 判断文件是否存在
		FILE *pFile;
		pFile = fopen(buffer, "rb");  //获取已打开文件的指针
		if (pFile)
		{
			fseek(pFile, 0, SEEK_END);  //先用fseek将文件指针移到文件末尾
			int n = ftell(pFile);    //再用ftell获取文件内指针当前的文件位置。
			//printf("file:%s, size:%dKB\n", buffer, n/1024);
			sprintf(sbuffer,"file:%s, size:%dKB\n", buffer, n / 1024);
			send(clntSock, sbuffer, BUF_SIZE, 0);  //【send】文件大小信息
			recv(clntSock, buffer, BUF_SIZE, 0);  //【recv】
			if (*buffer == 'y')
			{
				fseek(pFile, 0, SEEK_SET);//开头
				int len;
				while (1)
				{
					if((len = fread(&sbuffer, 1, BUF_SIZE, pFile)) && len > 0)
					{
						send(clntSock, sbuffer, len, 0);  //【send】
						//printf("FILE p offset:%d\n", (int)ftell(pFile));
						//printf("%d\n", len);
					}
					else
					{
						printf("Download down!\n");
						break;
					}
				}
			}
			else
				printf("Download Canceled!\n");
		}
		else
		{
			sprintf(sbuffer, "file:%s not exist!!!\n", buffer);
			send(clntSock, sbuffer, BUF_SIZE, 0);  //【send】文件大小信息
		}


		closesocket(clntSock);  //关闭套接字
		memset(buffer, 0, BUF_SIZE);  //重置缓冲区
		memset(sbuffer, 0, BUF_SIZE);
	}

	//关闭套接字
	closesocket(servSock);

	//终止 DLL 的使用
	WSACleanup();

	return 0;
}

客户端

client.cpp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
// 客户端发送字符串，服务器接收字符串，以相同内容返回 (循环服务)
#include <stdio.h>
#include <WinSock2.h>
#include <windows.h>
#pragma comment(lib, "ws2_32.lib")  //加载 ws2_32.dll

#define BUF_SIZE 1024

int main() 
{
	//初始化DLL
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);
	
	//向服务器发起请求
	sockaddr_in sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));  //每个字节都用0填充
	sockAddr.sin_family = PF_INET;
	//sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");//服务器IP
	sockAddr.sin_port = htons(3356);

	char bufSend[BUF_SIZE] = { 0 };
	char bufRecv[BUF_SIZE] = { 0 };

	//输入服务器IP
	printf("Input server IP: ");
	gets_s(bufSend, BUF_SIZE);//此处先借用bufSend接收输入的IP地址
	sockAddr.sin_addr.s_addr = inet_addr(bufSend);

	while (1) 
	{
		//创建套接字
		SOCKET sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);//【socket】
		connect(sock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));//【connect】
		//获取用户输入的字符串并发送给服务器
		printf("Input a file name for download: ");
		gets_s(bufSend, BUF_SIZE);
		send(sock, bufSend, BUF_SIZE, 0);//【send】
		//接收服务器传回的数据
		recv(sock, bufRecv, BUF_SIZE, 0);//【recv】

		//输出接收到的数据
		printf("%s\n", bufRecv);
		if (!strstr(bufRecv, "not"))
		{
			printf("Download now?(y/n)");
			if (getchar() == 'y')
			{
				printf("Download ...\n");
				send(sock, "y", sizeof(char), 0);//【send】
				FILE *pFile;
				pFile = fopen(bufSend, "wb");  //获取已打开文件的指针
				int len;
				while ((len = recv(sock, bufRecv, BUF_SIZE, 0)) && len > 0)//【recv】
				{
					fwrite(&bufRecv, 1, len, pFile);
					//printf("receive...%d\n", (int)ftell(pFile));
					//printf("%d\n", len);
				}
				printf("Download down!\n");
				fclose(pFile);
			}
			else
				printf("Cancel download\n");
		}

		getchar();//此句是为了消除上面gets_s()或的问题

		memset(bufSend, 0, BUF_SIZE);  //重置缓冲区
		memset(bufRecv, 0, BUF_SIZE);  //重置缓冲区
		closesocket(sock);  //关闭套接字【close】
	}

	WSACleanup();  //终止使用 DLL
	return 0;
}

运行效果与python版的类似。