Python之socket编程(未完待续)

一. C/S架构

C/S架构有叫做 客户端/服务端 架构。
服务器是一个软件或者硬件，用于提供客户需要的“服务”，服务器存在的唯一目的就是等待客户的请求，给这些客户提供服务，然后再等待其他请求。
硬件 客户/服务器 架构
打印(机)服务就是一个硬件服务器的例子，客户端将打印任务传输给打印机，打印机完成打印任务，等待下一次打印任务
软件 客户/服务器 架构
软件服务器也是运行在某个硬件之上，但不像硬件那样有专门的设备，软件服务器提供的服务主要是程序的运行，数据的发送与接收，合并，升级或者其他的程序或数据的操作。
目前，最常用的软件服务器就是web服务器，一台机器放一些网页或者web应用程序，然后启动服务器。服务器的任务就是接受客户的请求，将网页发送给客户，等待下一次请求。

二. TCP UDP IP之间的关系

从图中并没有看到socket，那么socket在网络协议中是在一个什么样的位置呢？

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。
ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序
而程序的pid是同一台机器上不同进程或者线程的标识

二. 套接字

完成客户端与服务端的通信，必须创建一个通信端点，让服务器“监听”请求。
套接字就是一种计算机网络数据结构，可以创建上述的通信端点，实现“监听”功能，最终实现网络通信。网络化的应用程序，在开始任何通信之前必须要创建套接字，就像电话的插口一样，没有他无法通信。
我们只关心网络编程，我们只用套接字夹住中的AF_INET，Python还支持AF_INET之外的AF_UNIX和AF_NETLINK。

1. 套接字工作流程

服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

import socket
socket.socket(socket_family,socket_type,protocal=0)
#socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。

#获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

由于 socket 模块中有太多的属性。使用 'from socket import *',能大幅减短代码。
例如tcpSock = socket(AF_INET, SOCK_STREAM)

2. 套接字函数

名称	用法
服务端套接字函数
s.bind()	绑定(主机,端口号)到套接字
s.listen()	开始TCP监听
s.accept()	被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端套接字函数
c.connect()	主动初始化TCP服务器连接
c.connect_ex()	connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv()	接收TCP数据
s.send()	发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall()	发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom()	接收UDP数据
s.sendto()	发送UDP数据
s.getpeername()	连接到当前套接字的远端的地址
s.getsockname()	当前套接字的地址
s.getsockopt()	返回指定套接字的参数
s.setsockopt()	设置指定套接字的参数
s.close()	关闭套接字
面向锁的套接字方法
s.setblocking()	设置套接字的阻塞与非阻塞模式
s.settimeout()	设置阻塞套接字操作的超时时间
s.gettimeout()	得到阻塞套接字操作的超时时间
面向文件的套接字的函数
s.fileno()	套接字的文件描述符
s.makefile()	创建一个与该套接字相关的文件

3. 基于TCP的socket编程

基于TCP的socket编程的实现方式

server端

ss = socket() #创建服务器套接字
ss.bind()      #把地址绑定到套接字
ss.listen()      #监听链接
inf_loop:      #服务器无限循环
    cs = ss.accept() #接受客户端链接
    comm_loop:         #通讯循环
        cs.recv()/cs.send() #对话(接收与发送)
    cs.close()    #关闭客户端套接字
ss.close()        #关闭服务器套接字(可选)

client端

cs = socket()    # 创建客户套接字
cs.connect()    # 尝试连接服务器
comm_loop:        # 通讯循环
    cs.send()/cs.recv()    # 对话(发送/接收)
cs.close()            # 关闭客户套接字

根据上述通信实现流程实现一个简单的tcp套接字程序

# server端程序
from socket import *

IP_PROT = ('127.0.0.1', 8080)


def sok_ser(ip_port):
    ss = socket(AF_INET, SOCK_STREAM)
    ss.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    ss.bind(ip_port)
    ss.listen(5)

    while True:    # 服务器循环
        conn, addr = ss.accept()

        while True:   # 链接循环
            try:   # 使用try/except来处理windows系统中客户端发送空包导致异常终止的问题
                data = conn.recv(1024)
                if not data: break    # 用于在Linux系统中处理客户端发送空包会进入接受死循环的问题
                conn.send(data.upper())

            except Exception:
                break

        conn.close()
    ss.close()

if __name__ == '__main__':
    sok_ser(IP_PROT)

# client端程序
from socket import *

IP_PROT = ('127.0.0.1', 8080)

def sok_cli(ip_port):
    cc = socket(AF_INET, SOCK_STREAM)
    cc.connect(ip_port)

    while True:
        msg = input('>>: ')
        if not msg:
            continue

        cc.send(msg.encode('utf-8'))
        data = cc.recv(1024)
        print(data.decode('utf-8'))

    cc.close

if __name__ == '__main__':
    sok_cli(IP_PROT)

基于TCP的socket编程—实现远程执行命令功能

# server端
from socket import *
import subprocess

def sok_ser():
    socket_server = socket(AF_INET, SOCK_STREAM)
    socket_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 解决客户端断开后，server端进入TIME_WAIT的状态
    socket_server.bind(('127.0.0.1', 8080))
    socket_server.listen(5)

    while True:
        conn, addr = socket_server.accept()  # 链接循环

        while True:
            try:
                cmd = conn.recv(1024)
                if not cmd:
                    break
                res = subprocess.Popen(cmd.decode('utf-8'),
                                       shell=True,
                                       stdout=subprocess.PIPE,
                                       stderr=subprocess.PIPE)

                conn.send(res.stdout.read())
                conn.send(res.stderr.read())
            except Exception:
                break

        conn.close()

    socket_server.close()


if __name__ == '__main__':
    sok_ser()

# client端
from socket import *


def sok_cli(code_fmt):
    socket_client = socket(AF_INET, SOCK_STREAM)
    socket_client.connect(('127.0.0.1', 8080))

    while True:
        cmd = input(':>>')
        if not cmd:
            continue

        socket_client.send(bytes(cmd, encoding='utf-8'))

        data = socket_client.recv(1024)
        if not data.decode(code_fmt):
            print('wrong cmd')
            continue
        else:
            print(data.decode(code_fmt))

    socket_client.close()

if __name__ == '__main__':
    sok_cli('gbk')

基于TCP的socket编程—解决粘包问题

上述例子貌似是可以实现远程执行命令的功能的，但是如果使用上述程序查看一个非常大的文件，就会出现显示不完全的问题，这个问题是由粘包导致的。

什么是粘包

首先说明一点 只有TCP有粘包现象
首先应该明白一点，数据发送端是将数据发送到发送端的缓存中，数据接收端是从接收端中的缓存中读取数据。
两端之间的数据的交互是基于TCP的，数据在两端之间是以数据流的形式存在的。那么怎么传输这个数据流呢？发送端为了将多个被发送的数据包更有效地发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。
若连续几次需要send的数据都很少，那么这些数据就会封装在一个包，而数据接收方不知道消息之间的界限，不知道一次性提取多少字节的数据。这就形成了 粘包
两种情况下会发生粘包

• 发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
• 接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

下面通过实例演示一下粘包现象

# client端
from socket import *

IP_PORT = ('127.0.0.1', 8080)

def sok_cli(ip_port):
    cc = socket(AF_INET, SOCK_STREAM)
    cc.connect(ip_port)

    cc.send('hello world'.encode('utf-8'))
    cc.send('sb'.encode('utf-8'))


if __name__ == '__main__':
    sok_cli(IP_PORT)

# server端
from socket import *

IP_PORT = ('127.0.0.1', 8080)

def sok_ser(ip_port):
    ss = socket(AF_INET, SOCK_STREAM)
    ss.bind(ip_port)
    ss.listen(5)

    conn, addr = ss.accept()

    data1 = conn.recv(1024)
    data2 = conn.recv(1024)

    print('data1: ', data1)
    print('data2: ', data2)

if __name__ == '__main__':
    sok_ser(IP_PORT)

在执行server端后执行client端，server端的打印结果如下所示

data1:  b'hello worldsb'
data2:  b''

可以看出所有数据粘在了一起，client端在第一次接受数据的过程中接收了全部数据，这属于第一种粘包现象。
下面，通过减下第一次接收数据的数据长度，模拟第一次接受数据接收不完全的现象。
将server端的data1 = conn.recv(1024) 改成 data1 = conn.recv(1) 得到的结果如下所示

data1:  b'h'
data2:  b'ello worldsb'

这属于第二种粘包现象
如果知道每次发送的数据的长度，可以确定数据间的边界，就可以解决粘包现象，下面详细阐述如何解决粘包。

如何解决粘包

解决办法就是，让数据接收方知道接收的数据的数据长度，那么就可以在发送数据前先发送一个报文头，报文头中包含数据长度等信息，为了保证数据接收方方便识别报文头，需要将报文头定制为统一长度，即每次数据接收方接收数据先解析固定长度的报文，提取报文头中的信息，用于读取后续的数据主体。
如何将报文头定制为固定长度呢，这里引入一个模块struct
struct模块
struct — 一个， 可以把一个类型(如数字)转成固定长度的bytes， 的神奇的模块
struct 模块有很多用于，这里不展开详细阐述，仅对用到的部分知识做简要介绍，通过下面的语句可以实现将数据打包为固定长度字节数据
head_len=struct.pack('i',len(head_bytes))
其中'i' 为固定语法，该参数表示打包后的字节数据长度为4
不粘包的远程执行命令程序

# server端
from socket import *
import subprocess
import struct

def sok_ser():
    socket_server = socket(AF_INET, SOCK_STREAM)
    socket_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 解决客户端断开后，server端进入TIME_WAIT的状态
    socket_server.bind(('127.0.0.1', 8080))
    socket_server.listen(5)

    while True:
        conn, addr = socket_server.accept()  # 链接循环

        while True:
            try:
                cmd = conn.recv(1024)
                if not cmd:
                    break
                res = subprocess.Popen(cmd.decode('utf-8'),
                                       shell=True,
                                       stdout=subprocess.PIPE,
                                       stderr=subprocess.PIPE)

                out_res = res.stdout.read()
                err_res = res.stderr.read()
                data_size = len(out_res) + len(err_res)
                # 发送报头
                head_size = struct.pack('i', data_size)
                conn.send(head_size)

                # 发送信息主体
                conn.send(out_res)
                conn.send(err_res)
            except Exception:
                break

        conn.close()

    socket_server.close()


if __name__ == '__main__':
    sok_ser()

# client端
from socket import *
import struct


def sok_cli(code_fmt):
    socket_client = socket(AF_INET, SOCK_STREAM)
    socket_client.connect(('127.0.0.1', 8080))

    while True:
        cmd = input(':>>')
        if not cmd:
            continue

        socket_client.send(bytes(cmd, encoding='utf-8'))

        # 收报头
        head_len = socket_client.recv(4)
        print('head_len', head_len)
        data_size = struct.unpack('i', head_len)[0]

        # 收数据
        recv_size = 0
        recv_data = b''
        while recv_size < data_size:
            data = socket_client.recv(1024)
            recv_size += len(data)
            recv_data += data

        print(recv_data.decode(code_fmt))

    socket_client.close()


if __name__ == '__main__':
    sok_cli('gbk')

改程序中数据由server端发出，client端接收，所以server端需要首先发送报头，client端在接收到报头后根据报头中数据的长度对数据进行循环接收。

基于TCP的socket编程—实现ftp功能

4. 基于UDP的socket编程