python6-网络编程

最新推荐文章于 2023-06-26 14:44:40 发布

tensor_zhang

最新推荐文章于 2023-06-26 14:44:40 发布

阅读量159

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/Mr_ZhangKY/article/details/119712789

版权

python 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1，七层网络协议

应表会传网数物：

应用层、表示层、会话层：（这三层又可以合并为应用层，这样就是五层网络协议【osi五层协议】） python ‘你好’.encoding(‘utf-8’)
传输层：预备如何传输、使用的端口（port，tcp，udp）；四层路由器、四层交换机
网络层： ip（ipv4 ipv6）；路由器、三层交换机
数据链路层： mac(mac, arp协议：可以通过ip找到mac)；二层交换机、网卡（单播、广播、组播，arp用到单播和广播）
物理层：转成电信号

2，TCP/UDP

tcp需要先建立连接，然后才能够通信（类似于打电话）

占用连接，可靠（消息不会丢失），实时性高，慢（效率低、面向连接、可靠、全双工）
三次握手
- 客户端向服务器端发送syn请求
- 服务端回复ack并发送syn请求
- 客户端接收到请求后再回复ack，连接建立
  - 在socket中是由客户端connect() 和服务端accept()两个命令完成的
四次挥手
- 客户端向服务端发送fin请求
- 服务端回复ack确认
- 服务端向客户端发送fin请求
- 客户端回复ack确认
  - 在socket中是由客户端sk.close() 和服务端 conn.close()两个命令完成的
  - 挥手时服务端的ack和fin不能同时发送，因为客户端发送完所有信息时，服务端不一定完成了所有信息的发送

udp不需要建立连接，就可以通信（类似于发信息）

不占用连接，不够可靠（消息因为网络不稳定可能丢失），实时性不高（效率高、无连接的、不可靠的）

3，例子

'''
------------------------------
TCP协议
------------------------------
'''
'''server'''
import socket

sk = socket.socket()
sk.bind(('127.0.0.1', 6000))
sk.listen()

conn, addr = sk.accept()
conn.send('你好'.encode('utf-8'))
msg = conn.recv(1024)
print(msg.decode('utf-8'))
conn.close()

sk.close()

'''client'''
import socket

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

msg = sk.recv(1024)
print(msg.decode('utf-8'))
sk.send('再见'.encode('utf-8'))

sk.close()

'''
------------------------------
UDP协议
------------------------------
'''
'''server'''
import socket

sk = socket.socket(type=socket.SOCK_DGRAM)   #SOCK_DGRAM udp    default tcp
sk.bind(('127.0.0.1', 6000))

# msg = sk.recv(1024)
# print(msg.decode('utf-8'))

while True:
    msg = sk.recvfrom(1024)
    print(msg)
    print(msg[0].decode('utf-8'))
    if msg[0].decode('utf-8') == '对方和你断开了连接':
        continue
    msgSend = input('>>>')
    sk.sendto(msgSend.encode('utf-8'), msg[1])

'''client'''
import socket

sk = socket.socket(type=socket.SOCK_DGRAM)
server = ('127.0.0.1', 6000)

while True:
    msgSend = input('>>>')
    if msgSend.upper() == 'Q':
        sk.sendto('对方和你断开了连接'.encode('utf-8'), server)
        break
    sk.sendto(msgSend.encode('utf-8'), server)
    msg = sk.recv(1024).decode('utf-8')
    if msg.upper() == 'Q':
        print('对方和你断开了连接')
        break
    print(msg)

4，粘包

只出现在tcp协议中，因为tcp协议中多条消息之间没有边界，并且还有各种优化算法，因此会导致发送端和接收端都存在粘包现象：

发送端：两条消息很短，而且发送的间隔时间也很短

接收端：多条消息没有及时接收，而在接收方的缓存堆在一起导致粘包

'''server'''
import socket

sk = socket.socket()
sk.bind(('127.0.0.1', 6000))
sk.listen()

conn, addr = sk.accept()
conn.send(b'hello')
conn.send(b'byebye')

conn.close()
sk.close()

'''client'''
import time
import socket

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

time.sleep(0.1)
msg = sk.recv(5)
print(msg)
msg = sk.recv(4)
print(msg)

sk.close()

解决粘包问题的本质：设置边界（发送长度、发送消息，交替进行）

1，自定义协议

'''server'''
import socket

sk = socket.socket()
sk.bind(('127.0.0.1', 6000))
sk.listen()

conn, addr = sk.accept()
msg1 = input('>>>').encode('utf-8')
msg2 = input('>>>').encode('utf-8')

def sendFunc(msg):
    num = str(len(msg))
    ret = num.zfill(4)
    conn.send(ret.encode('utf-8'))
    conn.send(msg)
sendFunc(msg1)
sendFunc(msg2)

conn.close()
sk.close()

'''client'''
import socket

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

def receiveFunc():
    num = sk.recv(4).decode('utf-8')
    msg = sk.recv(int(num))
    print(msg.decode('utf-8'))

receiveFunc()
receiveFunc()

sk.close()

2，struct模块

import struct
'''~2**32, 排除符号位，相当于1G的数据的长度'''

num1 = 1231341234
num2 = 1342342
num3 = 12

ret1 = struct.pack('i', num1)
print(ret1)
print(len(ret1))
ret2 = struct.pack('i', num2)
print(ret2)
print(len(ret2))
ret3 = struct.pack('i', num3)
print(ret3)
print(len(ret3))

ret11 = struct.unpack('i', ret1)
print(ret11)
print(type(ret11[0]))

5，文件传输

固定字节传输

'''server'''
import socket
import os
import json
import struct

sk = socket.socket()
sk.bind(('127.0.0.1', 6969))
sk.listen()

conn, _ = sk.accept()
length = struct.unpack('i', conn.recv(4))
dic_info = json.loads(conn.recv(length[0]).decode('utf-8'))
directory = dic_info['filename']
size = dic_info['filesize']
print(directory)
print(size)

with open(f'recv\\{directory}', mode='wb') as f:
    while size > 0:
        f.write(conn.recv(1024))
        size -= length[0]

if os.path.getsize(f'recv\\{directory}') == dic_info['filesize']:
    print('\033[32m成功接收文件！\033[0m')
else:
    print('\033[31m接收文件失败！\033[0m')

'''client'''
import socket
import os
import json
import struct

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

directory = 'eclipse-inst-jre-win64.exe'
size = os.path.getsize(directory)
str_dic = json.dumps({'filename': directory, 'filesize': size}).encode('utf-8')
sk.send(struct.pack('i', len(str_dic)))
sk.send(str_dic)

with open(directory, mode='rb') as f:
    while size > 0:
        sk.send(f.read(1024))
        size -= 1024

sk.close()

按行传输

'''server'''
import socket
import os
import json
import struct

sk = socket.socket()
sk.bind(('127.0.0.1', 6000))
sk.listen()

conn, _ = sk.accept()
length = struct.unpack('i', conn.recv(4))
dic_info = json.loads(conn.recv(length[0]).decode('utf-8'))
directory = dic_info['filename']
size = dic_info['filesize']

with open(f'recv\\{directory}', mode='wb') as f:
    while size > 0:
        length = struct.unpack('i', conn.recv(4))
        msg = conn.recv(length[0])
        f.write(msg)
        size -= length[0]

if os.path.getsize(f'recv\\{directory}') == dic_info['filesize']:
    print('\033[32m成功接收文件！\033[0m')
else:
    print('\033[31m接收文件失败！\033[0m')

'''client'''
import socket
import os
import json
import struct

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

directory = 'eclipse-inst-jre-win64.exe'
size = os.path.getsize(directory)
str_dic = json.dumps({'filename': directory, 'filesize': size}).encode('utf-8')
sk.send(struct.pack('i', len(str_dic)))
sk.send(str_dic)

with open(directory, mode='rb') as f:
    for line in f:
        length = len(line)
        sk.send(struct.pack('i', length))
        sk.send(line)

sk.close()

6，验证客户端合法性

'''补充知识'''
# 生成一个随机的字符串
import os
ret = os.urandom(16)
print(ret)
print(len(ret))

# 加密
import hashlib
sha = hashlib.sha1(密钥)
sha.updata(随机字符串)
res = sha.hexdigest()
print(res)

'''server'''
import socket
import os
import hashlib

key = b'alex'
sk = socket.socket()
sk.bind(('127.0.0.1', 9000))
sk.listen()

conn, addr = sk.accept()
#创建一个随机的字符串
rand = os.urandom(32)
conn.send(rand)

#接收并对比
msg = conn.recv(1024).decode('utf-8')
sha = hashlib.sha1(key)
sha.update(rand)
if sha.hexdigest() == msg:
    print(True)
    '''继续通讯'''
else:
    print(False)
    conn.send('滚吧'.encode('utf-8'))
    conn.close()

'''client'''
import socket
import os
import hashlib

key = b'alex'
sk = socket.socket()
sk.connect(('127.0.0.1', 9000))

#接收随机字符串
msg = sk.recv(32)

#加密并发送
sha = hashlib.sha1(key)
sha.update(msg)
sk.send(sha.hexdigest().encode('utf-8'))

tensor_zhang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
python6-网络编程

1，七层网络协议应表会传网数物：应用层、表示层、会话层：（这三层又可以合并为应用层，这样就是五层网络协议【osi五层协议】） python ‘你好’.encoding(‘utf-8’)传输层：预备如何传输、使用的端口（port，tcp，udp）；四层路由器、四层交换机网络层： ip（ipv4 ipv6）；路由器、三层交换机数据链路层： mac(mac, arp协议：可以通过ip找到mac)；二层交换机、网卡（单播、广播、组播，arp用到单播
复制链接

扫一扫