码迷，mamicode.com
首页 > 编程语言 > 详细

Learning-Python【28】：基于TCP协议通信的套接字

时间：2018-11-05 17:37:16      阅读：173      评论：0      收藏：0      [点我收藏+]

标签：建立   get   try   file   udp   type   star   进程   判断   

什么是 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)
socket模块函数用法
技术分享图片 
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 没有执行完的继续显示，这发生了什么？

技术分享图片

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

Learning-Python【28】：基于TCP协议通信的套接字

标签：建立   get   try   file   udp   type   star   进程   判断   

原文地址：https://www.cnblogs.com/qiuxirufeng/p/9904182.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！