自动化运维Python系列（七）之Socket编程

32121111

了解知识点TCP\IP

要想理解socket首先得熟悉一下TCP/IP协议族， TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，定义了主机如何连入因特网及数据如何再它们之间传输的标准，

从字面意思来看TCP/IP是TCP和IP协议的合称，但实际上TCP/IP协议是指因特网整个TCP/IP协议族。不同于ISO模型的七个分层，TCP/IP协议参考模型把所有的TCP/IP系列协议归类到四个抽象层中（数据链路层和物理层可以统称为网络接入层）

OSI七层模型和TCP\IP四层参考模型

网络协议TCP\IP各层的作用

①     应用层：将一串应用程序产生的数据流传送到传输层

②     传输层：将应用程序的数据截成分组，加上TCP包头形成TCP段，交送网络层TCP UDP

③     网络层：将TCP段加上包括源、目的主机的IP地址和IP报头形成IP数据包，交送数据链路层

IP  ICMP  ARP  RARP

静态路由协议

动态路由协议 RIP（距离向量路由协议） OSPF（开放最短路径优先协议） ISIS（分级链路状态协议，类似OSPF） BGP（边界网关协议）

④     数据链路层：在MAC数据帧的数据部分装上IP数据包，再加上源、目的主机的MAC地址和帧头，根据其目的的MAC地址将帧送到目的主机或者路由

    应用层：TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet 等等

    传输层：TCP，UDP

    网络层：IP，ICMP，OSPF，EIGRP，IGMP

    数据链路层：SLIP，CSLIP，PPP，MTU

TCP协议三次握手和四次挥手断开

三次握手连接建立阶段

   1、客户端发送请求连接报文（SYN=1，seq=client_isn）,SYN=1表示请求连接，seq序列号随机生成

   2、服务端收到请求后，回复ACK报文，ACK为源seq=client_isc +1,以便回复给客户端后知晓自己的请求得到了回复

   3、客户端回复ACK报文确认建立连接，ACK报文为服务端seq=server_isc +1

四次挥手（断开连接过程）

   1、假设断开过程由客户端提出，则客户端发送FIN报文，意思说“我的clinet客户端没有数据要发送给你了，我要断开了”，状态变为（FIN_WAIT1）此时应用程序不会立即关闭socket，如果还有数据没传完可以继续传

   2、服务端收到FIN报文后，发送ACK，说“你的请求我知道了，但是我还没准备好，请等我消息”此时服务端状态变为（CLOSE_WAIT），客户端收到状态变为（FIN_WAIT2），服务端继续传输数据

   3、等服务端忙完了，就会发送FIN报文给客户端，表示“我忙完了，可以断开了”状态变为（LAST_ACK）

   4、客户端收到断开FIN报文后，就知道要关闭网络了，但是他还是不太相信网络，就会再次发送一个ACK给服务端，服务端收到以后就知道可以断开了，于是关闭连接；而客户端在等待2MSL(生命周期)大概1~4分钟时间后如果没再收到回复，就会主动关闭SOCKET关闭连接。

Socket

如果两个程序需要通信，我们需要一个能够来唯一标识这两个进程的办法：

本地：本地环境中，我们不需要考虑网络协议直接使用程序PID即可识别出两个不同的程序

网络：在网络环境中，我们可以使用 “IP地址 + 协议 + 端口号” 来区分网络中两个不同的程序

    socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信，通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求

    socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）

socket和file的区别：

• file模块是针对某个指定文件进行【打开】【读写】【关闭】
• socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】
  
  

python中简单socket通信模型

socket server服务端

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

#!/usr/bin/env python # -*- coding:utf-8 -*- import socket # 以元组形式定义一个IP地址和端口 ip_port = ('127.0.0.1',9999) # 创建对象并绑定IP地址 开始监听 sk = socket.socket() sk.bind(ip_port) sk.listen(5) # 开始接收消息 while True:     print 'server waiting...'     # conn 表示客户端与服务端建立连接后的专有通信线路     conn,addr = sk.accept()  # accept属于阻塞式，没有收到连接请求就不会继续向下运行     # 接收客户端发来的消息     client_data = conn.recv(1024) # recv也属于阻塞式     print client_data     # 回复消息     conn.sendall('收到收到 我是地瓜！')     # 关闭连接     conn.close()

socket client客户端

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

import socket ip_port = ('127.0.0.1',9999) sk = socket.socket()sk.connect(ip_port) sk.sendall('地瓜地瓜！我是南瓜...') server_reply = sk.recv(1024) print server_reply sk.close()

SOCKET模块功能介绍

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

#参数一：地址簇
　　socket.AF_INET IPv4（默认）　　socket.AF_INET6 IPv6
　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信
#参数二：类型
　　socket.SOCK_STREAM　　流式socket , for TCP （默认）　　
　　socket.SOCK_DGRAM　　 数据报式socket , for UDP
　　socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；
　　其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字
　　选项由用户构造IP头。　　
　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。
　　SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。
　　SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。　　
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务
#参数三：协议
　　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,
　　自动选择一个合适的协议

socket方法

sk.bind(address)

　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog)

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

      backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
      这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool)

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept()

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　关闭套接字

sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag])

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

      内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout)

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()

粘包问题

sk.recv(1024)中的1024是bufsize值（链路层协议EthernetII最大传输单元MTU值为1500），表示最大只能传输1024字节的数据，那么如果我们要发送的数据大于1024，server并不会丢弃这些数据，而是暂存在系统内核缓冲区，在下次需要返回结果的时候继续返回上次未完全返回的数据，就会出现在客户端执行一条命令，继续返回上一条命令结果的现象，这就成为粘包

粘包的解决办法

模拟HTTP请求流程

1）客户端请求数据

2）服务端计算返回数据字节数，发送给客户端

3）客户端收到总字节数，随便发出一个 ready 信号，告诉服务端可以开始发送数据

4）服务器发送数据

5）客户端开始多次循环接收，直到所有数据接收完成

socket服务端

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

import socket import subprocess ip_port = ('127.0.0.1', 9999) s = socket.socket() s.bind(ip_port) s.listen(5) while True:     conn, addr = s.accept()     while True:         try:             recv_data = conn.recv(1024)             if str(recv_data, encoding='utf-8') == 'exit':                 break             p = subprocess.Popen(str(recv_data, encoding='utf-8'), shell=True, stdout=subprocess.PIPE)             ret = p.stdout.read()             if len(ret) == 0:                 send_data = 'cmd error...'                 ret = bytes(send_data, encoding='utf-8')                 conn.send(ret)             else:                 ret = str(ret, encoding='gbk')                 ret = bytes(ret, encoding='utf8')                 # 返回总字节数给客户端                 read_tag = 'ready|%s' % len(ret)                 conn.send(bytes(read_tag, encoding='utf8'))                 # 确认客户端已经收到                 freedback = conn.recv(1024)                 if str(freedback, encoding='utf8') == 'start':                     conn.send(ret)         except Exception:             break     conn.close()

客户端

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

import socket ip_port = ('127.0.0.1', 9999) s = socket.socket() s.connect(ip_port) while True:     send_data = input('>>: ').strip()     if not send_data:         continue     else:         s.send(bytes(send_data, encoding='utf-8'))         if send_data == 'exit':             break         # 解决粘包问题         ready_tag = s.recv(1024)         if str(ready_tag, encoding='utf8').startswith('ready'):             msg_size = int(str(ready_tag, encoding='utf8').split('|')[-1])             s.send(bytes('start', encoding='utf8'))             recv_msg = b''             recv_size = 0             # 开始循环接收数据             while recv_size < msg_size:                 recv_data = s.recv(1024)                 recv_msg += recv_data                 recv_size += len(recv_data)                 print('MSG_SIZE:{} (RECV:{})'.format(msg_size, recv_size))             recv_data = str(recv_msg, encoding='utf-8')             print(recv_data)         else:             print(str(ready_tag, encoding='utf8')) s.close()