python网络编程

知识内容：

1.socket语法及相关

2.黏包

3.struct模块

4.subprocess模块

5.socketserver模块

6.验证客户端连接的合法性

 

参考：

http://www.cnblogs.com/Eva-J/articles/8244551.html

http://www.cnblogs.com/alex3714/articles/5227251.html

关于网络基础概念：http://www.cnblogs.com/wyb666/p/9014857.html

 

 

 

一、socket语法及相关

1.基于TCP协议的socket

TCP是基于连接的，必须先启动服务端，然后再启动客户端去链接服务端；另外双方一定要有一方发消息一方收消息，不能同时收消息或同时发消息

TCP编程中用到的socket模块中的方法如下：

• socket([family, [, type, [proto]]]): 创建一个socket对象
• connect(address): 连接远程主机
• send(bytes[, flags]): 发送数据
• recv(bufsize[, flags]): 接受数据
• bind(address): 绑定地址
• listen(backlog): 开始监听，等待客户端连接
• accept(): 响应客户端的请求
• close(): 关闭连接或关闭服务器

server.py

# __author__ = "wyb"
# date: 2018/5/8

import socket                   # 导入socket模块
sk = socket.socket()
sk.bind(('127.0.0.1', 8888))    # bind(('ip', 'port')) 绑定ip和端口号
sk.listen()                     # 监听连接

conn, addr = sk.accept()        # 接收客户端连接

res = conn.recv(1024)           # 接收信息
print(res)
conn.send(b'hi!')               # 发送信息，必须传一个bytes类型
res = conn.recv(1024)
print(res.decode('utf-8'))                          # 解码
conn.send(bytes("吃包子啊!".encode('utf-8')))       # 编码

conn.close()                    # 关闭连接
sk.close()                      # 关闭服务器


# 有收必有发，收发必相等

client.py

# __author__ = "wyb"
# date: 2018/5/8
import socket

sk = socket.socket()

sk.connect(('127.0.0.1', 8888))     # 连接服务器
sk.send(b'wyb')                     # 发送信息
res = sk.recv(1024)                 # 接受信息
print(res)
sk.send(bytes("中午吃什么".encode('utf-8')))     # 编码
res = sk.recv(1024)
print(res.decode("utf-8"))                     # 解码

sk.close()                          # 关闭客户端

 

 

2.基于UDP协议的socket

udp是无链接的，启动服务之后可以直接接受消息，不需要提前建立链接，而是直接向接收方发送信息

UDP编程中用到socket模块中的如下方法：

(1)socket([family, [, type, [proto]]]):  创建一个socket对象,参数如下:

• family为socket.AF_INET表示IPV4，family为socket.INET6表示IPV6
• type为SOCK_STREAM表示TCP，type为SOCK_DGRAM表示UDP
• proto为协议号，通常为零,可以省略

(2)sendto(string, address)：把string指定的内容发送给address指定的地址，其中address是一个包含接受方主机IP地址和应用进程端口号的元组，

格式为(IP地址, 端口号)

(3)recvfrom(bufsize[, flags])：接受数据，bufsize是可接受的最大数据，单位为kb

(4)bind(address): 绑定地址

(5)close(): 关闭服务器

server.py

# __author__ = "wyb"
# date: 2018/5/9
import socket

sk = socket.socket(type=socket.SOCK_DGRAM)          # DGRAM datagram
sk.bind(('127.0.0.1', 8888))                        # '127.0.0.1', 8888 -> server端地址

msg, addr = sk.recvfrom(1024)                       # 接受消息
print(msg.decode("utf-8"))
sk.sendto(b"bye", addr)                             # 发送消息  addr -> client端地址

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

client.py

# __author__ = "wyb"
# date: 2018/5/9
import socket

sk = socket.socket(type=socket.SOCK_DGRAM)          # DGRAM datagram

ip_port = ('127.0.0.1', 8888)                       # 发送的地址 '127.0.0.1', 8888 -> server端地址

sk.sendto(b"hello", ip_port)                        # 发送消息
ret, addr = sk.recvfrom(1024)                       # 接受消息   addr -> server端地址
print(ret.decode("utf-8"))

sk.close()

 

 

3.相关练习

(1)话痨对话

server.py

# __author__ = "wyb"
# date: 2018/5/8
import socket

sk = socket.socket()

sk.bind(('127.0.0.1', 8888))
sk.listen()

conn, addr = sk.accept()

while True:
    res = conn.recv(1024).decode('utf-8')           # 接收消息(解码)
    if res == "bye":                                # 退出
        conn.send(b"bye")
        break
    print(res)                                      # 输出消息
    mes = input(">>>")                              # 输入消息
    conn.send(mes.encode('utf-8'))                  # 发送消息(编码)

conn.close()
sk.close()

client.py

# __author__ = "wyb"
# date: 2018/5/8
import socket

sk = socket.socket()

sk.connect(('127.0.0.1', 8888))

while True:
    msg = input(">>>")                                  # 输入消息
    sk.send(msg.encode('utf-8'))                        # 传输消息(编码)
    res = sk.recv(1024).decode("utf-8")                 # 接收消息(解码)
    if res == 'bye':                                    # 退出
        sk.send(b'bye')
        break
    print(res)                                          # 输出消息

sk.close()

 

(2)时间服务器

server.py

# __author__ = "wyb"
# date: 2018/5/8
import socket
from time import strftime

ip_port = ('127.0.0.1', 8888)       # server端地址

udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_server.bind(ip_port)

while True:
    msg, addr = udp_server.recvfrom(1024)       # 接受消息
    print(msg.decode("utf-8"))

    # 根据接受到的消息进行处理
    if not msg:
        time_fmt = '%Y-%m-%d %X'
    else:
        time_fmt = msg.decode('utf-8')
    # 根据时间格式生成时间信息
    back_msg = strftime(time_fmt)

    # 发送消息
    udp_server.sendto(back_msg.encode("utf-8"), addr)


udp_server.close()

client.py

# __author__ = "wyb"
# date: 2018/5/8
import socket

ip_port = ('127.0.0.1', 8888)
udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    msg = input('请输入时间格式(例%Y %m %d)>>: ').strip()    # 输入信息
    udp_client.sendto(msg.encode('utf-8'), ip_port)          # 发送信息

    data = udp_client.recv(1024)                             # 接受消息
    print(data.decode("utf-8"))


udp_client.close()

 

(3)QQ聊天

server.py

import socket

ip_port = ('127.0.0.1', 8005)
sk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sk.bind(ip_port)

while True:
    data, addr = sk.recvfrom(1024)  # 接受消息
    if data == b"bye":
        break
    print(data.decode("utf-8"))
    info = input(">>>").encode("utf-8")
    sk.sendto(info, addr)

sk.close()

client.py

import socket

ip_port = ('127.0.0.1', 8005)
sk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    msg = input("老王: ")
    msg = "\033[34m来自老王的消息: %s\033[0m" % msg
    sk.sendto(msg.encode("utf-8"), ip_port)
    data, addr = sk.recvfrom(1024)
    if data == b"bye":
        break
    print(data.decode("utf-8"))

sk.close()

 

(4)远程执行命令

server.py

import socket
sk = socket.socket()

sk.bind(('127.0.0.1', 8888))
sk.listen()

conn, addr = sk.accept()

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


conn.close()
sk.close()

client.py

import socket
import subprocess
sk = socket.socket()

sk.connect(('127.0.0.1', 8888))

while True:
    cmd = sk.recv(1024).decode("gbk")
    if cmd == "q" or cmd == "exit":
        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()

 

 

 

二、黏包

1.什么是黏包

黏包问题是因为发送方把若干数据发送，接收方收到数据时候黏在一包，从接受缓冲区来看，后一包的数据黏在前一包的尾部，当连续send多个小数据包时就可能会发生黏包，其是TCP内部的优化算法造成的

注只有TCP才有黏包问题，UDP没有黏包问题:

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。 
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

 

 

2.黏包成因

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据

补充说明:

用UDP协议发送时，用sendto函数最大能发送数据的长度为：
65535- IP头(20) – UDP头(8)＝65507字节
用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误，将会丢弃这个包，不进行发送

用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制，只是暂不考虑缓冲区的大小，是指在用send函数时，数据长度参数不受限制
而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送

 

 

3.黏包具体情况

(1)发送方的缓存机制

连续send两个小包时，就会黏包，TCP会将这两个包合为一体，变成一个包  eg: 2+8  ->  10，其本质是发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，多个小数据会当做一个包发出去，产生粘包）

示例:

server.py

import socket

sk = socket.socket()
sk.bind(("127.0.0.1", 8888))
sk.listen()

conn, addr = sk.accept()
res = conn.recv(200)
print("res:", res)

conn.close()
sk.close()

client.py

import socket

sk = socket.socket()
sk.connect(("127.0.0.1", 8888))
sk.send(b"hello, world!")
sk.send(b"wyb666")

sk.close()

 

(2)接受方的缓存机制

连续两个recv，第一个recv特别小，假如说此时发送的是一个长数据，则会出问题(没接受完的数据缓存下来)，其本质是接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

示例:

server.py

import socket

sk = socket.socket()
sk.bind(("127.0.0.1", 8888))
sk.listen()

conn, addr = sk.accept()
res = conn.recv(2)
res2 = conn.recv(10)
print("res:", res)
print("res2:", res2)

conn.close()
sk.close()

client.py

import socket

sk = socket.socket()
sk.connect(("127.0.0.1", 8888))
sk.send(b"hello, world!")

sk.close()

总结：

黏包现象只发生在tcp协议中：

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

 

 

4.黏包的解决方案

(1)解决原理

问题的根源在于接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是在发送包之前发送数据的大小，再根据数据的大小来接受数据

根据上述方法解决黏包如下所示：

server.py

import socket
sk = socket.socket()

sk.bind(('127.0.0.1', 8888))
sk.listen()

conn, addr = sk.accept()

while True:
    cmd = input(">>>")
    if cmd == 'q':
        conn.send(b'q')
        break
    conn.send(cmd.encode("gbk"))
    num = conn.recv(1024).decode("utf-8")       # 接受数据的大小
    conn.send(b"ok")                            # 响应ok
    res = conn.recv(int(num)).decode("gbk")     # 根据数据大小接受数据
    print(res)


conn.close()
sk.close()

client.py

import socket
import subprocess

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

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()     # 原理是队列 所以只能读一次
    sk.send(str(len(std_out)+len(std_err)).encode("utf-8"))     # 发送数据的大小
    sk.recv(1024)                   # 接收ok
    sk.send(std_out)
    sk.send(std_err)


sk.close()

这样解决的好处与坏处:

• 好处：确定我到底要接受多大的数据
• 坏处：多了一次交互

注意：

最好在文件中配置一个配置选项，指定每一次recv的大小，也就是指定buffer，最大为4096

当我们要发送大的数据时，应该明确的告诉接收方要发送多大的数据，以便能准确的接受到所有数据

以上的方法多用在文件传输的过程中，在大文件的传输过程中发送方一边读一边传，接收方一边收一边写

 

(2)解决黏包问题升级版 - 借助struct模块

server.py

import socket
import struct
sk = socket.socket()

sk.bind(('127.0.0.1', 8888))
sk.listen()

conn, addr = sk.accept()

while True:
    cmd = input(">>>")
    if cmd == 'q':
        conn.send(b'q')
        break
    conn.send(cmd.encode("gbk"))
    num = conn.recv(4)                              # 接受数据的大小
    num = struct.unpack('i', num)[0]                # 将4个字节转化成整数
    res = conn.recv(int(num)).decode("gbk")         # 根据数据大小接受数据
    print(res)


conn.close()
sk.close()

client.py

import socket
import struct
import subprocess

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

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_py = struct.pack('i', len_num)      # 把数据大小压缩为4个
    sk.send(num_py)
    sk.send(std_out)
    sk.send(std_err)


sk.close()

 

 

 

三、struct模块

1.简单使用

作用：struct模块可以把一个类型，如数字，转成固定长度的bytes

基本用法：

# __author__ = "wyb"
# date: 2018/5/16
# 什么是固定长度的bytes
# 为什么要转化成固定长度的bytes

import struct

res = struct.pack('i', 4096)        # 'i'代表int，就是即将要把一个数字转化成固定长度的bytes类型
print(res)

num = struct.unpack('i', res)
print(num)          # 输出元组
print(num[0])       # 输出数

 

 

2.使用struct解决黏包 

借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。

发送时	接收时
先发送struct转换好的数据长度4字节	先接受4个字节使用struct转换成数字来获取要接收的数据长度
再发送数据	再按照长度接收数据

具体实例见上面的解决黏包问题升级版

我们还可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）

发送时	接收时
先发报头长度	先收报头长度，用struct取出来
再编码报头内容然后发送	根据取出的长度收取报头内容，然后解码，反序列化
最后发真实内容	从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

实例：

server.py

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)     #阻塞的最大数

while True:
    coon,addr = phone.accept()
    print(coon,addr)
    while True:     #通信循环
        # 收发消息
        cmd = coon.recv(1024) #接收的最大数
        print('接收的是：%s'%cmd.decode('utf-8'))
        #处理过程
        res = subprocess.Popen(cmd.decode('utf-8'),shell = True,
                                          stdout=subprocess.PIPE, #标准输出
                                          stderr=subprocess.PIPE #标准错误
                                )
        stdout = res.stdout.read()
        stderr = res.stderr.read()
        # 制作报头
        header_dic = {
            'total_size': len(stdout)+len(stderr),  # 总共的大小
        }
        header_json = json.dumps(header_dic) #字符串类型
        header_bytes = header_json.encode('utf-8')  #转成bytes类型(但是长度是可变的)
        #先发报头的长度
        coon.send(struct.pack('i',len(header_bytes))) #发送固定长度的报头
        #再发报头
        coon.send(header_bytes)
        #最后发命令的结果
        coon.send(stdout)
        coon.send(stderr)
    coon.close()
phone.close()

client.py

import socket
import struct
import json

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.connect(('127.0.0.1', 8080))  # 连接服务器
buffer = 1024

while True:
    cmd = input('输入命令>>').strip()
    phone.send(cmd.encode('utf-8'))  # 发送消息
    header_len = struct.unpack('i', phone.recv(4))[0]  # 收报头的长度
    header_bytes = phone.recv(header_len)  # 接收报头
    header_json = header_bytes.decode('utf-8')  # 拿到json格式的字典
    header_dic = json.loads(header_json)  # 反序列化拿到字典
    total_size = header_dic['total_size']  # 拿到数据的总长度
    # 最后收数据
    recv_size = 0
    total_data = b''
    while recv_size < total_size:  # 循环的收
        recv_data = phone.recv(buffer)  # buffer只是一个最大的限制
        recv_size += len(recv_data)
        total_data += recv_data  # 最终的结果
    print('返回的消息：%s' % total_data.decode('gbk'))

phone.close()

 

 

 

四、subprocess模块

作用：提供与系统交互的方法,与标准库中的其它模块相比，提供了一个更高级的接口。用于替换如下模块：
os.system() , os.spawnv() , os和popen2模块中的popen()函数，以及 commands()

简单使用：

import subprocess

command = input("请输入命令: ").strip()
res = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

print(res)
print("stdout: ", res.stdout.read().decode("gbk"))
print("stderr: ", res.stderr.read().decode("gbk"))

 

 

 

五、socketserver模块

作用：socketserver用于简化网络客户端与服务器端的实现

server.py

# __author__ = "wyb"
# date: 2018/5/18
import socketserver

class MyServer(socketserver.BaseRequestHandler):
    def handle(self):           # self.request相当于一个conn
        while True:
            msg = self.request.recv(1024)
            print(msg.decode("utf-8"))
            msg = input(">>>")
            self.request.send(msg.encode("utf-8"))

if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1', 8888), MyServer)
    # thread 线程
    server.serve_forever()           # 让server一直运行

client.py

import socket

sk = socket.socket()
sk.connect(('127.0.0.1', 8888))
while True:
    msg = input(">>>")
    if msg == "q":
        sk.send(b"q")
        break
    sk.send(("老王: "+msg).encode("utf-8"))
    res = sk.recv(1024)
    print(res.decode("utf-8"))

sk.close()

 

关于socketserver源码：http://www.cnblogs.com/Eva-J/p/5081851.html

 

 

 

六、验证客户端连接的合法性

想实现一个简单的客户端链接认证功能，又不像SSL那么复杂，那么利用hmac+加盐的方式来实现

hmac使用：

# __author__ = "wyb"
# date: 2018/5/18
import hmac         # 类似hashlib

h = hmac.new(b"key", b"hello")      # secret_key 要加密的bytes

secret_h = h.digest()               # 生成密文
print(secret_h)

print(hmac.compare_digest(secret_h, b"xxaf"))      # 对比密文与另一个密文

server.py

# __author__ = "wyb"
# date: 2018/5/18
import os
import hmac
import socket

secret_key = b"wyb"     # 加密的密钥

sk = socket.socket()
sk.bind(("127.0.0.1", 8001))
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.py

# __author__ = "wyb"
# date: 2018/5/18
import hmac
import socket

secret_key = b"wyb"     # 加密的密钥

sk = socket.socket()
sk.connect(("127.0.0.1", 8001))

msg = sk.recv(1024)
h = hmac.new(secret_key, msg)
digest = h.digest()
sk.send(digest)

sk.close()

注：如果客户端不知道正确的密钥或不知道正确的加密方法那么将无法通过验证