socket编程(struct报头)网络编程

目录

• 一：socket编程
  • • 1.简介
    • 2.参数说明：
    • 3.socket套接字方法
    • 4.socket编程思路：
• 二：socket套接字编程
  • • 1.socket简易版编程
    • 2.通信循环
• 三：通信循环及代码优化
  • • 四：粘包现象
    • 1.什么是粘包？
    • 2.为什么会有粘包与半包?
    • 3.如何解决粘包以及半包问题?
    • 4.报头
    • 5.TCP特性
    • 5.为什么会发生粘包和拆包的TCP反而被称为可靠的连接与传输?
• 五：struct模块
  • • 1.struct用法
    • 2.简易版本报头
• 六：防优酷项目(视频传输)

一：socket编程

1.简介

socket是基于C/S架构的，也就是说进行socket网络编程，通常需要编写两个py文件，一个服务端，一个客户端。

首先，导入Python中的socket模块： import socket

这张逻辑图，是整个socket编程中的重点的重点，你必须将它理解、吃透，然后刻在脑海里，真正成为自己记忆的一部分！

在Python中，import socket后，用socket.socket()方法来创建套接字，语法格式如下：

sk = socket.socket([family[, type[, proto]]])

2.参数说明：

• family: 套接字家族，可以使AF_UNIX或者AF_INET。
• type: 套接字类型，根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM，也就是TCP和UDP的区别。
• protocol: 一般不填默认为0。

直接socket.socket()，则全部使用默认值。

• 下面是具体的参数定义：

socket类型	描述
socket.AF_UNIX	只能够用于单一的Unix系统进程间通信
socket.AF_INET	IPv4
socket.AF_INET6	IPv6
socket.SOCK_STREAM	流式socket , for TCP
socket.SOCK_DGRAM	数据报式socket , for UDP
socket.SOCK_RAW	原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
socket.SOCK_SEQPACKET	可靠的连续数据包服务
创建TCP Socket：	s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
创建UDP Socket：	s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

3.socket套接字方法

通过`s = socket.socket()`方法，我们可以获得一个socket对象s，也就是通常说的获取了一个“套接字”，该对象具有一下方法：

方法	描述
服务器端方法
s.bind()	绑定地址（host,port）到套接字，在AF_INET下,以元组（host,port）的形式表示地址。
s.listen(backlog)	开始监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
s.accept()	被动接受客户端连接,(阻塞式)等待连接的到来，并返回（conn,address）二元元组,其中conn是一个通信对象，可以用来接收和发送数据。address是连接客户端的地址。
客户端方法
s.connect(address)	客户端向服务端发起连接。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。
s.connect_ex()	connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共方法
s.recv(bufsize)	接收数据，数据以bytes类型返回，bufsize指定要接收的最大数据量。
s.send()	发送数据。返回值是要发送的字节数量。
s.sendall()	完整发送数据。将数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.recvform()	接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收的数据，address是发送数据的套接字地址。
s.sendto(data,address)	发送UDP数据，将数据data发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close()	关闭套接字，必须执行。
s.getpeername()	返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname()	返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value)	设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])	返回套接字选项的值。
s.settimeout(timeout)	设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout()	返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno()	返回套接字的文件描述符。
s.setblocking(flag)	如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile()	创建一个与该套接字相关连的文件

• 注意事项

1. Python3以后，socket传递的都是**bytes类型**的数据，字符串需要先转换一下，`string.encode()`即可；另一端接收到的bytes数据想转换成字符串，只要`bytes.decode()`一下就可以。
2. 在正常通信时，`accept()`和`recv()`方法都是阻塞的。所谓的阻塞，指的是程序会暂停在那，一直等到有数据过来。

4.socket编程思路：

• 服务端：

1. 创建套接字，绑定套接字到本地IP与端口：socket.socket(socket.AF_INET,socket.SOCK_STREAM) ,
2. s.bind()
3. 开始监听连接：s.listen()
4. 进入循环，不断接受客户端的连接请求：s.accept()
5. 接收传来的数据，或者发送数据给对方：s.recv() , s.sendall()
6. 传输完毕后，关闭套接字：s.close()

• 客户端

1. 创建套接字，连接服务器地址：socket.socket(socket.AF_INET,socket.SOCK_STREAM) ,
2. s.connect()
3. 连接后发送数据和接收数据：s.sendall(), s.recv()
4. 传输完毕后，关闭套接字：s.close()
   

二：socket套接字编程

• socket编程

# 只要涉及到远程数据交互必须要操作OSI七层 所以有现成的模块直接实现
socket模块
架构启动肯定是先启动服务端再启动客户端

1.socket简易版编程

• 服务端

import socket
"""
导入模块的两种方式
    import句式
    from...import...句式
第三方模块下载
    pip3 install 模块名==版本号 -i 仓库地址
"""
server = socket.socket()  # 默认就是基于网络的TCP传输协议   买手机
server.bind(('127.0.0.1', 8080))  # 绑定ip和port         插电话卡
server.listen(5)  # 半连接池            开机(过渡)
sock, address = server.accept()  # 监听   三次握手的listen态
print(address)  # 客户端地址
data = sock.recv(1024)  # 接收客户端发送的消息  听别人说话
print(data)
sock.send(b'hello my big baby~~~')  # 给别人回话
sock.close()  # 挂电话
server.close()  # 关机

• 客户端

import socket
client = socket.socket()  # 买手机
client.connect(('127.0.0.1', 8080))  # 拨号
# 说话
client.send(b'hello big DSB DSB DSB!')
# 听他说
data = client.recv(1024)
print(data)
client.close()

2.通信循环

• 服务端

import socket
from socket import SOL_SOCKET, SO_REUSEADDR

# 套字节
server = socket.socket()  # 默认基于TCP网络传输协议
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 在bind前加
# 绑定地址到套字节，在inet下，以元组的形式表示地址
server.bind(('192.168.11.120', 8080))  # 绑定ip与port
# 开始 5指定连接之前，操作系统可以挂起的最大连接数量。该值最少为1
server.listen(5)

# 被动接收客户端的连接，并返回(sock, address) sock是通信对象，可以用来接收数据与发送数据
# address是连接客户端地址
sock, address = server.accept()  # 监听  三次握手
# 客户端地址
print(address)
while True:
    try:
        # 接收数据，1024指定要接收的最大数据量，
        data = sock.recv(1024)   # 接收客户端发送的信息
        # 接收数据   解码
        print(data.decode('utf8'))
        # 发送数据，返回值是要发送的字节数量
        sock.send(data + b'123')
    except ConnectionResetError as e:
        print(e)
        break

• 客户端

import socket

# 套字节
client = socket.socket() # 默认就是基于TCP传输协议
# 客户端向服务端发起连接 如果出错报socket.error
client.connect(('192.168.11.120', 8080))

while True:
    msg = input('请输入：').strip()
    if len(msg) == 0:
        continue
    # 发送数据,将输入数据 编码
    client.send(msg.encode('utf8'))
    # 接收数据，数据要以bytes类型返回，1024指要接收的最大数据量
    data = client.recv(1024)
    # 打印接收数据
    print(data.decode('utf8'))

三：通信循环及代码优化

• 1.客户端校验消息不能为空
• 2.服务端添加兼容性代码(mac linux)
• 3.服务端重启频繁报端口占用错误

from socket import SOL_SOCKET, SO_REUSEADDR

server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 在bind前加

• 4.客户端异常关闭服务端报错的问题

异常捕获
        try:
        # 接收数据，1024指定要接收的最大数据量，
        data = sock.recv(1024)   # 接收客户端发送的信息
        # 接收数据   解码
        print(data.decode('utf8'))
        # 发送数据，返回值是要发送的字节数量
        sock.send(data + b'123')
    except ConnectionResetError as e:

• 5.服务端链接循环
• 6.半连接池

设置可以等待的客户端数量
    server.listen(5)

• 7.允许同一个文件执行多次

Allow parallel run

四：粘包现象

1.什么是粘包？

• 粘包：顾名思义，就是原本属于两个包的消息被合并在一起了

• 半包：字面意思，原本是一个包内的消息被拆分成为两个包

2.为什么会有粘包与半包?

出现粘包和半包的首要原因就是TCP是以数据流在网络当中传输的，而“流”是没有明显的收尾区别的，因此在接收的时候也无法区分哪里是数据包的头哪里是尾。

• 粘包产生的两种原因：
• 1.每次发送方发送的数据小于socket缓冲区的大小，频繁的发送会被TCP优化算法合并成一个包
• 2.接收端接收不及时，使得下一次接收到的包还是上一次遗留的
• 半包产生的两种原因:
• 1.发送方发送的数据大于socket缓冲区的大小
• 2.发送的数据大于协议的 MTU (Maximum Transmission Unit，最大传输单元)，因此必须拆包。

3.如何解决粘包以及半包问题?

• 1.告诉接收方包的“头尾”

既然粘包和半包的根本原因是接收方不知道发送的数据流的收尾，那么在发送的时候告诉接收方的发送方数据的大小就可以解决。具体做法就是在发送的TCP包前面再封装一层，就是加上数据包的长度data=str(len(data))+data,但是这样做的缺点就是编码成本较大，会增加程序的运行时间。

• 2.固定缓冲区的大小

发送方每次将不足缓冲区大小的数据包使用空字符填充，接收方每次接受也只接受固定长度的包长。这样做虽然可以解决粘包的问题，但是对于拆包的问题却不能很好的解决，同时会对网络产生额外的开销。

• 3.特殊字符结尾

在每个数据包的结尾加上特殊的字符，例如\n\n\t\t，这样接收方每次提取到这几个特殊的字符都会认为是一个完整的包结束了。可以解决粘包问题，同时对于半包(拆包)问题，也可以得到很好的解决。

4.报头

能够标识即将到来的数据具体信息
    eg:数据量多大
报头的长度必须是固定的
    struct模块

5.TCP特性

当数据量比较小 且时间间隔比较短的多次数据
	那么TCP会自动打包成一个数据包发送

5.为什么会发生粘包和拆包的TCP反而被称为可靠的连接与传输?

TCP的“可靠”是体现在它是面向连接的传输；以及它在传输前的三次握手，传输结束之后的四次挥手。并且TCP传输是不会丢包的。

五：struct模块

该模块可以把一个类型，如数字，转换成固定的长度的bytes
struct.pack('i', 11111111111111)

1.struct用法

import struct
import json


d = {
    'file_name': '很好看.mv',
    'file_size': 1231283912839123123424234234234234234324324912,
    'file_desc': '拍摄的很有心 真的很好看!!!',
    'file_desc2': '拍摄的很有心 真的很好看!!!'
}
# 字典转换成json格式
d = json.dumps(d)
 # struct将数组转换成(打包)固定长度的bytes
res = struct.pack('i',len(d))
print(len(res))		# 4
# 解包
res1 = struct.unpack('i',res)[0]
print(res1)			# 274

2.简易版本报头

• 服务器

import socket
import subprocess
import json
import struct



#  套字节
server = socket.socket()  # TCP网络传输协议

# 绑定ip与port
server.bind(('192.168.11.120', 8080))

# 开始 操作系统可以挂起的最大连接数，连接池
server.listen(5)

# 监控开始
while True:
    # 被动接收客户端连接，并返回(sock, address)
    # sock是通信对象，可以接收数据与发送数据
    # accept是连接客户端地址
    sock, address = server.accept()
    while True:
        # 接收数据cmd命令
        data = sock.recv(1024)
        # 解码二进制
        command_cmd = data.decode('utf8')
        # subprocess.Popen用来创建子进程，并连接它们的输入
        sub = subprocess.Popen(command_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        # 输出和错误管道，获取它们的返回状态。
        res = sub.stdout.read() + sub.stderr.read()
        # 1.制作报头
        data_first = struct.pack('i', len(res))
        # 2.发送报头
        sock.send(data_first)
        # 3.发送真实数据
        sock.send(res)

• 客户端

import socket
import struct

# 套字节
client = socket.socket()

# 客户端向服务端发起连接，如果出错则报socket.error
client.connect(('192.168.11.120', 8080))

while True:
    msg = input('请输入cmd命令:').strip()
    # 判断输入为空，重新输入
    if len(msg) == 0:
        continue
    # 将数据编码betsy
    client.send(msg.encode('utf8'))
    # 1.先接收固定长度为4的报头数据
    recv_first = client.recv(4)
    # 2.解析报头
    real_length = struct.unpack('i', recv_first)[0]
    # 3.接收真实数据
    real_data = client.recv(real_length)
    # 将数据转换成gbk
    print(real_data.decode('gbk'))

六：防优酷项目(视频传输)

• 客户端

import json
import socket
import struct
import os

client = socket.socket()  # 买手机
client.connect(('127.0.0.1', 8080))  # 拨号

while True:
    data_path = r'D:\金牌班级相关资料\网络并发day01\视频'
    # print(os.listdir(data_path))  # [文件名称1 文件名称2 ]
    movie_name_list = os.listdir(data_path)
    for i, j in enumerate(movie_name_list, 1):
        print(i, j)
    choice = input('请选择您想要上传的电影编号>>>:').strip()
    if choice.isdigit():
        choice = int(choice)
        if choice in range(1, len(movie_name_list) + 1):
            # 获取文件名称
            movie_name = movie_name_list[choice - 1]
            # 拼接文件绝对路径
            movie_path = os.path.join(data_path, movie_name)
            # 1.定义一个字典数据
            data_dict = {
                'file_name': 'XXX老师合集.mp4',
                'desc': '这是非常重要的数据',
                'size': os.path.getsize(movie_path),
                'info': '下午挺困的，可以提神醒脑'
            }
            data_json = json.dumps(data_dict)
            # 2.制作字典报头
            data_first = struct.pack('i', len(data_json))
            # 3.发送字典报头
            client.send(data_first)
            # 4.发送字典
            client.send(data_json.encode('utf8'))
            # 5.发送真实数据
            with open(movie_path,'rb') as f:
                for line in f:
                    client.send(line)

• 服务端

import socket
import json
import struct


server = socket.socket()

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

server.listen(5)

while True:
    # 被动客户端连接 并返回(sock,address)
    # sock用于通信  用于接收 发送数据
    # address用于客户端地址
    sock, address = server.accept()
    while True:
        # 1.线接收固定长度为4的字典报头数据
        recv_first = sock.recv(4)
        # 2.解析报头
        dict_length = struct.unpack('i', recv_first)[0]
        # 3.接收字典数据
        real_data = sock.recv(dict_length)
        # 4.解析字典(json格式的bytes数据 loads方法会自动先解码 后反序列化)
        real_dict = json.loads(real_data)
        # 5.获取视频数据大小
        data_length = real_dict.get('size')
        # 6.接收视频名称
        file_name = real_dict.get('file_name')

        # 定义
        recv_size = 0
        # 打开文件
        with open(file_name, 'wb') as f:
            # 循环判断 0 是否小于 视频数据大小 (如果0等于 视频数据时 则代表传输完)
            with recv_size < data_length:
                # 每次接收客户端数据为1024
                data = sock.recv(1024)
                # 零 加上 每次传输的 视频数据长度
                recv_size += len(data)
                # 写入视频文件
                f.write(data)