六、网络编程(socket编程)

一、客户端/服务器架设

1、硬件C/S架构(打印机)

2、软件C/S架构

  互连网各处是C/S架构

  比如百度网站是服务端,浏览器是客户端(B/S架构也是C/S架构的一种)

  腾讯作为服务端提供微信服务,要求下载微信安装包安装使用才足以去聊微信。

C/S架构与socket的关系:

  用socket就是为了成功C/S架构的花费

server端(必须听从的):

  1、地方必须稳定死,绑定一个定位的地址

  2、对外直接提供劳动,稳定运行

  3、协助并发(让多少个客户端感觉是同时被劳务着)

二、OSI七层

1、引子

事项一个完好无缺的总结机种类是由硬件、操作系统、应用软件三者结合,具备了那多个原则,一台微机连串就足以协调跟自己玩了(打个单机游戏,玩个扫雷)

假诺你要跟旁人一起玩,那您就需要上网了,什么是互连网?

互连网的大旨就是由一堆协议组成,协议就是规范,比如举世人通讯的专业是韩语

万一把电脑比作人,互连网协议就是总结机界的西班牙王国语。所有的微处理器都学会了网络协议,那拥有的处理器都就可以坚守联合的正式去收发音信之所以形成通讯了。

稠人广众根据分工分歧把网络协议从逻辑上划分了层级

2、OSI七层协议

互联网协议根据职能各异分为osi七层或tcp/ip五层或tcp/ip四层

 图片 1

每层运行常见物理设备

图片 2

1、物理层

物理层成效:首倘诺根据电器特性发送高低电压(电信号),高电压对应数字1,低电压对应数字0

 

2、数据链路层

数码链路层由来:单纯的电信号0和1尚未此外意义,必须确定电信号多少位一组,每组什么意思

多少链路层的功能:定义了电信号的分组办法

 

2.1 以太网协议:

最初的时候种种集团都有和好的分组办法,后来形成了统一的正规,即以太网协议ethernet

ethernet规定

  • 一组电信号构成一个数据包,叫做‘帧’
  • 每一数据帧分成:报头head和多少data两片段
       head                        data                             

 

head包含:(固定18个字节)

  • 发送者/源地址,6个字节
  • 收信人/目的地方,6个字节
  • 数据类型,6个字节

data包含:(最短46字节,最长1500字节)

  • 数据包的具体内容

head长度+data长度=最短64字节,最长1518字节,领先最大范围就分片发送

 

2.2 mac地址:

head中富含的源和目的地址由来:ethernet规定接入internet的装置都不可能不具有网卡,发送端和接收端的地方便是指网卡的地方,即mac地址

mac地址:每块网卡出厂时都被烧制上一个社会风气唯一的mac地址,长度为48位2进制,平日由12位16进制数表示(前六位是厂商编号,后六位是流水线号)

 

2.3 广播:

有了mac地址,同一网络内的两台主机就可以通讯了(一台主机通过arp协议得到此外一台主机的mac地址)

ethernet选用最原始的主意,广播的主意开展通信,即总括机通讯基本靠吼

 

3、网络层

网络层由来:有了ethernet、mac地址、广播的出殡方式,世界上的电脑就足以并行通讯了,难题是世界范围的网络是由

一个个相互隔离的小的局域网整合的,那么只要所有的通讯都利用以太网的播放方式,那么一台机械发送的包整个世界都会接收,

那就不仅仅是功效低的难题了,那会是一种苦难。

 

急需找出一种格局来区分哪些统计机属于同一广播域,哪些不是,固然是就应用广播的章程发送,假诺不是,

就采用路由的方式(向差别广播域/子网分发数据包),mac地址是不能区分的,它只跟厂商有关

网络层作用:引入一套新的地点用来分别差其余广播域/子网,那套地址即互联网地址。

3.1 IP协议:

  • 规定互连网地址的商议叫ip协议,它定义的地点称之为ip地址,广泛使用的v4版本即ipv4,它规定网络地址由32位2进制表示
  • 范围0.0.0.0-255.255.255.255
  • 一个ip地址寻常写成四段十进制数,例:172.16.10.1

3.2 ip地址分成两片段

  • 网络部分:标识子网
  • 主机部分:标识主机

只顾:单纯的ip地址段只是标识了ip地址的品类,从互连网部分或主机部分都爱莫能助辨认一个ip所处的子网

例:172.16.10.1与172.16.10.2并不可能确定双方处于同一子网

3.3 子网掩码

所谓”子网掩码”,就是象征子互联网特征的一个参数。它在格局上同一IP地址,也是一个32位二进制数字,它的网络部分一体为1,主机部分全体为0。比如,IP地址172.16.10.1,借使已知互连网部分是前24位,主机部分是后8位,那么子互连网掩码就是11111111.11111111.11111111.00000000,写成十进制就是255.255.255.0。

 

驾驭”子网掩码”,大家就能断定,任意多个IP地址是还是不是处于同一个子互联网。方法是将八个IP地址与子网掩码分别展开AND运算(多少个数位都为1,运算结果为1,否则为0),然后相比较结实是不是一律,假设是的话,就标志它们在同一个子网络中,否则就不是。

 

譬如,已知IP地址172.16.10.1和172.16.10.2的子网掩码都是255.255.255.0,请问它们是不是在同一个子网络?两者与子网掩码分别开展AND运算,

172.16.10.1:10101100.00010000.00001010.000000001

255255.255.255.0:11111111.11111111.11111111.00000000

AND运算得互连网地址结果:10101100.00010000.00001010.000000001->172.16.10.0

 

172.16.10.2:10101100.00010000.00001010.000000010

255255.255.255.0:11111111.11111111.11111111.00000000

AND运算得互连网地址结果:10101100.00010000.00001010.000000001->172.16.10.0

结果都是172.16.10.0,因而它们在同一个子互连网。

小结一下,IP协议的成效重点有五个,一个是为每一台电脑分配IP地址,另一个是确定哪些地点在同一个子网络。

3.4 ip数据包

ip数据包也分为head和data部分,无须为ip包定义单独的栏位,直接放入以太网包的data部分

 

head:长度为20到60字节

data:最长为65,515字节。

而以太网数据包的”数据”部分,最长唯有1500字节。因而,即使IP数据包超越了1500字节,它就要求分割成多少个以太网数据包,分开发送了。

 

以太网头                ip 头                                     ip数据                                

 

 

 *3.5 **ARP协议***

arp协议由来:总括机通讯基本靠吼,即广播的法门,所有上层的包到最终都要封装上以太网头,然后通过以太网协议发送,在谈及以太网协议时候,我门领悟到

通讯是按照mac的播音格局已毕,统计机在发包时,获取自我的mac是便于的,怎么着收获目的主机的mac,就需求通过arp协议

arp协议成效:广播的措施发送数据包,获取目的主机的mac地址

 

商事工作措施:每台主机ip都是已知的

例如:主机172.16.10.10/24访问172.16.10.11/24

一:首先通过ip地址和子网掩码区分出团结所处的子网

场景 数据包地址
同一子网 目标主机mac,目标主机ip
不同子网 网关mac,目标主机ip

 

 

 

二:分析172.16.10.10/24与172.16.10.11/24地处相同互联网(假如不是一样网络,那么下表中目的ip为172.16.10.1,通过arp获取的是网关的mac)

  源mac 目标mac 源ip 目标ip 数据部分
发送端主机 发送端mac FF:FF:FF:FF:FF:FF 172.16.10.10/24 172.16.10.11/24 数据

 

 

三:这些包会以广播的办法在发送端所处的自网内传输,所有主机接收后拆开包,发现目的ip为投机的,就响应,重临自己的mac

 

四、传输层

传输层的由来:互联网层的ip帮大家区分子网,以太网层的mac帮大家找到主机,然后大家利用的都是应用程序,你的总结机上或许同时打开qq,台风影音,等多个应用程序,

那么我们透过ip和mac找到了一台一定的主机,如何标识那台主机上的应用程序,答案就是端口,端口即应用程序与网卡关联的号子。

传输层功效:建立端口到端口的通讯

补给:端口范围0-65535,0-1023为系统占用端口

tcp协议:

保证传输,TCP数据包没有长度限制,理论上得以无限长,可是为了确保网络的频率,寻常TCP数据包的长度不会超越IP数据包的尺寸,以管教单个TCP数据包不必再划分。

以太网头 ip 头               tcp头               数据                                                    

 

udp协议:

不得靠传输,”报头”部分共计唯有8个字节,总长度不超越65,535字节,正好放进一个IP数据包。

以太网头 ip头                      udp头                            数据                                           

 

 

tcp一回握手和四遍挥手

图片 3

 

五、应用层

应用层由来:用户使用的都是应用程序,均工作于应用层,互联网是支付的,我们都可以付出协调的应用程序,数据各个多种,必须确定好数据的团队形式 

应用层成效:规定应用程序的数据格式。

例:TCP协议得以为各个种种的主次传递数据,比如Email、WWW、FTP等等。那么,必须有两样协商确定电子邮件、网页、FTP数据的格式,这几个应用程序协议就结成了”应用层”。

打听上述网络协议的目标:

1、基于socket编程,开发C/S架构的软件

2、C/S架构软件(软件属于应用层)是根据互联网开展通讯的

3、互联网的主导即为一堆协议,协议即规范,要开发基于网络通讯的软件就无法不听从那一个规范

三、socket编程

率先socket怎么去已毕互连网通讯的

图片 4

socket是什么:

咱俩平常把socket翻译为套接字,socket是在应用层和传输层之间的一个抽象层,它把TCP/IP层复杂的操作抽象为多少个简单的接口供应用层调用已兑现进程在互联网中通信。

Socket是应用层与TCP/IP协议族通讯的中等软件抽象层,它是一组接口。在设计情势中,Socket其实就是一个外衣情势,它把复杂的TCP/IP协议族隐藏在Socket接口后边,对用户来说,一组不难的接口就是一切,让Socket去协会数据,以合乎指定的协议。

故而,大家无需长远驾驭tcp/udp协议,socket已经为我们封装好了,大家只要求坚守socket的规定去编程,写出的次第自然就是依照tcp/udp标准的。

 

一、套接字发展史及分类

套接字源点于 20 世纪 70 年代佛蒙特大学Berkeley分校版本的
Unix,即人们所说的 BSD Unix。
由此,有时人们也把套接字称为“伯克利套接字”或“BSD
套接字”。一起先,套接字被规划用在同
一台主机上八个应用程序之间的通信。那也被称经过间通信,或
IPC。套接字有二种(或者叫做有多个种族),分别是依据文件型的和按照互连网型的。 

依据文件类型的套接字家族

套接字家族的名字:AF_UNIX

unix一切皆文件,基于文件的套接字调用的就是底层的文件系统来取数据,五个套接字进度运行在同一机器,可以通过访问同一个文件系统直接已毕通讯

据悉互联网项目标套接字家族

套接字家族的名字:AF_INET

(还有AF_INET6被用于ipv6,还有部分别样的地点家族,可是,他们照旧是只用于某个平台,要么就是已经被舍弃,或者是很少被应用,或者是常有没有落到实处,所有地方家族中,AF_INET是选用最常见的一个,python辅助很三种地点家族,可是出于我们只关切网络编程,所以一大半时候我么只利用AF_INET)

 

二、套接字工作流程

图片 5

先从劳动说起。服务器端先起初化socket,然后与端口绑定(bind),对端口举办监听(listen),调用accept
阻塞,等待客户端连接。此时如若有客户端初叶化一个socket,然后连接服务器,假若老是成功。客户端与服务端的连天就创设了。客户端发送数据请求,服务端接收请求并处理请求,然后把应对数据发送给客户端,客户端读取数据,最终关闭连接,三遍交互停止。

 

服务端套接字函数
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协议的套接字通讯

图片 6图片 7

import socket

#第一步:调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM

#第二步:绑定地址和端口
s.bind(('127.0.0.1',8080)) #ip应该是服务端这个软件运行那台机器的ip地址,port(0-65535)

#第三步:监听
s.listen(5) #半连接池:控制的是同一时刻的链接请求个数
print('服务端启动。。。')

#第四步:等待链接的请求
conn,client_addr=s.accept() #(套接字对象,存放有客户端的ip和端口的元组)
print(conn,client_addr)

#第五步:收/发消息
data=conn.recv(1024) #1024单位是bytes,代表最大接收1024bytes
print('收到消息',data)
conn.send(data.upper()) #发送大写的(接收到的结果)

#第六步:关闭链接
conn.close()

#第七步:关闭服务端对象
s.close()

服务端

图片 8图片 9

import socket

#第一步:调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM

#第二步:发起链接请求
s.connect(('127.0.0.1',8080)) #ip和port应该是服务端的ip和端口

#第三步:发/收消息
s.send('hello world'.encode('utf-8')) # 必须是bytes类型
data=s.recv(1024)  #接收消息单位是bytes,代表最大接收1024bytes
print('服务端消息:',data)

#第四步:关闭客户端对象
s.close()

客户端

基于TCP协议启动顺序必须是:

  先启动服务端 ———->  然后启动客户端

 

二、完成通信循环TCP的套接字通讯

图片 10图片 11

import socket

#1. 调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM
print(s)

#2. 绑定地址和端口

s.bind(('127.0.0.1',8080)) #ip应该是服务端这个软件运行那台机器的ip地址,port(0-65535)

#3. 监听
s.listen(5) #半连接池:控制的是同一时刻的链接请求数

print('服务端启动。。。')
#4. 等待链接的请求
conn,client_addr=s.accept() #(套接字对象,存放有客户端的ip和端口的元组)
print(conn,client_addr)

#5. 收\发消息
while True: #通信循环
    try: #处理异常步骤
        data=conn.recv(1024) #1024单位是bytes,代表最大接收1024bytes
        if len(data) == 0:break #针对linux或者mac。。。
        print('收到消息',data)
        conn.send(data.upper())
    except ConnectionResetError: ##针对windows
        break

#6. 关闭链接
conn.close()

#7. 关闭服务端对象
s.close()

服务端

图片 12图片 13

import socket

#1. 调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM

#2. 发送链接请求
s.connect(('127.0.0.1',8080)) #ip和port应该是服务端的ip和端口

#3,发\收消息
while True:
    msg=input('>>: ').strip()
    s.send(msg.encode('utf-8')) # 必须是bytes类型
    data=s.recv(1024)
    print('服务端消息:',data)

#4. 关闭
s.close()

客户端 

依据音讯的收发加上while循环 即落到实处了通讯间的轮回

唯独上述代码难点还有不少

三、TCP的链接循环(内部含通讯循环)

图片 14图片 15

import socket

#1. 调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM
print(s)

#2. 绑定地址和端口

s.bind(('127.0.0.1',8080)) #ip应该是服务端这个软件运行那台机器的ip地址,port(0-65535)

#3. 监听
s.listen(5) #半连接池:控制的是同一时刻的链接请求数

print('服务端启动。。。')
#4. 等待链接的请求
while True:  #链接循环
    conn,client_addr=s.accept() #(套接字对象,存放有客户端的ip和端口的元组)
    print(conn,client_addr)

    #5. 收\发消息
    while True: #通信循环
        try: #处理异常步骤
            data=conn.recv(1024) #1024单位是bytes,代表最大接收1024bytes
            if len(data) == 0:break #针对linux或者mac 。。。客户端强行终止处理异常
            print('收到消息',data)
            conn.send(data.upper())
        except ConnectionResetError: ##针对windows 。。。客户端强行终止处理异常
            break

    #6. 关闭链接
    conn.close()

#7. 关闭服务端对象
s.close()

服务端

图片 16图片 17

import socket

#1. 调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM

#2. 发送链接请求
s.connect(('127.0.0.1',8080)) #ip和port应该是服务端的ip和端口

#3,发\收消息
while True:
    msg=input('>>: ').strip()
    if  len(msg) == 0:continue  #客户端的的msg不能为空
    s.send(msg.encode('utf-8')) # 必须是bytes类型
    data=s.recv(1024)
    print('服务端消息:',data)

#4. 关闭
s.close()

客户端

此时程序就完毕了server端的 条件1和规则2

  1、地点必须稳定死,绑定一个原则性的地方

  2、对外直接提供服务,稳定运转

暂时完结持续并发的出力

 

五、模拟ssh远程执行命令

#=================================服务端============================================
import socket

#1. 调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM
#2. 绑定地址和端口
s.bind(('127.0.0.1',8080)) #ip应该是服务端这个软件运行那台机器的ip地址,port(0-65535)
#3. 监听
s.listen(5) #半连接池:控制的是同一时刻的链接请求数
print('服务端启动。。。')
#4. 等待链接的请求
while True:  #链接循环
    conn,client_addr=s.accept() #(套接字对象,存放有客户端的ip和端口的元组)
    print(conn,client_addr)

    #5. 收\发消息
    while True: #通信循环
        try: #处理异常步骤
            data=conn.recv(1024) #1024单位是bytes,代表最大接收1024bytes
            if len(data) == 0:break #针对linux或者mac 。。。客户端强行终止处理异常
            import subprocess #导入此模块实现执行操作系统命令
            obj=subprocess.Popen(data.decode('utf-8'),
                                 shell=True,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE)
            stdout=obj.stdout.read()
            stderr=obj.stderr.read()
            print(len(stdout) + len(stderr))
            conn.send(stdout + stderr)   #发送管道中正确输出和错误输出
        except ConnectionResetError: ##针对windows 。。。客户端强行终止处理异常
            break

    #6. 关闭链接
    conn.close()

#7. 关闭服务端对象
s.close()

# ===================================客户端=================================
import socket

#1. 调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM

#2. 发送链接请求
s.connect(('127.0.0.1',8080)) #ip和port应该是服务端的ip和端口

#3,发\收消息
while True:
    msg=input('>>: ').strip()
    if  len(msg) == 0:continue  #客户端的的msg不能为空
    s.send(msg.encode('utf-8')) # 必须是bytes类型
    data=s.recv(1024)
    print('服务端消息:',data.decode('gbk'))#操作系统的输出,编码时为gbk,所以解码也需要gbk

#4. 关闭
s.close()

 

那时候举办windows上的命令,例如dir  、 ping 127.0.0.1 
等。发现并未怎么难题

然则只要推行例如 tasklist  或 netstat -ano  等  就会发现有难点了

回去的输出值不可能三次取干净。在执行命令时,却取出了上三回命令的残存

上述顺序是基于tcp的socket,在运转时会暴发粘包问题

 

六、什么是粘包

前提:唯有TCP有粘包现象,UDP永远不会粘包

图片 18

#重启服务端时可能会遇到 “Addres already in use”
#这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址(如果不懂,请深入研究
1.tcp三次握手,四次挥手 
2.syn洪水攻击 
3.服务器高并发情况下会有大量的time_wait状态的优化方法)

#加入一条socket配置,重用ip和端口
s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它,在bind前加

#==============================================
发现系统存在大量TIME_WAIT状态的连接,通过调整linux内核参数解决,
vi /etc/sysctl.conf

编辑文件,加入以下内容:
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30

然后执行 /sbin/sysctl -p 让参数生效。

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 时间

 

上述图即为模拟ssh执行命令tasklist 配图

那时即爆发了粘包问题

发送端可以是一K一K地发送数据,而接收端的应用程序可以两K两K地提走数据,当然也有可能一遍提走3K或6K数量,或者五遍只提走多少个字节的数量,也就是说,应用程序所见到的数目是一个整机,或视为一个流(stream),一条音信有微微字节对应用程序是不可知的,因而TCP协议是面向流的说道,那也是便于并发粘包难题的原故。而UDP是面向消息的协商,每个UDP段都是一条音讯,应用程序必须以信息为单位领到数额,不可能一次提取任意字节的数目,那或多或少和TCP是很不相同的。怎样定义信息吧?可以认为对方三次性write/send的多少为一个音讯,须要了然的是当对方send一条音讯的时候,无论底层怎么样分段分片,TCP协议层会把构成整条音信的数据段排序达成后才显示在基础缓冲区。

譬如基于tcp的套接字客户端往服务端上传文件,发送时文件内容是遵循一段一段的字节流发送的,在接收方看了,根本不亮堂该文件的字节流从哪里开首,在何方停止

所谓粘包难点首要仍旧因为接收方不通晓新闻之间的无尽,不知道五遍性领取多少字节的数码所导致的。

除此以外,发送方引起的粘包是由TCP协议本身造成的,TCP为增强传输功能,发送方往往要搜集到丰富多的数额后才发送一个TCP段。若再而三几回索要send的多少都很少,平时TCP会按照优化算法把那个多少合成一个TCP段后五次发送出去,那样接收方就接受了粘包数据。

  1. TCP(transport
    control
    protocol,传输控制协议)是面向连接的,面向流的,提供高可信性服务。收发两端(客户端和劳动器端)都要有各类成对的socket,因而,发送端为了将几个发往接收端的包,更实用的发到对方,使用了优化措施(Nagle算法),将反复间隔较小且数据量小的数额,合并成一个大的数据块,然后举行封包。这样,接收端,就进退为难分辨出来了,必须提供不错的拆包机制。
    即面向流的通信是无新闻爱护边界的。
  2. UDP(user datagram
    protocol,用户数量报协议)是无连接的,面向新闻的,提供高成效服务。不会利用块的合并优化算法,,
    由于UDP协助的是一对多的形式,所以接收端的skbuff(套接字缓冲区)接纳了链式结构来记录每一个抵达的UDP包,在每个UDP包中就有了新闻头(新闻来源地址,端口等新闻),那样,对于接收端来说,就便于进行区分处理了。 即面向音讯的通讯是有信息尊敬边界的。
  3. tcp是依照数据流的,于是收发的音讯不可能为空,那就必要在客户端和服务端都添加空新闻的拍卖体制,幸免程序卡住,而udp是根据数据报的,即使是您输入的是空内容(直接回车),那也不是空新闻,udp协议会帮您封装上新闻头,实验略

udp的recvfrom是阻塞的,一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的多少就是已毕,假若y>x数据就不见,那象征udp根本不会粘包,不过会丢数据,不可相信

tcp的商议数据不会丢,没有收完包,下次吸收,会继续上次一气浑成接收,己端总是在吸收ack时才会去掉缓冲区内容。数据是有限支撑的,不过会粘包。

三种情景下会时有暴发粘包

1、发送端须要等缓冲区满才发送出去,造成粘包(时间间隔很短,数据量很小,会晤到联合,暴发粘包)

图片 19图片 20

import  socket
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(10)
data2=conn.recv(10)

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

服务端接收

图片 21图片 22

import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect(ip_port)


s.send('hello'.encode('utf-8'))
s.send('world'.encode('utf-8'))

客户端发送

 

2、接收方不马上接收缓冲区的包,造成三个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收时依然从缓冲区拿上次遗留的数额,暴发粘包)

图片 23图片 24

import socket
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(2) #一次没有收完整
data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

服务端接收

图片 25图片 26

import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect(ip_port)


s.send('hello world'.encode('utf-8'))

客户端发送

 

拆包的发出境况

当发送端缓冲区的长短超越网卡的MTU时,tcp会将这次发送的多寡拆成多少个数据包发送出去。

 

增补难题一:为什么tcp是可看重传输,udp是不行靠传输

基于tcp的多寡传输请参考我的另一篇作品http://www.cnblogs.com/linhaifeng/articles/5937962.html,tcp在数据传输时,发送端先把数据发送到自己的缓存中,然后协议控制将缓存中的数据发往对端,对端返回一个ack=1,发送端则清理缓存中的数据,对端返回ack=0,则重新发送数据,所以tcp是可靠的

而udp发送数据,对端是不会回去确认新闻的,由此不可信赖

 

补偿难点二:send(字节流)和recv(1024)及sendall

recv里指定的1024意思是从缓存里一次拿出1024个字节的数量

send的字节流是先放入己端缓存,然后由协和决定将缓存内容发往对端,即使待发送的字节流大小大于缓存剩余空间,那么数量丢失,用sendall就会循环调用send,数据不会丢掉

 

七、解决粘包难题的措施

为字节流加上自定义永恒长度报头,报头中带有字节流长度,然后两遍send到对端,对端在收受时,先从缓存中取出定长的报头,然后再取真实数据

struct 模块

该模块可以把一个档次,如数字,转成固定长度的bytes

import struct
res=struct.pack('i',123456)
print(res,len(res))
#b'@\xe2\x01\x00' 4

服务端:

#=================================服务端============================================
import socket,struct,json

#1. 调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM
#2. 绑定地址和端口
s.bind(('127.0.0.1',8080)) #ip应该是服务端这个软件运行那台机器的ip地址,port(0-65535)
#3. 监听
s.listen(5) #半连接池:控制的是同一时刻的链接请求数
print('服务端启动。。。')
#4. 等待链接的请求
while True:  #链接循环
    conn,client_addr=s.accept() #(套接字对象,存放有客户端的ip和端口的元组)
    print(conn,client_addr)

    #5. 收\发消息
    while True: #通信循环
        try: #处理异常步骤
            data=conn.recv(1024) #1024单位是bytes,代表最大接收1024bytes
            if len(data) == 0:break #针对linux或者mac 。。。客户端强行终止处理异常
            import subprocess #导入此模块实现执行操作系统命令
            obj=subprocess.Popen(data.decode('utf-8'),
                                 shell=True,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE)
            stdout=obj.stdout.read()
            stderr=obj.stderr.read()
            # 先制作报头
            header_dic = {
                'total_size': len(stdout) + len(stderr),
                'filename': 'a.txt'
            }
            header_json = json.dumps(header_dic)  #字典序列化成字符串
            header_bytes = header_json.encode('utf-8') #字符串编码成bytes类型

            # 先发送报头的长度(固定4个字节)
            conn.send(struct.pack('i', len(header_bytes)))

            # 再发送报头
            conn.send(header_bytes)

            # 最后发送真实的数据
            conn.send(stdout)   #发送管道中正确输出和错误输出
            conn.send(stderr)   #发送管道中正确输出和错误输出
        except ConnectionResetError: ##针对windows 。。。客户端强行终止处理异常
            break

    #6. 关闭链接
    conn.close()

#7. 关闭服务端对象
s.close()

客户端:

# ===================================客户端=================================
import socket,struct,json

#1. 调用socket产生s对象
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp流式协议=>SOCK_STREAM

#2. 发送链接请求
s.connect(('127.0.0.1',8080)) #ip和port应该是服务端的ip和端口

#3,发\收消息
while True:
    msg=input('>>: ').strip()
    if  len(msg) == 0:continue  #客户端的的msg不能为空
    s.send(msg.encode('utf-8')) # 必须是bytes类型
    # 先4个bytes,然后提取报头的长度
    header_size=struct.unpack('i',s.recv(4))[0]

    # 再根据报头的长度精准地收取报头,然后从报头提取报头字典
    header_bytes=s.recv(header_size)  #收报头(bytes)
    header_json=header_bytes.decode('utf-8')  #解码成字符串
    header_dic=json.loads(header_json)  #反序列化得到字典
    print(header_dic)

    total_size=header_dic['total_size']  #拿到字典中真实数据的长度
    # 最后接收真实数据
    res=b''
    recv_size=0
    while recv_size < total_size:
        data=s.recv(1024)
        res+=data
        recv_size+=len(data)
    print('服务端消息:',res.decode('gbk'))#操作系统的输出,编码时为gbk,所以解码也需要gbk

#4. 关闭
s.close()

咱俩得以把报头做成字典,字典里富含将要发送的真正数据的详细音讯,然后json序列化,然后用struck将系列化后的数目长度打包成4个字节(4个温馨丰富用了)

发送时:

先发报头长度

再编码报头内容然后发送

最终发真实内容

 

接收时:

先手报头长度,用struct取出来

依照取出的长短收取报头内容,然后解码,反体系化

从反系列化的结果中取出待取数据的详细音讯,然后去取真实的数码内容

 

八、socketserver模块已毕产出

 后续抽时间完成

相关文章