python之网络编程

一、什么是网络编程

　　网络编程简单来说就是对信息的发送到接收，中间传输为物理线路的作用。

　　在我们没有学过网络编程之前，在应用上写的代码都是只能自己提供自己使用，不能与其他人交互。那么如何实现相互通信呢？

二、数据之间的相互通信

　　首先先介绍一下套接字模块socket

　　套接字是一种通信机制，凭借这种机制，客户/服务器系统的开发工作既可以在本地单机上进行，也可以跨网络进行，Linux所提供的功能（如打印服务，ftp等）通常都是通过套接字来进行通信的，套接字的创建和使用与管道是有区别的，因为套接字明确地将客户和服务器区分出来，套接字可以实现将多个客户连接到一个服务器。

　　基于python提供了socket模块，我们可以应用该模块创建一个简单的可以与它人互动的程序

服务端
import socket   #导入socket套接字模块
server = socket.socket()    #创建一个socket对象
server.bind(("192.168.13.132",8000))    #绑定IP与端口
server.listen(3)    #规定只允许不超过三人链接服务端
conn,addr = server.accept()     #创建媒介与客户端地址
data = conn.recv(1024)      #新建一个变量，通过媒介接收客户端传输过来的字节并限制不超过1024
print(data)         #打印客户端传来的讯息
conn.send(b"123456")        #返回给客户端的字节
conn.close()        #与服务器断开链接
server.close()      # 关闭服务器的服务

# 客户端
import socket       #导入socket模块
client = socket.socket()      #创建一个socket对象
client.connect(("192.168.13.132",8000))     #与服务端建立链接
client.send(b"456789")      #向服务断传输讯息(字节型)
data =client.recv(1024)     #接服务端传来的讯息 不超过1024字节
print(data)         # 打印
client.close()      #关闭客户端

 三、网络编程的简单应用

　　模拟ssh

　　　　在没有介绍代码之前需要引入subprocess模块，subprocess是Python 2.4中新增的一个模块，它允许你生成新的进程，连接到它们的 input/output/error 管道，并获取它们的返回（状态）码

　　我们需要学会一下代码就足够了

import subprocess
res = subprocess.Popen("ipconfig",
                       shell= True,
                       stderr=subprocess.PIPE,
                       stdout=subprocess.PIPE

                      )
print(res.stdout.read().decode("gbk"))

　　建立服务端

# 服务端
import socket
import subprocess
server = socket.socket()
server.bind(("192.168.13.132",8000))
server.listen(3)
print("建立链接中。。。")
conn,addr = server.accept()
print("等待响应中。。。")
while True:
    cmd = conn.recv(1024).decode("utf-8")
    res = subprocess.Popen(cmd,
                               shell= True,
                               stderr=subprocess.PIPE,
                               stdout=subprocess.PIPE
                              )
    result = res.stdout.read()
    print("响应长度为%s" % len(result))
    conn.send(result.decode("gbk").encode("utf-8"))

　　建立客户端

# 客户端
import socket
client =socket.socket()
client.connect(("192.168.13.132",8000))
while True:
    user_input = input("请输入dose命令")
    client.send(user_input.encode("utf-8"))
    result = client.recv(1024).decode("utf-8")
    print(result)

　　文件的上传与下载

　　建立服务端

# 服务端
import socketserver,os,struct,hashlib,json
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        print("等待响应...")
        recevie_order = self.request.recv(1024).decode("utf-8")             #接收一个客户端发来的指令
        if recevie_order == "upload":               #判断当指令为upload时
            recevie_filename = self.request.recv(1024).decode("utf-8")  # 接收文件名
            currentfile_path = os.path.dirname(__file__)  # 获取当前路径前两位
            abs_path = os.path.join(currentfile_path, recevie_filename)  # 拼接路径
            maxbytes = self.request.recv(4)  # 接收客户端传来的报头信息
            md5 = hashlib.md5()      #创建一个摘要对象
            # 防止黏包
            long = struct.unpack("i", maxbytes)[0]      #解包获得文件的长度
            num = 0                 #设置一个初始长度
            data = b""              #文件的字节
            while num < long:           #当长度大于文件的长度时 退出循环
                receive = self.request.recv(1024)           #循环接收 客户端传来的文件内容
                data += receive         #以字节的形式进行字符串拼接
                num += len(receive)         #累加
            result = data       #最后获得一个字节形式的文件内容
            with open(abs_path, "wb") as f:         #创建一个文件，以字节的形式写入
                f.write(result)                 #将字节形式的内容写入到创建好的文件中
                md5.update(result)              # 进行摘要处理，目的是校验文件的完整性
            print("上传成功")
            check = self.request.recv(1024).decode("utf-8")             #接收客户端传来的摘要信息，并解码
            print(check)
            if check == md5.hexdigest():            #判断写入文件时进行的摘要与接收客户端传来的摘要是否一致
                self.request.send("文件完整".encode("utf-8"))
            else:
                self.request.send("文件被修改".encode("utf-8"))

        elif recevie_order == "download":           #判断当指令为upload时
            filename = os.listdir(os.path.dirname(__file__))            #获取当前的路径的前两位的路径下的文件
            for item in filename:                       #对这个文件列表进行遍历
                abs_path = os.path.join(os.path.dirname(__file__), item)        #在对文件的路径进行拼接
                if os.path.isdir(abs_path):                 #判断是否是文件夹
                    filename.remove(item)           #如果是则删除
            fileshow = json.dumps(filename)     #将列表序列化
            print(fileshow)
            self.request.send(fileshow.encode("utf-8"))         #向客户端发送这个序列化后的列表
            filename = self.request.recv(1024).decode("utf-8")          #接收文件名
            currentfile_path = os.path.dirname(__file__)                #获取当前服务端所在的路径
            abs_path = os.path.join(currentfile_path,filename)          #拼接路径，目的是为了获取服务端所在文件夹下的文件，即客户端要下载的文件
            md5 = hashlib.md5()             #创建一个摘要对象
            with open(abs_path, "rb") as f:         #以rb的形式打开文件
                result = f.read()               #读取字节形式的文件
                md5.update(result)              #进行摘要处理
                self.request.send(struct.pack("i", len(result)))            #向客户端发送一个报头，目的是解决黏包现象
                self.request.send(result)           #向客户端发送字节形式的文件
            print("传输成功")
            check = self.request.recv(1024).decode("utf-8")         #接收客户端传来的摘要信息，并解码
            print(check)
            if check == md5.hexdigest():
                self.request.send("文件完整".encode("utf-8"))
            else:
                self.request.send("文件被修改".encode("utf-8"))

server = socketserver.ThreadingTCPServer(("192.168.13.132",8000),Myserver)
server.serve_forever()

　　

　　建立客户端

# 客户端
import socket,os,hashlib,struct,json

client = socket.socket()
client.connect(("192.168.13.132",8000))
def upload():       #创建一个函数表示上传文件相关
    client.send(os.path.basename(user_input_list[1]).encode("utf-8"))         #向客户端发送文件名
    md5 = hashlib.md5()  # 校验
    with open(user_input_list[1], "rb") as f:           
        result = f.read()
        md5.update(result)
        client.send(struct.pack("i", len(result)))
        client.send(result)
    print("传输成功")
    check = md5.hexdigest()
    print(check)
    client.send(check.encode("utf-8"))
    check_result = client.recv(1024).decode("utf-8")
    print(check_result)
def download():
    client.send(user_input_list[1].encode("utf-8"))
    maxbytes = client.recv(4)  # 最大接收不超过4字节
    md5 = hashlib.md5()
    long = struct.unpack("i", maxbytes)[0]
    num = 0
    data = b""
    while num < long:
        receive = client.recv(1024)
        data += receive
        num += len(receive)
    result = data
    abs_path = os.path.join(os.path.dirname(__file__), user_input_list[1])
    with open(abs_path, "wb") as f:
        f.write(result)
        md5.update(result)
    print("下载成功")
    check = md5.hexdigest()
    print(check)
    client.send(check.encode("utf-8"))
    check_result = client.recv(1024).decode("utf-8")
    print(check_result)
menu_list =["上传文件","下载文件"]
for i,item in enumerate(menu_list,1):
    print(i,item)
user_choice = int(input("请输入序号选择功能"))
if user_choice == 1:
    client.send("upload".encode("utf-8"))               #向服务端发送该进行什么操作的指令
    user_input = input("请输入指令进行操作(upload/路径)")
    user_input_list = user_input.strip().split("/")
    upload()
elif user_choice== 2:
    client.send("download".encode("utf-8"))                 #当发送的指令为download时我们应该获得一个文件列表，方便与客户端知道该下载什么文件
    fileshow = client.recv(1024).decode("utf-8")            #接收到一个文件列表
    file_list = json.loads(fileshow)            #再将列表反序列化
    print("可下载的文件列表为:")
    print(file_list)                #展示列表
    user_input = input("请输入指令进行操作(download/文件)")
    user_input_list = user_input.strip().split("/")
    download()

四、黏包现象

　　黏包现象就是同时执行多条命令之后，得到的结果很可能只有一部分，在执行其他命令的时候又接收到之前执行的另外一部分结果，这种显现就称之为黏包。

　　只有tcp协议会出现黏包现象，dcp协议不会出现。

　　

　　

 　　解决黏包的理想方案:

　　

# 服务端
import socket    #套接字模块
import subprocess
import struct
server = socket.socket()
server.bind(("192.168.13.132",8000))
server.listen(3)
print("建立链接中。。。")
conn,addr = server.accept()
print("等待响应中。。。")
while True:
    cmd = conn.recv(1024).decode("utf-8")
    res = subprocess.Popen(cmd,
                               shell= True,
                               stderr=subprocess.PIPE,
                               stdout=subprocess.PIPE
                              )
    result = res.stdout.read()
    error = res.stderr.read()
    print("响应长度为%s" % len(result))
    print("错误信息为%s" % error.decode("gbk"))
    if error:
        back_message = error
    else:
        back_message = result
    conn.send(struct.pack("i", len(back_message)))  # 构建报头
    conn.send(back_message)  # 发送数据

# 客户端
import socket
import struct
client =socket.socket()
client.connect(("192.168.13.132",8000))
while True:
    user_input = input("请输入dose命令")
    client.send(user_input.encode("utf-8"))
    maxbytes = client.recv(4)
    long = struct.unpack("i",maxbytes)[0]
    num = 0
    data = b""
    while num < long:
        receive = client.recv(1024)
        data +=receive
        num +=len(receive)
    print(data.decode("gbk"))

 五、osi七层模型

　osi七层模型一般指开放系统互连参考模型

　　概要:

　　osi7层模型
    　　·应用层 :使用软件
    　　·表示层 :看到视频图片等             }产生数据(传输令牌)
    　　·会话层 :保持你的登陆或链接状态
    　　· 5 - 7
    　　·传输层 :tcp / udp
    　　·网络层 :找Ip
    　　·4 - 5
    　　·数据链路层 :MAC地址                }物理层
    ·　　物理层 :
　　

TCP三次握手/四次挥手
    socket客户端向服务端发起连接请求:三次握手 ·connect
    客户端和服务端断开连接:四次握手  ·close




    补充！
        当客户端主动断开链接时，会向服务端抛出异常，或发送空