基于TCP协议通信的套接字

什么是 Socket

Socket 是应用层与 TCP/IP 协议通信的中间软件抽象层，它是一组接口。在设计模式中，Socket 其实就是一个门面模式，它把复杂的 TCP/IP 协议族隐藏在 Socket 接口后面，对用户来说，一组简单的接口就是全部，让 Socket 去组织数据，以符合指定的协议。

所以，我们无需深入理解 TCP/UDP 协议，socket 已经为我们封装好了，我们只需要遵循 socket 的规定去编程，写出的程序自然就是遵循 TCP/UDP 标准的。

套接字的分类：

　　基于文件类型的套接字家族：AF_UNIX（在 Unix 系统上，一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程同时运行在同一机器，可以通过访问同一个文件系统间接完成通信）

　　基于网络类型的套接字家族：AF_INET（Python 支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我们只使用 AF_INET）

基于 TCP 协议的 socket

工作流程：

下面我们举个打电话的小例子来说明一下

如果你要给你的一个朋友打电话，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。 生活中的场景就解释了这工作原理。

（如果你去一家餐馆吃饭，假设那里的老板就是服务端，而你自己就是客户端，当你去吃饭的时候，你肯定的知道那个餐馆，也就是服务端的地址，但是对于你自己来说，餐馆的老板不需要知道你的地址）

服务端：
1）创建套接字描述符（socket）
2）设置服务器的 IP 地址和端口号（需要转换为网络字节序的格式）
3）将套接字描述符绑定到服务器地址（bind）
4）将套接字描述符设置为监听套接字描述符（listen），等待来自客户端的连接请求，监听套接字维护未完成连接队列和已完成连接队列
5）从已完成连接队列中取得队首项，返回新的已连接套接字描述符（accept），如果已完成连接队列为空，则会阻塞
6）从已连接套接字描述符读取来自客户端的请求（read / recv）
7）向已连接套接字描述符写入应答（write / send）
8）关闭已连接套接字描述符（close），回到第 5 步等待下一个客户端的连接请求

 服务端必须满足至少三点：

　　1）绑定一个固定的 IP 和端口号

　　2）一直对外提供服务，稳定运行

　　3）能够支持并发

客户端：
1）创建套接字描述符（socket）
2）设置服务器的 IP 地址和端口号（需要转换为网络字节序的格式）
3）请求建立到服务器的 TCP 连接并阻塞，直到连接成功建立（connect）
4）向套接字描述符写入请求（write / send）
5）从套接字描述符读取来自服务器的应答（read / recv）
6）关闭套接字描述符（close）

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

获取TCP/IP套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

获取UDP/IP套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 1. 服务端套接字函数
phone.bind('主机ip地址', 端口号)  # 绑定到（主机，端口号）套接字
phone.listen()  # 开始TCP监听
phone.accept()  # 被动接受TCP客户的连接，等待连接的到来

# 2. 客户端套接字函数
import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买手机
phone.connect()  # 主动连接服务端的ip和端口
phone.connect_ex()  # connect()函数的扩展版本，出错的时候返回错码，而不是抛出异常

# 3. 服务端和客户端的公共用途的嵌套字函数
phone.recv()  # 接受TCP数据
phone.send()  # 发送TCP数据
phone.recvfrom()  # 接受UDP数据
phone.sendto()  # 发送UDP数据
phone.getpeername()  # 接收到当前套接字远端的地址
phone.getsockname()  # 返回指定套接字的参数
phone.setsockopt()  # 设置指定套接字的参数
phone.close()  # 关闭套接字

# 面向锁的套接字方法
phone.setblocking()  # 设置套接字的阻塞与非阻塞模式
phone.settimeout()  # 设置阻塞套接字操作的超时时间
phone.gettimeout()  # 得到阻塞套接字操作的超时时间

# 面向文件的套接字函数
phone.fileno()  # 套接字的文件描述符
phone.makefile()  # 创建一个与该套接字相关的文件

TCP是基于链接的，必须先启动服务器，然后再启动客户端去链接服务端

简单版

import socket

# 1. 创建套接字描述符, 用来建立链接
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(phone)

# 2. 设置IP和端口号, 绑定套接字描述符
phone.bind(("127.0.0.1", 8080))

# 3. 将套接字描述符设置为监听状态, 设置同一时刻最大请求数为5
phone.listen(5)

print("start...")
# 4. 等待来自客户端的连接
conn, client_addr = phone.accept()
# accept有返回值，是一个元组
# 元组的第一个参数是双向链接的套接字对象(即三次握手的结果), 用来收发消息
# 第二个参数是一个元组，存放客户端的IP和端口号
# print(conn)
# print(client_addr)

# 5. 收/发消息, 1024是接收的最大字节数bytes
data = conn.recv(1024)
print("收到客户端的数据", data)
conn.send(data.upper())

# 6. 关闭双向链接的套接字对象
conn.close()

# 7. 关闭套接字描述符
phone.close()

import socket

# 1. 创建套接字描述符
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 2. 连接服务端的IP地址和端口号
phone.connect(("127.0.0.1", 8080))

# 3. 发/收消息
phone.send("hello".encode("utf-8"))    # 只能发bytes类型
data = phone.recv(1024)
print("收到服务端的消息", data)

# 4. 关闭套接字描述符
phone.close()

由于 socket 模块中有太多的属性。在这里破例使用了 'from module import *' 语句。使用 'from socket import *'，就把 socket 模块里的所有属性都带到命名空间里了，这样能大幅减短代码。
例如 tcpSock = socket(AF_INET, SOCK_STREAM)

通信循环

from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind(("127.0.0.1", 8080))
server.listen(5)

conn, client_addr = server.accept()

# 通信循环
while True:
    data = conn.recv(1024)
    conn.send(data.upper())

conn.close()
server.close()

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(("127.0.0.1", 8080))

# 通信循环
while True:
    msg = input("请输入: ").strip()
    client.send(msg.encode("utf-8"))
    data = client.recv(1024)
    print(data)

client.close()

但是这样写有一个 bug，当你手动结束客户端的程序运行时，服务端也会跟着崩溃

因为 conn 代表的是一个双向连接，只有服务端和客户端都正常运行的时候，conn 才有意义，然而此时客户端是非正常的断开，服务端还在使用没有意义的 conn 做 recv 操作，无法收到消息，所以在 Windows 上直接崩溃，而在 Linux 上，相同的操作服务端会一直处于收空的状态

补救措施是，在 Windows 系统上捕捉异常，在 Linux 系统上加上判断

from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind(("127.0.0.1", 8080))
server.listen(5)

conn, client_addr = server.accept()

# 通信循环
while True:
    try:
        data = conn.recv(1024)
        # 针对Linux系统
        if len(data) == 0:
            break
        conn.send(data.upper())

    except ConnectionResetError:
        break

conn.close()
server.close()

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(("127.0.0.1", 8080))

# 通信循环
while True:
    msg = input("请输入: ").strip()
    client.send(msg.encode("utf-8"))
    data = client.recv(1024)
    print(data)

client.close()

链接通信循环

这样虽然解决了崩溃问题，但是当手动结束客户端时，服务端还是会跟着结束，所以在服务端等待客户端的连接前加上循环，从而达到 “链接 + 通信” 循环

from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind(("127.0.0.1", 8080))
server.listen(5)

# 链接循环
while True:
    conn, client_addr = server.accept()

    # 通信循环
    while True:
        try:
            data = conn.recv(1024)
            # 针对Linux系统
            if len(data) == 0:
                break
            conn.send(data.upper())

        except ConnectionResetError:
            break

    conn.close()
server.close()

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(("127.0.0.1", 8080))

# 通信循环
while True:
    msg = input("请输入: ").strip()
    client.send(msg.encode("utf-8"))
    data = client.recv(1024)
    print(data)

client.close()

但这样做，服务端每次只能针对于一个客户端，只有当这个客户端的收发消息结束后才能给下一个客户端服务，无法达到并发的效果，这个后面学到并发时再讲

其实还有一个问题，当客户端传一个空消息时，会发生阻塞状态，因为发空的时候服务端时无法收到的（空时是什么都没有），服务端收不到，无法返回给客户端，所以客户端处于阻塞状态。补救方法是不让客户端输入空

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(("127.0.0.1", 8080))

# 通信循环
while True:
    msg = input("请输入: ").strip()
    if len(msg) == "0":
        continue
    client.send(msg.encode("utf-8"))
    data = client.recv(1024)
    print(data)

client.close()

from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind(("127.0.0.1", 8080))
server.listen(5)

# 连接循环
while True:
    conn, client_addr = server.accept()

    # 通信循环
    while True:
        try:
            data = conn.recv(1024)
            # 针对Linux系统
            if len(data) == 0:
                break
            conn.send(data.upper())

        except ConnectionResetError:
            break

    conn.close()
server.close()

 模拟ssh实现远程执行命令

当使用客户端远程连接服务器时，在客户端上执行命令，服务器会返回命令执行的结果给客户端，那么该如何实现呢？

from socket import *
import subprocess

server = socket(AF_INET, SOCK_STREAM)
server.bind(("127.0.0.1", 8080))
server.listen(5)

# 连接循环
while True:
    conn, client_addr = server.accept()

    # 通信循环
    while True:
        try:
            cmd = conn.recv(1024)  # cmd = b'dir'
            #             # 针对Linux系统
            if len(cmd) == 0:
                break
            # 命令的执行结果
            obj = subprocess.Popen(cmd.decode("utf-8"),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()
            conn.send(stdout + stderr)

        except ConnectionResetError:
            break

    conn.close()
server.close()

import socket

# 1. 创建套接字描述符
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 2. 连接服务端的IP地址和端口号
phone.connect(("127.0.0.1", 8080))

# 3. 发/收消息
phone.send("hello".encode("utf-8"))    # 只能发bytes类型
data = phone.recv(1024)
print("收到服务端的消息", data)

# 4. 关闭套接字描述符
phone.close()

但是目前这样有一个局限性，我将接收端数据的最大字节数设置为1024，当发送端发的数据量小于接收端的1024时，可以被完全接收，但是发送端的数据量大于1024时，就只能接收1024条数据，那么多出的那些数据该如何处理呢？

首先客户端发送一条执行命令给服务端，让服务端接收，这里命令的字节数大多数情况不会大于1024，所以可以被完全接收，暂不考虑，当服务端接收了命令执行后，会将命令的执行结果发送给客户端，让客户端接收，这里命令的执行结果是很有可能大于1024个字节的，例如：tasklist，在终端上显示的最后一条是自己，而在上面所写的两个文件中只能显示几条结果，很显然是大于1024的

但这时再输入 dir 时，竟然是 tasklist 没有执行完的继续显示，再输入其它命令，还是 tasklist 没有执行完的继续显示，这发生了什么？

这就是待解决的粘包问题，下一节将会学习