网络编程与模块相关

Posted Sober--

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了网络编程与模块相关相关的知识,希望对你有一定的参考价值。

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的那几个函数中呢?请看下图:

image

                    图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中的四次握手释放连接的过程,请看下图:

image

                 图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 收到服务端发来的消息是  
View Code

 

实验过程中遇到的问题:

在重启服务端时可能会遇到如下报错:

  这个是由于你的服务端仍然存在四次挥手的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(\'以上是关于网络编程与模块相关的主要内容,如果未能解决你的问题,请参考以下文章

使用实体框架迁移时 SQL Server 连接抛出异常 - 添加代码片段

网络编程与模块相关

以编程方式将 GoogleMap 添加到片段

片段与另一个片段重叠

从零开始配置vim(27)——代码片段

包与模块