路飞学城Python-Day24

12.粘包现象

客户端接收的信息指定了的字节，TCP协议没有丢失协议，只是只能接收指定的字节数，于是产生出了粘包现象

服务端接收命令只能接收1024字节，服务端执行命令结果以后传输给客户端，客户端再以1024个字节接收，但是如果结果超过1024个字节以后也不能再接收了，导致结果不可控了，没有接收的信息就会形成数据残留留到传输管道里，新的数据再发送的时候才会把老的数据发送过来，这样数据的传输会越来越不准确，这就是粘包的现象

粘包现象：多个包的数据粘到一起了，在管道里根本不区分数据，流式数据传输的特性，所有数据全部传到一起不做任何区分

服务端

import socket

import subprocess

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

print('starting')

while True:

conn, client_addr = phone.accept()

print(client_addr)

while True:

try:

# 收到命令

cmd = conn.recv(1024)

if not cmd:break

print('客户端接收的数据', cmd)

# 执行收到命令，拿到结果

f = subprocess.Popen(cmd.decode('gbk'), shell=True,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

)

stdout = f.stdout.read()

stderr = f.stderr.read()

conn.send(stdout+stderr)

# 把命令结果返回

except ConnectionRefusedError:

break

conn.close()

phone.close()

客户端

import socket

 

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.connect(('127.0.0.1', 8080))

while True:

# 发命令

cmd = input('>>>').strip()

if not cmd: continue

phone.send(cmd.encode('utf-8'))

# 拿到命令结果并打印

data = phone.recv(1024)

print(data.decode('gbk'))

phone.close()

---

13.粘包底层原理分析

运行一个程序（软件）和什么硬件有关？

硬盘>>内存>>Cpu

send和recv的实现原理

站在客户端的角度讲，执行一次send的操作是应用程序的代码，想要将自己的数据发出去，但是应用程序不能执行直接发送，需要给自己的操作系统转交发送，但是客户端的内存和服务端的内存是相互隔离的，操作系统遵循tcp协议之后，通过接收到的数据发送，send只是拷贝给自己的操作系统的内存，send对于应用程序来说不过是完成了给内存的传输

数据接收，recv实际分为两个过程，1.数据接收，放到服务端的缓存中 2.从缓存中调取数据，解析发给应用程序

粘包发生的原因：数据量比较小，而且发送时间短

粘包是tcp的底层的优化算法决定的，但是解决粘包的关键就是需要指定发送文件的长度就可以了

服务端（粘包）

import socket

 

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.bind(('127.0.0.1', 8080))

server.listen(5)

conn, addr = server.accept()

data = conn.recv(1024)

print(data)

data1 = conn.recv(1024)

print(data1)

客户端

import socket

 

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

client.connect(('127.0.0.1', 8080))

client.send('hello'.encode('utf-8'))

client.send('world'.encode('utf-8'))

---

14.解决粘包问题-伪代码实现

解决粘包问题的就是告诉发送方，需要发送的数据大小

服务端

import socket

import subprocess

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

print('starting')

while True:

conn, client_addr = phone.accept()

print(client_addr)

while True:

try:

# 收到命令

cmd = conn.recv(1024)

if not cmd:break

print('客户端接收的数据', cmd)

# 执行收到命令，拿到结果

f = subprocess.Popen(cmd.decode('gbk'), shell=True,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

)

stdout = f.stdout.read()

stderr = f.stderr.read()

# 1.把报头（固定长度）数据的长度发送给客户端

total_size = len(stdout+stderr)

conn.send(str(total_size).encode('gbk'))

# 2.再发送真实的数据

 

conn.send(stdout)

conn.send(stderr)

# 把命令结果返回

except ConnectionRefusedError:

break

conn.close()

phone.close()

客户端

import socket

 

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.connect(('127.0.0.1', 8080))

while True:

# 发命令

cmd = input('>>>').strip()

if not cmd: continue

phone.send(cmd.encode('utf-8'))

# 第一步拿到数据长度

total_size = 1000000

# 第二步接收真实的数据

recv_size = 0

recv_data = b''

while recv_size<total_size:

res = phone.recv(1024)

recv_data += res

recv_size += len(res)

 

print(recv_data.decode('gbk'))

phone.close()

---

15.解决粘包问题-简单版本

使用struck模块打包数据报头

服务端

import socket

import subprocess

import struct

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

print('starting')

while True:

conn, client_addr = phone.accept()

print(client_addr)

while True:

try:

# 收到命令

cmd = conn.recv(1024)

if not cmd:break

print('客户端接收的数据', cmd)

# 执行收到命令，拿到结果

f = subprocess.Popen(cmd.decode('gbk'), shell=True,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

)

stdout = f.stdout.read()

stderr = f.stderr.read()

# 1.把报头（固定长度）数据的长度发送给客户端

 

total_size = len(stdout+stderr)

header = struct.pack('i', total_size)

conn.send(header)

conn.send(str(total_size).encode('gbk'))

# 2.再发送真实的数据

 

conn.send(stdout)

conn.send(stderr)

# 把命令结果返回

except ConnectionRefusedError:

break

conn.close()

phone.close()

客户端

import socket

import struct

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.connect(('127.0.0.1', 8080))

while True:

# 发命令

cmd = input('>>>').strip()

if not cmd: continue

phone.send(cmd.encode('utf-8'))

# 第一步拿到数据长度

total_size = struct.unpack('i', phone.recv(4))[0]

# 第二步接收真实的数据

recv_size = 0

recv_data = b''

while recv_size<total_size:

res = phone.recv(1024)

recv_data += res

recv_size += len(res)

print(recv_data.decode('gbk'))

phone.close()

---

16.解决粘包问题-终极版本

基于struck的打包会超过它的打包的长度，struck的模块有两种类型，i模式和l模式，对于大文件都有可能不够使用

import struct

res = struct.pack('i',12879999777)

print(res,type(res),len(res))

res1 = struct.unpack('i',res)

print(res1)

客户端

import socket

import struct

import json

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.connect(('127.0.0.1', 8080))

while True:

# 发命令

cmd = input('>>>').strip()

if not cmd: continue

phone.send(cmd.encode('utf-8'))

# 第一步拿到数据长度

header_size = struct.unpack('i', phone.recv(4))[0]

# 接收报头内容

header_bytes = phone.recv(header_size)

# 从报头中解析真实数据的信息

header_json = header_bytes.decode('gbk')

header_dict = json.loads(header_json)

print(header_dict)

 

# 第二步接收真实的数据

total_size = header_dict['total_size']

recv_size = 0

recv_data = b''

while recv_size< total_size:

res = phone.recv(1024)

recv_data += res

recv_size += len(res)

print(recv_data.decode('gbk'))

phone.close()

服务端

import socket

import subprocess

import struct

import json

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

print('starting')

while True:

conn, client_addr = phone.accept()

print(client_addr)

while True:

try:

# 收到命令

cmd = conn.recv(1024)

if not cmd:break

print('客户端接收的数据', cmd)

# 执行收到命令，拿到结果

f = subprocess.Popen(cmd.decode('gbk'), shell=True,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

)

stdout = f.stdout.read()

stderr = f.stderr.read()

# 1.制作固定长度的报头

header_dic = {

'filename': 'a.txt',

'md5':'xxxxxxdxxx',

'total_size': len(stdout)+len(stderr)

}

header_json = json.dumps(header_dic)

header_bytes = header_json.encode('gbk')

# 发送报头的长度

conn.send(struct.pack('i',len(header_bytes)))

# 再发报头

conn.send(header_bytes)

# 2.再发送真实的数据

total_size = len(stdout + stderr)

header = struct.pack('i', total_size)

conn.send(header)

conn.send(str(total_size).encode('gbk'))

conn.send(stdout)

conn.send(stderr)

# 把命令结果返回

except ConnectionRefusedError:

break

conn.close()

phone.close()

---

17.文件传输功能实现

什么是文件上传下载功能呢？如何实现呢？

首先是客户端提交命令，指定下载的文件名，是软件级别自己的定义的命令

---

18.文件传输功能-函数版

客户端

import socket

import struct

import json

 

download_dir=r'/Users/linhaifeng/PycharmProjects/网络编程/05_文件传输/优化版本/client/download'

 

def get(phone,cmds):

# 2、以写的方式打开一个新文件，接收服务端发来的文件的内容写入客户的新文件

# 第一步：先收报头的长度

obj = phone.recv(4)

header_size = struct.unpack('i', obj)[0]

 

# 第二步：再收报头

header_bytes = phone.recv(header_size)

 

# 第三步：从报头中解析出对真实数据的描述信息

header_json = header_bytes.decode('utf-8')

header_dic = json.loads(header_json)

'''

header_dic={

'filename': filename, #'filename':'1.mp4'

'md5':'xxdxxx',

'file_size': os.path.getsize(filename)

}

'''

print(header_dic)

total_size = header_dic['file_size']

filename = header_dic['filename']

 

# 第四步：接收真实的数据

with open('%s/%s' % (download_dir, filename), 'wb') as f:

recv_size = 0

while recv_size < total_size:

line = phone.recv(1024) # 1024是一个坑

f.write(line)

recv_size += len(line)

print('总大小：%s 已下载大小：%s' % (total_size, recv_size))

 

def put(phone,cmds):

pass

 

def run():

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

 

phone.connect(('127.0.0.1',8912))

 

while True:

#1、发命令

inp=input('>>: ').strip() #get a.txt

if not inp:continue

phone.send(inp.encode('utf-8'))

 

cmds=inp.split() #['get','a.txt']

if cmds[0] == 'get':

get(phone,cmds)

elif cmds[0] == 'put':

put(phone,cmds)

 

phone.close()

 

 

 

if __name__ == '__main__':

run()

服务端

import socket

import subprocess

import struct

import json

import os

 

share_dir=r'/Users/linhaifeng/PycharmProjects/网络编程/05_文件传输/优化版本/server/share'

 

def get(conn,cmds):

filename = cmds[1]

 

# 3、以读的方式打开文件,读取文件内容发送给客户端

# 第一步：制作固定长度的报头

header_dic = {

'filename': filename, # 'filename':'1.mp4'

'md5': 'xxdxxx',

'file_size': os.path.getsize(r'%s/%s' % (share_dir, filename))

# os.path.getsize(r'/Users/linhaifeng/PycharmProjects/网络编程/05_文件传输/server/share/1.mp4')

}

 

header_json = json.dumps(header_dic)

 

header_bytes = header_json.encode('utf-8')

 

# 第二步：先发送报头的长度

conn.send(struct.pack('i', len(header_bytes)))

 

# 第三步：再发报头

conn.send(header_bytes)

 

# 第四步：再发送真实的数据

with open('%s/%s' % (share_dir, filename), 'rb') as f:

# conn.send(f.read())

for line in f:

conn.send(line)

 

def put(conn,cmds):

pass

 

def run():

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind(('127.0.0.1',8912)) #0-65535:0-1024给操作系统使用

phone.listen(5)

 

print('starting...')

while True: # 链接循环

conn,client_addr=phone.accept()

print(client_addr)

 

while True: #通信循环

try:

#1、收命令

res=conn.recv(8096) # b'put 1.mp4'

if not res:break #适用于linux操作系统

 

#2、解析命令，提取相应命令参数

cmds=res.decode('utf-8').split() #['put','1.mp4']

if cmds[0] == 'get':

get(conn,cmds)

elif cmds[0] == 'put':

input(conn,cmds)

 

 

except ConnectionResetError: #适用于windows操作系统

break

conn.close()

 

phone.close()

 

 

if __name__ == '__main__':

run()

---

19.文件传输功能-面向对象版

 

---

20.基于udp协议的套接字介绍

UDP协议不会粘包

客户端

from socket import *

 

client = socket(AF_INET, SOCK_DGRAM)

 

 

while True:

msg=input('>>: ').strip()

client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))

 

data,server_addr=client.recvfrom(1024)

print(data,server_addr)

client.close()

服务端

from socket import *

 

server=socket(AF_INET,SOCK_DGRAM)

server.bind(('127.0.0.1',8080))

 

 

while True:

data,client_addr=server.recvfrom(1024)

print(data)

 

server.sendto(data.upper(),client_addr)

 

server.close()