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(\'以上是关于网络编程与模块相关的主要内容，如果未能解决你的问题，请参考以下文章