BS架构 (腾讯通软件:server+client)
CS架构 (web网站)
C/S架构与socket的关系:
我们学习socket就是为了完成C/S架构的开发
二、OSI七层模型
互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层
每层运行常见物理设备
详细参考:
http://www.cnblogs.com/linhaifeng/articles/5937962.html#_label4
学习socket一定要先学习互联网协议:
1.首先:本节课程的目标就是教会你如何基于socket编程,来开发一款自己的C/S架构软件
2.其次:C/S架构的软件(软件属于应用层)是基于网络进行通信的
3.然后:网络的核心即一堆协议,协议即标准,你想开发一款基于网络通信的软件,就必须遵循这些标准。
4.最后:就让我们从这些标准开始研究,开启我们的socket编程之旅
TCP/IP协议族包括运输层、网络层、链路层。
三、socket层(不懂看图就明白了)
Socket是介于应用层和传输层之间。
四、socket是什么
Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。
所以,我们无需深入理解tcp/udp协议,socket已经为我们封装好了,我们只需要遵循socket的规定去编程,写出的程序自然就是遵循tcp/udp标准的。
扫盲篇:
1 将socket说成ip+port,ip是用来标识互联网中的一台主机的位置,而port是用来标识这台机器上的一个应用程序,ip地址是配置到网卡上的,而port是应用程序开启的,ip与port的绑定就标识了互联网中独一无二的一个应用程序 2 3 而程序的pid是同一台机器上不同进程或者线程的标识(Google Chrome会有多个PID)
五、套接字工作流程
生活中的场景,你要打电话给一个朋友,先拨号,朋友听到电话铃声后提起电话,这时你和你的朋友就建立起了连接,就可以讲话了。等交流结束,挂断电话结束此次交谈。
生活中的场景就解释了这工作原理,也许TCP/IP协议族就是诞生于生活中,这也不一定。
先从服务器端说起。服务器端先初始化Socket,然后与端口绑定(bind),对端口进行监听(listen),调用accept阻塞,等待客户端连接。在这时如果有个客户端初始化一个Socket,然后连接服务器(connect),如果连接成功,这时客户端与服务器端的连接就建立了。客户端发送数据请求,服务器端接收请求并处理请求,然后把回应数据发送给客户端,客户端读取数据,最后关闭连接,一次交互结束。
1、socket模块发送和接收消息
示例:模拟发送消息和接收消息的过程
tcp服务端(server)
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 import socket 6 7 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机 8 phone.bind((\'127.0.0.1\',8000)) #绑定手机卡 #改成服务端网卡IP地址和端口 9 phone.listen(5) #开机 5的作用是最大挂起连接数 #backlog连接池(也叫半链接) 10 print(\'------------->\') 11 conn,addr=phone.accept() #等电话 12 13 msg=conn.recv(1024) #收消息 14 print(\'客户端发来的消息是:\',msg) 15 conn.send(msg.upper()) #发消息 16 17 conn.close() 18 phone.close()
执行结果:
1 ------------->
tcp客户端(client)
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 import socket 6 7 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) 8 9 phone.connect((\'127.0.0.1\',8000)) #拔通电话 #改成服务端网卡IP地址和端口 10 11 phone.send(\'hello\'.encode(\'utf-8\')) #发消息 12 data=phone.recv(1024) 13 print(\'收到服务端的发来的消息: \',data) 14 15 phone.close()
执行结果:
1 收到服务端的发来的消息: b\'HELLO\'
2、tcp三次握手和四次挥手
主动断开连接 :FIN_WAIT_1
被动断开连接: FIN_WAIT_2
马上断开连接: TIME_WAIT
socket中TCP的三次握手建立连接详解
流程如下:
- 客户端向服务器发送一个SYN J
- 服务器向客户端响应一个SYN K,并对SYN J进行确认ACK J+1
- 客户端再向服务器发一个确认ACK K+1
只有就完了三次握手,但是这个三次握手发生在socket的那几个函数中呢?请看下图:
图1、socket中发送的TCP三次握手
从图中可以看出,当客户端调用connect时,触发了连接请求,向服务器发送了SYN J包,这时connect进入阻塞状态;服务器监听到连接请求,即收到SYN J包,调用accept函数接收请求向客户端发送SYN K ,ACK J+1,这时accept进入阻塞状态;客户端收到服务器的SYN K ,ACK J+1之后,这时connect返回,并对SYN K进行确认;服务器收到ACK K+1时,accept返回,至此三次握手完毕,连接建立。
总结:客户端的connect在三次握手的第二个次返回,而服务器端的accept在三次握手的第三次返回。
socket中TCP的四次握手释放连接详解
上面介绍了socket中TCP的三次握手建立过程,及其涉及的socket函数。现在我们介绍socket中的四次握手释放连接的过程,请看下图:
图2、socket中发送的TCP四次握手
图示过程如下:
- 某个应用进程首先调用close主动关闭连接,这时TCP发送一个FIN M;
- 另一端接收到FIN M之后,执行被动关闭,对这个FIN进行确认。它的接收也作为文件结束符传递给应用进程,因为FIN的接收意味着应用进程在相应的连接上再也接收不到额外数据;
- 一段时间之后,接收到文件结束符的应用进程调用close关闭它的socket。这导致它的TCP也发送一个FIN N;
- 接收到这个FIN的源发送端TCP对它进行确认。
这样每个方向上都有一个FIN和ACK。
总结:
四次挥手断开连接原则:
记住一条原则:谁先发起客户端请求,谁先断开连接
但是在大并发情况下,大部分都是服务端先断开连接,不会保留连接。因为每一分钟都有很多人在访问网站。
3、socket()模块函数用法
1 import socket 2 socket.socket(socket_family,socket_type,protocal=0) 3 socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。 4 5 获取tcp/ip套接字 6 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 7 8 获取udp/ip套接字 9 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 10 11 由于 socket 模块中有太多的属性。我们在这里破例使用了\'from module import *\'语句。使用 \'from socket import *\',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。 12 例如tcpSock = socket(AF_INET, SOCK_STREAM)
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.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() 创建一个与该套接字相关的文件
六、基于TCP的套接字
tcp语法格式:
tcp服务端
1 ss = socket() #创建服务器套接字 2 ss.bind() #把地址绑定到套接字 3 ss.listen() #监听链接 4 inf_loop: #服务器无限循环 5 cs = ss.accept() #接受客户端链接 6 comm_loop: #通讯循环 7 cs.recv()/cs.send() #对话(接收与发送) 8 cs.close() #关闭客户端套接字 9 ss.close() #关闭服务器套接字(可选)
tcp客户端
1 cs = socket() #创建客户套接字 2 cs.connect() #尝试连接服务器 3 comm_loop: #通讯循环 4 cs.send()/cs.recv() #对话(发送/接收) 5 cs.close() #关闭客户套接字
1、基于tcp实现:客户端发送空格,服务端也会接收
示例:
tcp_server端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 7 ip_port = (\'127.0.0.1\', 8080) 8 back_log = 5 9 buffer_size = 1024 10 11 tcp_server = socket(AF_INET, SOCK_STREAM) 12 tcp_server.bind(ip_port) 13 tcp_server.listen(back_log) 14 15 print(\'服务端开始运行了\') 16 conn, addr = tcp_server.accept() #服务器阻塞 17 print(\'双向链接是\', conn) 18 print(\'客户端地址\', addr) 19 20 while True: 21 data = conn.recv(buffer_size) #收缓存为空,则阻塞 22 print(\'客户端发来的消息是\', data.decode(\'utf-8\')) 23 conn.send(data.upper()) 24 conn.close() 25 26 tcp_server.close()
tcp_client端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 7 ip_port = (\'127.0.0.1\', 8080) 8 back_log = 5 9 buffer_size = 1024 10 11 tcp_client = socket(AF_INET, SOCK_STREAM) 12 tcp_client.connect(ip_port) 13 14 while True: 15 msg = input(\'>>:\') #发送空格到自己的发送缓存中 16 # msg=input(\'>>:\').strip() #去掉空格 17 tcp_client.send(msg.encode(\'utf-8\')) 18 print(\'客户端已经发送消息\') 19 data = tcp_client.recv(buffer_size) #收缓存为空则阻塞 20 print(\'收到服务端发来的消息是\', data.decode(\'utf-8\')) 21 22 tcp_client.close()
执行结果:
1 server: 2 服务端开始运行了 3 双向链接是 <socket.socket fd=304, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(\'127.0.0.1\', 8080), raddr=(\'127.0.0.1\', 53365)> 4 客户端地址 (\'127.0.0.1\', 53365) 5 客户端发来的消息是 6 7 client: 8 >>: 9 客户端已经发送消息 10 收到服务端发来的消息是
实验过程中遇到的问题:
在重启服务端时可能会遇到如下报错:
这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址(如果不懂,请深入研究1.tcp三次握手,四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法)。
解决方法:
法一:在程序中处理
1 #加入一条socket配置,重用ip和端口 2 3 phone=socket(AF_INET,SOCK_STREAM) 4 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加 5 phone.bind((\'127.0.0.1\',8080))
法二:在linux系统中,通过调整系统内核参数的方式来解决
1 发现系统存在大量TIME_WAIT状态的连接,通过调整linux内核参数解决,(系统优化的一个优化点) 2 3 vi /etc/sysctl.conf 4 5 编辑文件,加入以下内容: 6 net.ipv4.tcp_syncookies = 1 7 net.ipv4.tcp_tw_reuse = 1 8 net.ipv4.tcp_tw_recycle = 1 9 net.ipv4.tcp_fin_timeout = 30 10 11 然后执行 /sbin/sysctl -p 让参数生效。 12 13 net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时,启用cookies来处理,可防范少量SYN攻击,默认为0,表示关闭; 14 15 net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接,默认为0,表示关闭; 16 17 net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收,默认为0,表示关闭。 18 19 net.ipv4.tcp_fin_timeout = 30 修改系統默认的 TIMEOUT 时间
七、基于UDP的套接字
udp语法格式:
udp服务端
1 ss = socket() #创建一个服务器的套接字 2 ss.bind() #绑定服务器套接字 3 inf_loop: #服务器无限循环 4 cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送) 5 ss.close()
udp客户端
1 cs = socket() # 创建客户套接字 2 comm_loop: # 通讯循环 3 cs.sendto()/cs.recvfrom() # 对话(发送/接收) 4 cs.close() # 关闭客户套接字
1、基于upd实现方法
示例:
udp_server端
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #Author: nulige
4
5 from socket import *
6 ip_port=(\'127.0.0.1\',8080)
7 buffer_size = 1024
8
9 udp_server = socket(AF_INET,SOCK_DGRAM) #数据报套接字
10 udp_server.bind(ip_port)
11
12 while True:
13 data,addr=udp_server.recvfrom(buffer_size)
14 print(data)
15
16 udp_server.sendto(data.upper(),addr) #upper() 小写变大写
udp_client端:
1 from socket import * 2 ip_port=(\'127.0.0.1\',8080) #服务端IP+端口 3 buffer_size = 1024 4 5 udp_client=socket(AF_INET,SOCK_DGRAM) #udp数据报套接字 6 7 while True: 8 msg=input(\'>>:\').strip() 9 udp_client.sendto(msg.encode(\'utf-8\'),ip_port) 10 #数据,ip地址+端口 11 data,addr=udp_client.recvfrom(buffer_size) 12 print(data.decode(\'utf-8\'))
执行结果:
先运行udp_server,再运行udp_client。
服务端返回结果:
1 b\'sfdsfds\' #bytes类型
2 b\'fdsfds\'
3 b\'fsdfds\'
4 b\'sdfdsf\'
在客户端输入:
1 >>:sfdsfds #在客户端输入 2 SFDSFDS #服务端返回的结果,把客户端输入的字符变大写 3 4 >>:fdsfds 5 FDSFDS 6 7 >>:fsdfds 8 FSDFDS
2、实现ntp时间服务器
示例:
tup_server端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 #实现ntp时间服务器 6 import time 7 from socket import * 8 ip_port=(\'127.0.0.1\',8080) 9 buffer_size = 1024 10 11 udp_server = socket(AF_INET,SOCK_DGRAM) #数据报套接字 12 udp_server.bind(ip_port) 13 14 while True: 15 data,addr=udp_server.recvfrom(buffer_size) 16 print(data) 17 18 if not data: 19 fmt=\'%Y-%m-%d %X\' #如果用户没有输入时间,就返回默认格式 20 else: 21 fmt=data.decode(\'utf-8\') 22 back_time=time.strftime(fmt) 23 24 udp_server.sendto(back_time.encode(\'utf-8\'),addr)
udp_client端
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 ip_port=(\'127.0.0.1\',8080) #服务端IP+端口 7 buffer_size = 1024 8 9 udp_client=socket(AF_INET,SOCK_DGRAM) #数据报套接字 10 11 while True: 12 msg=input(\'>>:\').strip() 13 udp_client.sendto(msg.encode(\'utf-8\'),ip_port) 14 15 data,addr=udp_client.recvfrom(buffer_size) 16 print(\'ntp服务器的标准时间是\',data.decode(\'utf-8\'))
执行结果:
运行udp_server,再运行udp_client,然后在udp_client里输入:
1 >>:%Y #在客户端输入%Y 2 ntp服务器的标准时间是 2017 #就会返回服务端的时间 3 >>:%m-%d-%Y 4 ntp服务器的标准时间是 01-03-2017 5 >>:
3、基于tcp实现远程执行命令
备注:因系统差异,请尽量把程序放在linux服务器上面运行,windows上面可能会报错。
socket_server_tcp服务端 (在linux上面运行)
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 import subprocess 7 8 ip_port = (\'192.168.1.135\', 8000) 9 back_log = 5 10 buffer_size = 1024 11 12 tcp_server = socket(AF_INET, SOCK_STREAM) 13 tcp_server.bind(ip_port) 14 tcp_server.listen(back_log) 15 16 while True: 17 conn,addr=tcp_server.accept() 18 print(\'新的客户端链接\',addr) 19 while True: 20 #收 21 try: 22 cmd=conn.recv(buffer_size) 23 #if not cmd:break MAC笔记本处理方法 24 print(\'收到客户端的命令\',cmd) 25 26 #执行命令,得到命令的运行结果cmd_res 27 res=subprocess.Popen(cmd.decode(\'utf-8\'),shell=True, 28 stderr=subprocess.PIPE, 29 stdout=subprocess.PIPE, 30 stdin=subprocess.PIPE) 31 err=res.stderr.read() 32 if err: 33 cmd_res=err 34 else: 35 cmd_res=res.stdout.read() 36 #发 37 conn.send(cmd_res) 38 except Exception as e: 39 print(e) 40 break 41 conn.close()
socket_client_tcp客户端(windows系统上面运行)
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 7 # ip_port = (\'127.0.0.1\', 8082) 8 ip_port = (\'192.168.1.135\', 8000) 9 back_log = 5 10 buffer_size = 1024 11 12 tcp_client = socket(AF_INET, SOCK_STREAM) 13 tcp_client.connect(ip_port) 14 15 while True: 16 cmd=input(\'>>:\').strip() 17 if not cmd:continue 18 if cmd == \'quit\':break 19 20 tcp_client.send(cmd.encode(\'utf-8\')) 21 cmd_res=tcp_client.recv(buffer_size) 22 # print(\'命令的执行结果是 \',cmd_res.decode(\'gbk\')) 23 print(\'命令的执行结果是 \',cmd_res.decode(\'utf-8\')) 24 tcp_client.close()
执行结果:
在客户端执行命令:
1 >>:df -h 2 命令的执行结果是 Filesystem Size Used Avail Use% Mounted on 3 /dev/sda3 9.6G 1.8G 7.3G 20% / 4 tmpfs 931M 0 931M 0% /dev/shm 5 /dev/sda1 190M 32M 149M 18% /boot 6 /dev/sr0 4.4G 4.4G 0 100% /opt 7 8 >>:dir 9 命令的执行结果是 s3.py server_ssh.py socket_server.py 10 server.py socket_clinet_udp.py socket_server_udp.py 11 12 服务端返回结果: 13 [root@python3 scripts]# python socket_server.py 14 新的客户端链接 (\'192.168.1.115\', 53569) 15 收到客户端的命令 b\'df -h\' 16 收到客户端的命令 b\'dir\'
4、基于udp实现远程执行命令
socket_server_udp服务端:
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 #Author: nulige 4 5 from socket import * 6 import subprocess 7 8 ip_port = (\'192.168.1.135\', 8000) 9 back_log = 5 10 buffer_size = 1024 11 12 udp_server = socket(AF_INET, SOCK_DGRAM) 13 udp_server.bind(ip_port) 14 15 while True: 16 cmd,addr=udp_server.recvfrom(buffer_size) 17 print(cmd) 18 19 #执行命令,得到命令的运行结果cmd_res 20 res = subprocess.Popen(cmd.decode(\'utf-8\'), shell=True, 21 stderr=subprocess.PIPE, 22 stdout=subprocess.PIPE, 23 stdin=subprocess.PIPE) 24 err = res.stderr.read() 25 if err: 26 cmd_res = err 27 else: 28 cmd_res = res.stdout.read() 29 30 if not cmd_res: # 判断为空的情况 31 cmd_res = \'执行成功\'.encode(\'以上是关于网络编程与模块相关的主要内容,如果未能解决你的问题,请参考以下文章