python之路 -- 网络编程

1.软件开发的架构

- C/S架构（需要安装应用程序使用的软件）

　　c client 客户端

　　s server 服务端

- B/S架构（可以通过浏览器使用的）

　　b broser 浏览器

　　s server 服务端

不需要额外的安装客户端了,只需要一个网址就可以访问

轻量级，使用成本低

2.tcp协议/udp协议

TCP、UDP都是传输层协议

tcp协议（传输控制协议）
　　全双工的通信协议
　　建立了专门传送数据的通道（连接），是一个长连接
　　面向流的传输
　　传输速率比udp协议慢
　　数据安全不容易丢失(是一种可靠的传输)
　　大文件算法自己拆包编号发送
　　建立连接的 三次握手
　　断开连接的 四次挥手
udp协议（用户数据报协议）
　　是面向文件的传输，
　　是一种不可靠的
　　不需要建立连接，直接传送（传输通道）
　　传输速率比tcp协议高
　　不适合大文件的传输（文件过大会报错）

3.socket

网络编程就是如何在程序中实现两台计算机的通信，而两台计算机间的通信其实就是两个进程间的通信，进程间的通信主要通过socket（套接字）来描述ip地址（主机）和端口（进程）来实现的

socket是python中的一个内置模块

socket的使用

--使用tcp协议的socket

    server端-tcp_server.py
import socket
tcp_sk = socket.socket()    #创建客户套接字
tcp_sk.bind(("127.0.0.1",8090))   #把地址，端口绑定到套接字,参数为一个元组

tcp_sk.listen() #监听链接（请求）
conn, addr = tcp_sk.accept()    #接受客户端链接
ret1 = conn.recv(1024)   #接收客户端信息，参数为这一次最多接收1024个字节
print(ret1)      #打印客户端信息
conn.send(b'hi')    #向客户端发送信息,必须传一个bytes类型
ret2 = conn.recv(1024)
print(ret2.decode("utf-8"))
conn.send(bytes('吃了',encoding="utf-8"))

conn.close()    #关闭客户端套接字
tcp_sk.close()  #关闭服务器套接字


client端-tcp_clent.py
import socket
tcp_sk = socket.socket()
tcp_sk.connect(('127.0.0.1',8090))

tcp_sk.send(b'hello')
ret = tcp_sk.recv(1024)
print(ret)
tcp_sk.send(bytes("吃了吗？",encoding='utf-8'))
ret2 = tcp_sk.recv(1024)
print(ret2.decode('utf-8'))

tcp_sk.close()

--使用udp协议的socket

    server端-udp_server.py
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(("127.0.0.1",8096))    
# 传入的IP和端口号必须是元组的形式
msg,addr = sk.recvfrom(1024)
print(msg.decode('utf-8'))
sk.sendto(b'bye',addr)
sk.close()


    client端-udp_client.py
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = ("127.0.0.1",8096)
# 传入IP_port的时候必须是元组形式
sk.sendto(b'hello',ip_port)
ret,addr = sk.recvfrom(1024)
print(ret.decode('utf-8'))

sk.close()

# udp的server不需要进行监听，也不需要建立连接
# 在启动服务之后只能被动的等待客服端发送消息过来
# 客户端发送消息的同时还需要带上地址信息
# 消息回复的时候，不仅需要发送消息，还需要把对方的地址填写上

注意事项：

--发送的消息必须是bytes类型的数据。注意编码encode，解码decode

--传入的IP地址、端口号必须以元组的形式传入，直接开的端口号一般在8000以后

--tcp协议不能发空消息，udp协议可以

--tcp协议会发生黏包现象，udp协议不会发生黏包现象

--使用tcp协议的socket必须先运行sever端，再运行client端。基于udp的socket不需要有运行的顺序

--一般先关闭client端，再关闭sever端

黏包问题及解决方案

1.为什么会出现黏包现象：

首先只有在tcp协议中才会出现黏包现象

是因为tcp协议是面向流的协议

在发送数据传输的过程中还有缓存机制来避免数据丢失

因此在连续发送小数据的时候，以及接收大小不符合的时候都容易出现黏包现象

本质还是因为我们在接收数据的时候不知道发送的数据的长短

2.解决黏包问题的方案：

在传输大量数据之前先告诉接收端要发送的数据的大小

更好的解决方案：通过struct模块来定制协议

---

 demo1，远程发送系统命令

demo1，远程发送系统命令
server端
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen()
conn,addr = sk.accept()

while True:
    cmd = input('>>>')
    if cmd == "q":
        conn.send(b"q")
        break
    conn.send(cmd.encode('gbk'))
    res = conn.recv(500)
    print(res.decode('gbk'))

conn.close()
sk.close()

client端
import socket
import subprocess

sk = socket.socket()
sk.connect(('127.0.0.1',8090))

while True:
    cmd = sk.recv(1024).decode('gbk')
    if cmd == "q":
        break
    res = subprocess.Popen(cmd,shell=True,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE)
    sk.send(res.stdout.read())
    sk.send(res.stderr.read())

sk.close()

subprocess.Popen()
作用：用于在一个新的进程中执行一个子程序

参数说明：
    stdin, stdout, stderr： 分别表示程序标准输入、输出、错误句柄。
    shell： 该参数用于标识是否使用shell作为要执行的程序，如果shell值为True，则建议将cmd参数作为一个字符串传递而不要作为一个序列传递。

 demo2,使用struct模块解决黏包问题

demo2,使用struct模块解决黏包问题
server端
import socket
import struct

sk = socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen()
conn,addr = sk.accept()

while True:
    cmd = input('>>>')
    if cmd == "q":
        conn.send(b"q")
        break
    conn.send(cmd.encode('gbk'))
    num_by = conn.recv(4)
    num = struct.unpack('i',num_by)[0]
    res = conn.recv(int(num)).decode('gbk')
    print(res)

conn.close()
sk.close()

client端
import socket
import subprocess
import struct

sk = socket.socket()
sk.connect(('127.0.0.1',8090))

while True:
    cmd = sk.recv(1024).decode('gbk')
    if cmd == "q":
        break
    res = subprocess.Popen(cmd,shell=True,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE)#只能读取一次，读后就没有了，类似队列
    std_out = res.stdout.read()
    std_err = res.stderr.read()
    len_num = len(std_out)+len(std_err) #计算所要发送数据的长度
    num_by = struct.pack('i',len_num)
    sk.send(num_by)
    sk.send(std_out)
    sk.send(std_err)

sk.close()

struct模块

Python是一门非常简洁的语言，对于数据类型的表示，不像其他语言预定义了许多类型（如：在C#中，光整型就定义了8种），它只定义了六种基本类型：字符串，整数，浮点数，元组，列表，字典。通过这六种数据类型，我们可以完成大部分工作。但当Python需要通过网络与其他的平台进行交互的时候，必须考虑到将这些数据类型与其他平台或语言之间的类型进行互相转换问题。打个比方：C++写的客户端发送一个int型(4字节)变量的数据到Python写的服务器，Python接收到表示这个整数的4个字节数据，怎么解析成Python认识的整数呢？ Python的标准模块struct就用来解决这个问题。

struct.pack用于将Python的值根据格式符，转换为字符串
用法：struct.pack(fmt, v1, v2, …)，
参数fmt是格式字符串。v1, v2, …表示要转换的python值。

struct.unpack用于将字节流转换成python数据类型。
用法：struct.unpack(fmt, string)，该函数返回一个元组。

demo3，实现大文件的传输

server端
#_*_coding:utf-8_*_

import socket
import struct
import  json

buffer = 1024

sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn, addr = sk.accept()

headlen = conn.recv(4)
head_len = struct.unpack('i',headlen)[0]    #unpack之后得到的是一个元组
head_json = conn.recv(head_len).decode('utf-8')
head = json.loads(head_json)
file_size = head['filesize']

with open(head["filename"],mode="wb")as f:
    while file_size:
        if file_size >= buffer:
            content = conn.recv(buffer)
            file_size -= buffer
            f.write(content)
        else:
            content = conn.recv(file_size)
            f.write(content)
            break

conn.close()
sk.close()


client端
#_*_coding:utf-8_*_

import socket
import os
import json
import struct

buffer = 1024

sk = socket.socket()
sk.connect(('127.0.0.1',8080))

# 制作报头
head = {
    'filename':'04 python fullstack s9day32 struct模块补充.mp4',
    'filepath':'F:python全栈9期视频第一部分-基础day32',
    'filesize':''
}
file_path = os.path.join(head['filepath'],head['filename'])
file_size = os.path.getsize(file_path)
head['filesize'] = file_size

#先发送报头的大小
json_head = json.dumps(head)    #将报头的字典转换成字符串
bytes_head = json_head.encode('utf-8')  #将报头head转换成bytes类型
len_head = len(bytes_head)  #计算head的长度
head_pack = struct.pack('i',len_head)
sk.send(head_pack)      #先发送报头的长度
sk.send(bytes_head)     #再发送报头的bytes类型数据
with open(file_path,mode = "rb") as f:
    while file_size:
        if file_size >= buffer:
            content = f.read(buffer)
            file_size -= buffer
            sk.send(content)
        else:
            content = f.read(file_size)
            sk.send(content)
            break

sk.close()

demo4,验证客户端的合法性

demo4,验证客户端的合法性
server端
import socket
import os
import hmac

secret_key = b'egg'
sk = socket.socket()
sk.bind(("127.0.0.1",8066))
sk.listen()

def check_conn(conn):
    msg = os.urandom(32)
    conn.send(msg)
    h = hmac.new(secret_key,msg)
    digest = h.digest()
    client_digest = conn.recv(1024)
    return hmac.compare_digest(digest,client_digest)

conn,addr = sk.accept()
res = check_conn(conn)
if res:
    print("合法的客户端")
    conn.close()
else:
    print("不合法的客户端")
    conn.close()

sk.close()


client端
import socket
import hmac

secret_key = b'egg'

sk = socket.socket()
sk.connect(('127.0.0.1',8066))
msg = sk.recv(1024)
h = hmac.new(secret_key,msg)
digest = h.digest()
sk.send(digest)

sk.close()