网络编程——socket编程
Posted 休耕
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了网络编程——socket编程相关的知识，希望对你有一定的参考价值。
一、C/S架构介绍
C/S架构 C：clint(客户端软件)
S：server(服务端软件)
python程序员是应用开发程序员，开发的软件都是应用软件，应用软件必须运行于操作系统之上，操作系统则运行于硬件上，应用软件不能直接操作硬件，应用软件对硬件的操作必须调用操作系统接口，由操作系统操作硬件。
客户端软件基于网络发送消息给服务端软件流程：
1、客户端软件产生数据，存放于客户端软件的内存中，然后调用接口将自己内存中的数据发送/拷贝给操作系统内存
2、客户端操作系统收到数据后，按照客户端软件指定的协议、调用网卡发送数据
3、网络传输数据
4、服务端软件调用系统接口，想要将数据从操作系统内存拷贝到自己的内存中
5、服务端操作系统受到4的指令后，使用与客户端相同的协议，从网卡接收到数据，然后拷贝给服务端软件
假设我现在要写一个程序，给另一台计算机发数据，必须通过tcp/ip协议 ，但具体的实现过程是什么呢？我应该怎么操作才能把数据封装成tcp/ip的包，又执行什么指令才能把数据发到对端机器上呢?
简而言之，socket这个东东干的事情，就是帮你把tcp/ip协议层的各种数据封装啦、数据发送、接收等通过代码已经给你封装好了，你只需要调用几行代码，就可以给别的机器发消息了。
二、计算机网络
计算机之间的通信首先要有物理链接介质，比如网线，交换机，路由器等网络设备。
通信的线路建好之后，只是物理层面有了可以承载数据的介质，要想通信，还需要我们按照某种规则组织我们的数据，这样对方在接收到数据后就可以按照相同的规则去解析出数据。
三、TCP/IP
按照功能不同，人们将互联网协议分为osi七层或tcp/ip五层或tcp/ip四层。
http://www.cnblogs.com/linhaifeng/articles/5937962.html#_label5
TCP/IP五层：
1、应用层：规定应用程序的数据格式。
2、传输层：建立端口到端口的通信
""" 端口范围0-65535，0-1023为系统占用端口 传输层有两种协议，TCP和UDP: tcp协议： 可靠传输，TCP数据包没有长度限制，理论上可以无限长，但是为了保证网络的效率，通常 TCP数据包的长度不会超过IP数据包的长度，以确保单个TCP数据包不必再分割。 udp协议： 不可靠传输，”报头”部分一共只有8个字节，总长度不超过65,535字节，正好放进一个IP数据包。 """
3、网络层：引入一套新的地址用来区分不同的广播域／子网，这套地址即网络地址
""" ip协议： 1、规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示 2、范围0.0.0.0-255.255.255.255 3、一个ip地址通常写成四段十进制数，例：172.16.10.1 子网掩码： 所谓”子网掩码”，就是表示子网络特征的一个参数。它在形式上等同于IP地址，也是一个32位二进制数字， 它的网络部分全部为1，主机部分全部为0。比如，IP地址172.16.10.1，如果已知网络部分是前24位， 主机部分是后8位，那么子网络掩码就是11111111.11111111.11111111.00000000，写成十进制就是255.255.255.0。 """
4、数据链路层：定义了电信号的分组方式，分组方式后来形成了统一的标准，即以太网协议ethernet
""" ethernet规定： 1、一组电信号构成一个数据包，叫做‘帧’ 2、每一数据帧分成：报头head和数据data两部分 head包含：(固定18个字节) 发送者／源地址，6个字节 接收者／目标地址，6个字节 数据类型，6个字节 data包含：(最短46字节，最长1500字节) 数据包的具体内容 head长度＋data长度＝最短64字节，最长1518字节，超过最大限制就分片发送 mac地址：（标识子网内，一台机器的位置） ethernet规定接入internet的设备都必须具备网卡，发送端和接收端的地址便是指网卡的地址，即mac地址 每块网卡出厂时都被烧制上一个世界唯一的mac地址，长度为48位2进制，通常由12位16进制数表示（前六位是厂商编号，后六位是流水线号） 广播： 有了mac地址，同一网络内的两台主机就可以通信了（一台主机通过arp协议获取另外一台主机的mac地址） ethernet采用最原始的方式，广播的方式进行通信，即计算机通信基本靠吼 ## 以太网协议基于MAC地址的广播，只能在局域网吼。## """
5、物理层：主要是基于电器特性发送高低电压(电信号)，高电压对应数字1，低电压对应数字0
四、OSI七层模型
OSI/RM模型(Open System Interconnection / Reference Model)的设计目的是成为一个所有计算机厂商都能实现的开放网络模型，来克服使用众多私有网络模型所带来的困难和低效性。
1、应用层 2、表示层 3、会话层
4、传输层
5、网络层
6、数据链路层
7、物理层
五、socket
Socket是应用层与TCP/IP协议族（传输层）通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。
也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序。
而程序的pid是同一台机器上不同进程或者线程的标识。
五、套接字发展和分类
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
# socket实例化方式 socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None) # proto=0 可忽略，特殊用途 # fileno=None 可忽略，特殊用途
1、基于文件类型的套接字家族
套接字家族名：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信。
2、基于网络类型的套接字家族
套接字家族名：AF_INET
所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET
3、socket type类型
socket.SOCK_STREAM #for tcp socket.SOCK_DGRAM #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 #废弃了
六、套接字工作流程
套接字工作流程图如下：
流程解析：服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。
1、socket(）模块函数用法
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 module import *\'语句。使用 \'from socket import *\',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。 例如tcpSock = socket(AF_INET, SOCK_STREAM)
2、服务端套接字函数
s.bind() 绑定(主机，端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接，（阻塞式）等待连接到来
3、客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本，出错时返回出错码，而不是抛出异常
4、公共用途的套接字函数
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() 关闭套接字
5、面向锁的套接字方法
s.setblocking() 设置套接字的阻塞与非阻塞模式
s.settimeout() 设置阻塞套接字操作的超时时间
s.gettimeout() 得到阻塞套接字操作的超时时间
6、面向文件的套接字的函数
s.fileno() 套接字的文件描述符
s.makefile() 创建一个与该套接字相关的文件
1：用打电话的流程快速描述socket通信 2：服务端和客户端加上基于一次链接的循环通信 3：客户端发送空，卡主，证明是从哪个位置卡的 服务端： from socket import * phone=socket(AF_INET,SOCK_STREAM) phone.bind((\'127.0.0.1\',8081)) phone.listen(5) conn,addr=phone.accept() while True: data=conn.recv(1024) print(\'server===>\') print(data) conn.send(data.upper()) conn.close() phone.close() 客户端： from socket import * phone=socket(AF_INET,SOCK_STREAM) phone.connect((\'127.0.0.1\',8081)) while True: msg=input(\'>>: \').strip() phone.send(msg.encode(\'utf-8\')) print(\'client====>\') data=phone.recv(1024) print(data) 说明卡的原因：缓冲区为空recv就卡住，引出原理图 4.演示客户端断开链接，服务端的情况，提供解决方法 5.演示服务端不能重复接受链接，而服务器都是正常运行不断来接受客户链接的 6:简单演示udp 服务端 from socket import * phone=socket(AF_INET,SOCK_DGRAM) phone.bind((\'127.0.0.1\',8082)) while True: msg,addr=phone.recvfrom(1024) phone.sendto(msg.upper(),addr) 客户端 from socket import * phone=socket(AF_INET,SOCK_DGRAM) while True: msg=input(\'>>: \') phone.sendto(msg.encode(\'utf-8\'),(\'127.0.0.1\',8082)) msg,addr=phone.recvfrom(1024) print(msg) udp客户端可以并发演示 udp客户端可以输入为空演示，说出recvfrom与recv的区别，暂且不提tcp流和udp报的概念，留到粘包去说
七、基于TCP的套接字
tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端
服务端：
import socket # 1、买手机 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 # print(phone) """ <socket.socket fd=3, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(\'0.0.0.0\', 0)> """ # 2、绑定手机卡 phone.bind((\'127.0.0.1\', 9001)) # 本地回环地址, 端口0-65535（0-1024归系统使用） # 3、开机 phone.listen(5) # 最大挂起的链接数 # 4、等电话链接 print(\'starting...\') # res = phone.accept() # 程序卡在这一步 # print(res) # res包含链接对象 """ starting... ===》 (<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(\'127.0.0.1\', 8080), raddr=(\'127.0.0.1\', 55868)>, (\'127.0.0.1\', 55868)) """ # 改写分拆两个元组元素 conn, client_addr = phone.accept() print(conn) print(client_addr) print(\'got a new connection from %s\' % (client_addr, )) """ <socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(\'127.0.0.1\', 8080), raddr=(\'127.0.0.1\', 55925)> (\'127.0.0.1\', 65197) got a new connection from (\'127.0.0.1\', 65197) """ # 5、收发消息 data = conn.recv(1024) # 1、单位是bytes 2、1024代表接收数据的最大数是1024个bytes print(\'客户端数据\', data) conn.send(data.upper()) # 数据修改为大写后发送 # 6、挂电话 conn.close() # 7、关机 phone.close() """ 客户端数据 b\'hello\' """
客户端：
import socket # 1、买手机 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 #print(phone) # 2、拨号 phone.connect((\'127.0.0.1\', 8080)) # 服务端先启动后启动客户端 # 3、发、收消息 phone.send(\'hello\'.encode(\'utf-8\')) data = phone.recv(1024) print(data) # 4、关闭 phone.close() """ b\'HELLO\' """
上面是以打电话为例实现了一个low版的套接字通信，但是如果需要多次发送，需要加上通信循环。
import socket # 1、买手机 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 # 2、绑定手机卡 phone.bind((\'127.0.0.1\', 8080)) # 本地回环地址, 端口0-65535（0-1024归系统使用） # 3、开机 phone.listen(5) # 最大挂起的链接数（TCP协议需要） # 4、等电话链接 print(\'starting...\') conn, client_addr = phone.accept() # accept是建立链接 print(client_addr) # 客户端一启动打印 （\'127.0.0.1\',56641） # 5、收发消息 while True: # 通信循环 data = conn.recv(1024) # 1、单位是bytes 2、1024代表接收数据的最大数是1024个bytes print(\'客户端数据\', data) conn.send(data.upper()) # 数据修改为大写后发送 # 6、挂电话 conn.close() # 7、关机 phone.close() """ starting... (\'127.0.0.1\', 56641) 客户端数据 b\'hello\' 客户端数据 b\'xiugeng\' """
import socket # 1、买手机 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 #print(phone) # 2、拨号 phone.connect((\'127.0.0.1\', 8080)) # 服务端先启动后启动客户端 # 3、发、收消息 while True: # 通信循环 msg = input(\'>>:\').strip() phone.send(msg.encode(\'utf-8\')) data = phone.recv(1024) # 收到服务端大写之后的字符 print(data) # 4、关闭 phone.close() """ >>:hello b\'HELLO\' >>:xiugeng b\'XIUGENG\' """
解决重启服务端时，服务端仍存在四次挥手的time_wait状态占用地址的情况（深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法），无法重启服务端，修改代码如下：
import socket phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 解决重启服务端时，服务端仍存在四次挥手的time_wait状态占用地址的情况： # 方法一：加入一条socket配置，重用ip和端口 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 在bind前，启动关闭服务端时，系统端口没有回收，可以重用端口 # 方法二：调整linux内核参数 """ 在 /etc/sysctl.conf文件中添加： net.ipv4.tcp_syncookies = 1 # 表示开启SYN Cookies，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭 net.ipv4.tcp_tw_reuse = 1 # 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭 net.ipv4.tcp_tw_recycle = 1 #表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭 net.ipv4.tcp_fin_timeout = 30 # 修改系统默认的TIMEOUT时间 执行 /sbin/sysctl -p让参数生效 """ phone.bind((\'127.0.0.1\', 8080)) phone.listen(5) # 最大挂起的链接数 print(\'starting...\') conn, client_addr = phone.accept() print(client_addr) while True: # 通信循环 try: data = conn.recv(1024) # 客户端发出空消息，服务端没有收到 if not data:break # # 适用与Linux操作系统 print(\'客户端数据\', data) conn.send(data.upper()) except ConnectionResetError: # 适用于windiws的操作系统 break conn.close() phone.close()
import socket phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 phone.connect((\'127.0.0.1\', 8080)) # 服务端先启动后启动客户端 while True: # 通信循环 msg = input(\'>>:\').strip() # msg=\'\' # 修改办法 if not msg:continue # 输入空，不发送消息 phone.send(msg.encode(\'utf-8\')) # phone.send(b\'\') # print(\'has send\') # 定位不能发空的缘故 data = phone.recv(1024) # 服务端没有回消息，因此收不到消息 print(data.decode(\'utf-8\')) phone.close()
net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭； net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭； net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。 net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间
添加链接循环，当上一个链接结束后，等待下一个客户端接入。
import socket """ 需要服务端一直提供服务， """ 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) # 最大挂起的链接数 print(\'starting...\') """ 需要服务端一直提供服务，再添加一个循环。服务端的工作主要是：1、建立链接；2、通信 需要注意的是：服务端可以一直提供服务，但是不能并发。只有等前一个链接断了后，下一个客户端才能链接 """ while True: # 链接循环 # 创建链接 conn, client_addr = phone.accept() print(client_addr) while True: # 通信循环 try: data = conn.recv(1024) if not data:break print(\'客户端数据\', data) conn.send(data.upper()) except ConnectionResetError: break conn.close() phone.close()
import socket phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 phone.connect((\'127.0.0.1\', 8080)) # 服务端先启动后启动客户端 while True: # 通信循环 msg = input(\'>>:\').strip() # msg=\'\' # 修改办法 if not msg:continue # 输入空，不发送消息 phone.send(msg.encode(\'utf-8\')) # phone.send(b\'\') # print(\'has send\') # 定位不能发空的缘故 data = phone.recv(1024) # 服务端没有回消息，因此收不到消息 print(data.decode(\'utf-8\')) phone.close()
八、subprocess模块
之前学过os模块来执行系统命令：
import os cmd = os.popen(\'df -h\') cmd = cmd.read() print(cmd)
subprocess命令执行的结果就是bytes，无需转变格式就可以给客户端、服务端使用。
import subprocess obj = subprocess.Popen(\'dxxxs\', shell=True, stdout=subprocess.PIPE, # stdout:正确结果;管道 stderr=subprocess.PIPE) # stderr:错误结果;管道 print(obj) print(\'stdout 1---->: \', obj.stdout.read().decode(\'utf-8\')) # 正确管道内容 print(\'stderr 1---->: \', obj.stderr.read().decode(\'utf-8\')) # 错误管道内容 """ <subprocess.Popen object at 0x10401ada0> stdout 1---->: stderr 1---->: /bin/sh: dxxxs: command not found """
九、基于UDP协议的套接字
udp不需要经过3次握手和4次挥手，不需要提前建立链接，直接发送数据即可。
服务端：
# import socket from socket import * # 尽量少用这种导入方式，会将所有名字加入名称空间，容易导致重复 # server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 可以看到需要引用的socket的模块非常多。改用from socket import *导入 server = socket(AF_INET, SOCK_DGRAM) # SOCK_STREAM指的流式协议，SOCK_DGRAM指得是数据报协议（但凡发数据，就已经是完整的数据报） server.bind((\'127.0.0.1\', 8080)) # server.listen(5) # 挂起的链接数，TCP协议需要，UDP不需要 # while True: # conn, addr = server.accept() # 用来建立链接，UDP不需要 while True: data, client_addr = server.recvfrom(1024) # 收消息 print(data) server.sendto(data.upper(), client_addr) # 发消息，取收消息的地址 server.close()
客户端：
from socket import * client = socket(AF_INET, SOCK_DGRAM) while True: msg = input(\'>>: \').strip() client.sendto(msg.encode(\'utf-8\'), (\'127.0.0.1\', 8080)) # 发消息 data, server_addr = client.recvfrom(1024) # 收消息 print(data, server_addr) client.close()
以qq聊天为例：
import socket ip_port=(\'127.0.0.1\',8081) udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机 udp_server_sock.bind(ip_port) while True: qq_msg,addr=udp_server_sock.recvfrom(1024) print(\'来自[%s:%s]的一条消息:\\033[1;44m%s\\033[0m\' %(addr[0],addr[1],qq_msg.decode(\'utf-8\'))) back_msg=input(\'回复消息: \').strip() udp_server_sock.sendto(back_msg.encode(\'utf-8\'),addr)
import socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) qq_name_dic={ \'狗哥alex\':(\'127.0.0.1\',8081), \'瞎驴\':(\'127.0.0.1\',8081), \'一棵树\':(\'127.0.0.1\',8081), \'武大郎\':(\'127.0.0.1\',8081), } while True: qq_name=input(\'请选择聊天对象: \').strip() while True: msg=input(\'请输入消息,回车发送: \').strip() if msg == VSCode自定义代码片段——JS中的面向对象编程