网络编程——socket开发

Socket套接字方法

 

阅读目录

socket 实例类(8-10分钟)

socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)

 family***(*socke*t家族)***

  • socket.AF_UNIX:用于本机进程间通讯,为了保证程序安全,两个独立的程序(进程)间是不能互相访问彼此的内存的,但为了实现进程间的通讯,可以通过创建一个本地的socket来完成
  • socket.AF_INET:(还有AF_INET6被用于ipv6,还有一些其他的地址家族,不过,他们要么是只用于某个平台,要么就是已经被废弃,或者是很少被使用,或者是根本没有实现,所有地址家族中,AF_INET是使用最广泛的一个,python支持很多种地址家族,但是由于我们只关心网络编程,所以大部分时候我么只使用AF_INET)

 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 #废弃了

(Only SOCK_STREAM and SOCK_DGRAM appear to be generally useful.)

 proto=0 请忽略,特殊用途

 fileno=None 请忽略,特殊用途

  • 一 客户端/服务器架构
  • 二 osi七层
  • 三 socket层
  • 四 socket是什么
  • 五 套接字发展史及分类
  • 六 套接字工作流程
  • 七 基于TCP的套接字
  • 八 基于UDP的套接字
  • 九 recv与recvfrom的区别
  • 十 粘包现象
  • 十一 什么是粘包
  • 十二 低级的解决粘包处理方法
  • 十三 高级的解决粘包处理方法
  • 十四 认证客户端的链接合法性
  • 十五 socketserver实现并发

服务端套接字函数(2分钟)

  • s.bind()
    绑定(主机,端口号)到套接字
  • s.listen()
    TCP开始监听传入连接。backlog指定在拒绝连接之前,可以挂起的最大连接数量。 backlog等于5,表示内核已经接到了连接请求,但服务器还没有调用accept进行处理的连接个数最大为5, 这个值不能无限大,因为要在内核中维护连接队列
  • s.accept()
    被动接受TCP客户的连接,(阻塞式)等待连接的到来 

  服务程序调用accept函数从处于监听状态的流套接字s的客户连接请求队列中取出排在最前的一个客户请求,并且创建一个新的套接字来与客户套接字创建连接通道,如果连接成功,就返回新创建的套接字的描述符,以后与客户套接字交换数据的是新创建的套接字;如果失败就返回 INVALID_SOCKET。该函数的第一个参数指定处于监听状态的流套接字;操作系统利用第二个参数来返回新创建的套接字的地址结构;操作系统利用第三个参数来返回新创建的套接字的地址结构的长度。

 

 

客户端套接字函数(2分钟)

  • s.connect()
    主动初始化TCP服务器连接
  • s.connect_ex()
    connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

一. 客户端/服务器架构

  1. 两种情况
  • C/S架构
     客户端/服务器端(打印机)
  • B/S架构
     浏览器/服务器端(web服务)

C/S架构与socket的关系:我们学习socket就是为了完成C/S架构的开发

 

公共用途的套接字函数(3-5分钟)

  • s.recv()
    接收数据
  • s.send()
    发送数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完,可后面通过实例解释)
  • s.sendall()
    发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
  • s.recvfrom()
    Receive data from the socket. The return value is a pair (bytes,
    address)
  • s.getpeername()
    连接到当前套接字的远端的地址
  • s.close()
    关闭套接字
  • socket.setblocking(flag)
    #True or False,设置socket为非阻塞模式,以后讲io异步时会用
  • socket.getaddrinfo(host,
    port, family=0, type=0, proto=0, flags=0)
    返回远程主机的地址信息,例子
    socket.getaddrinfo(‘luffycity.com’,80)
  • socket.getfqdn()
    拿到本机的主机名
  • socket.gethostbyname()
    通过域名解析ip地址

二. OSI七层

1.
C/S架构的软件(软件属于应用层)是基于网络进行通信的。

2.
网络的核心即一堆协议,协议即标准,你想开发一款基于网络通信的软件,就必须遵循这些标准。

图片 1

                                                                图1

TCP/IP协议族包括传输层、网络层、链路层,自己开发的应用程序工作在应用层。

 

tcp套接字

1.简单套接字
客户端和服务端:两个主要功能,1、建立链接 2、数据通讯
服务端程序会产生两个套接字socket,一个用于三次握手建立链接,另一个用于收发消息数据通讯;
客户端产生一个套接字socket,既可以用于建立链接后,再用于收发消息数据通讯。

client.py

图片 2图片 3

 1 import socket
 2 
 3 #1.买手机
 4 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 print(phone)
 6 
 7 #2.拨号
 8 phone.connect(('127.0.0.1',8081)) 
 9 #端口范围0-65535,0-1024给操作系统用的,若一直无法连接上server,则会一直停留在这一步
10 
11 #3.发收消息
12 phone.send('hello'.encode('utf-8'))
13 data = phone.recv(1024)
14 print(data)
15 
16 #4.关闭
17 phone.close()

View Code

 service.py

图片 4图片 5

 1 import socket
 2 
 3 #1.买手机
 4 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 print(phone)
 6 
 7 #2.绑定手机卡
 8 phone.bind(('127.0.0.1',8081)) #端口范围0-65535,0-1024给操作系统用的
 9 
10 #3.开机
11 phone.listen(5) # 参数表示最大监听数
12 
13 #4.等电话链接
14 print('starting...')
15 conn,client = phone.accept() #返回一个新的套接字conn用于通讯,client为发起通讯链接的客户端的ip和端口号
16 print(conn,client)
17 # print('===>')
18 
19 #5.收,发消息
20 data = conn.recv(1024) # 单位:bytes,  1024代表最大接收1024个bytes
21 print('客户端的数据',data)
22 conn.send(data.upper())
23 
24 #6.挂电话
25 conn.close()
26 
27 #7.关机
28 phone.close()

View Code

三. socket层

在图1中,我们没有看到Socket的影子,那么它到底在哪里呢?还是用图来说话,一目了然。

图片 6

                                                        图2

 

 2.加上循环套接字

client.py 

图片 7图片 8

 1 import socket
 2 
 3 #1.买手机
 4 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 
 6 print(phone)
 7 
 8 #2.拨号
 9 phone.connect(('127.0.0.1',8080)) #端口范围0-65535,0-1024给操作系统用的
10 
11 while True:
12     msg = input('>>:').strip()
13     if not msg:continue
14     phone.send(msg.encode('utf-8'))  #phone.send(b'')
15     print('has send') #判断能否发空
16     data = phone.recv(1024)
17     print(data.decode('utf-8'))
18 
19 #4.关闭
20 phone.close()

View Code

service.py

图片 9图片 10

 1 import socket
 2 
 3 
 4 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
 6 print(phone)
 7 phone.bind(('127.0.0.1',8080)) #端口范围0-65535,0-1024给操作系统用的
 8 phone.listen(5) #最大链接挂起数
 9 
10 print('starting...')
11 conn,client = phone.accept() #监听
12 # print('===>')
13 
14 #监听到到后,进行通讯循环
15 # while True:
16 #     data = conn.recv(1024) # 单位:bytes,  1024代表最大接收1024个bytes
17 #     #conn tcp协议三次握手的成果,双向链接
18 #     if not data:break #适用与linux操作,当client单方面终止链接时,service端会出现死循环
19 #     print('客户端的数据',data)
20 #     conn.send(data.upper())
21 
22 while True:
23     try:
24         data = conn.recv(1024) # 单位:bytes,  1024代表最大接收1024个bytes
25         #conn tcp协议三次握手的成果,双向链接
26 
27         print('客户端的数据',data)
28         conn.send(data.upper())
29     except ConnectionResetError:
30 
31         break
32 
33 conn.close()
34 phone.close()

View Code

if not data:break 是用于linux的判断,因为在linux中当client端单方面终止时,servce端会一直接收到空,会一直循环print('客户端的数据',data),因此需要加上判断;

except ConnectionResetError: 是针对windows的,当client端单方面终止时,server端会报ConnnectionRsetError。

有时重启服务端时会遇到报错:

图片 11

 四. 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是同一台机器上不同进程或者线程的标识。

 

 

由于重启时系统还没来得及回收端口,因此会提示端口已被占用。

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

解决方法:加入一条socket配置,重用ip和端口。

phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
#就是它,在bind ip和端口 前加。

或者:

实验之前要全部关闭掉所用占用端口的程序,用以下指令
linux:pkill -9 python
windows:taskkill python

 

五.  套接字发展史及分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的
Unix,即人们所说的 BSD Unix。
因此,有时人们也把套接字称为“伯克利套接字”或“BSD
套接字”。一开始,套接字被设计用在同
一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或
IPC。套接字有两种(或者称为有两个种族),分别是基于文件型的和基于网络型的。 

基于文件类型的套接字家族

套接字家族的名字:AF_UNIX

unix一切皆文件,基于文件的套接字调用的就是底层的文件系统来取数据,两个套接字进程运行在同一机器,可以通过访问同一个文件系统间接完成通信。

基于网络类型的套接字家族

套接字家族的名字:AF_INET

(还有AF_INET6被用于ipv6,还有一些其他的地址家族,不过,他们要么是只用于某个平台,要么就是已经被废弃,或者是很少被使用,或者是根本没有实现,所有地址家族中,AF_INET是使用最广泛的一个,python支持很多种地址家族,但是由于我们只关心网络编程,所以大部分时候我么只使用。AF_INET)

 

3.加上 链接循环

之前代码运行可知,client端关闭后,service端也会关闭,但此刻我们想client端关闭后,service端应该能在接收新的client端的链接请求,因此,在建

立链接的部分加入循环。

client.py 

图片 12图片 13

 1 import socket
 2 
 3 #1.买手机
 4 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 
 6 print(phone)
 7 
 8 #2.拨号
 9 phone.connect(('127.0.0.1',8080)) #端口范围0-65535,0-1024给操作系统用的
10 
11 while True:
12     msg = input('>>:').strip()
13     if not msg:continue
14     phone.send(msg.encode('utf-8'))  #phone.send(b'')
15     print('has send') #判断能否发空
16     data = phone.recv(1024)
17     print(data.decode('utf-8'))
18 
19 #4.关闭
20 phone.close()

View Code

service.py

图片 14图片 15

 1 import socket
 2 
 3 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
 5 print(phone)
 6 phone.bind(('127.0.0.1',8080)) #端口范围0-65535,0-1024给操作系统用的
 7 phone.listen(5) #最大链接挂起数
 8 
 9 print('starting...')
10 
11 while True:
12     '''
13     用于监听多次client端的链接,但一次链接发起结束后,
14     可继续监听下一次client端的连接
15     '''
16     conn,client = phone.accept()
17     print(client)
18     while True:
19         try:
20             data = conn.recv(1024) # 单位:bytes,  1024代表最大接收1024个bytes
21             #conn tcp协议三次握手的成果,双向链接
22             if not data: break
23             print('客户端的数据',data)
24             conn.send(data.upper())
25         except ConnectionResetError:
26             break
27     conn.close()

View Code

六.  套接字工作流程

 一个生活中的场景。你要打电话给一个朋友,先拨号,朋友听到电话铃声后提起电话,这时你和你的朋友就建立起了连接,就可以讲话了。等交流结束,挂断电话结束此次交谈。生活中的场景就解释了这工作原理,也许TCP/IP协议族就是诞生于生活中,这也不一定,看下图。

图片 16

                                 
                      图3

先从服务器端说起。服务器端先初始化Socket,然后与端口绑定(bind),对端口进行监听(listen),调用accept阻塞,等待客户端连接。在这时如果有个客户端初始化一个Socket,然后连接服务器(connect),如果连接成功,这时客户端与服务器端的连接就建立了。客户端发送数据请求,服务器端接收请求并处理请求,然后把回应数据发送给客户端,客户端读取数据,最后关闭连接,一次交互结束

 4.模拟ssh远程执行命令

client.py 

图片 17图片 18

 1 import socket,subprocess
 2 
 3 
 4 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
 6 print(phone)
 7 phone.bind(('127.0.0.1',9900)) #端口范围0-65535,0-1024给操作系统用的
 8 phone.listen(5) #最大链接挂起数
 9 
10 print('starting...')
11 while True:
12     conn,client = phone.accept() #监听
13 
14     while True: #通讯循环
15         try:
16             #1、收命令
17             cmd = conn.recv(1024) # 单位:bytes,  1024代表最大接收1024个bytes
18             #conn tcp协议三次握手的成果,双向链接
19             if not cmd: break
20             #2、执行命令、拿到结果,命令的结果存入stdout=subprocess.PIPE管道,而不是直接输出到终端
21             obj = subprocess.Popen(cmd.decode('utf-8'),shell=True,
22                                    # 指令由client端发送过来是以utf-8解码为bytes发送过来的,因此处应该以utf-8来编码,
23                                    # 因此此处的命令编码应该与client端的一致
24                                    stdout=subprocess.PIPE,
25                                    stderr=subprocess.PIPE)
26             print(obj)
27             stdout = obj.stdout.read()
28             stderr =  obj.stderr.read() #s收发都是bytes格式
29 
30             #3、把命令的结果返回给客户端
31             conn.send(stdout+stderr) #申请一块新的内存空间存放stdout+stderr,会占内存,效率会低
32         except ConnectionResetError:
33             break
34     conn.close()
35 
36 phone.close()

View Code

service.py

图片 19图片 20

 1 import socket
 2 
 3 #1.买手机
 4 phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 
 6 print(phone)
 7 
 8 #2.拨号
 9 phone.connect(('127.0.0.1',9900)) #端口范围0-65535,0-1024给操作系统用的
10 
11 while True:
12     msg = input('>>:').strip()
13     if not msg:continue
14     phone.send(msg.encode('utf-8'))
15     # 注意:信息由utf-8解码为bytes格式发送到service端,因此service端也必须把bytes格式以utf-8来编码,
16 
17     data = phone.recv(1024)  #返回值可能超过1024bytes,
18     print(data.decode('gbk'))
19     # windows上,res.stdout.read()读出的就是GBK编码,因此此处也用GBK编码,linux上默认是utf-8
20 
21 #4.关闭
22 phone.close()

View Code

此处注意两个小问题:

  1.service端的命令的编码应该与client端的解码模式对应,client端以utf-8解码指令为bytes,则service端必须以utf-8来编码;

  2.service端的把命令结果发送给client端,client则需要将命令结果进行编码,若serice端在windows上,则以GBK进行编码,若在linux上则以utf-8进行编码。

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)

服务端套接字函数

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()        创建一个与该套接字相关的文件

 以打电话为流程的示例演示:

图片 21图片 22

import socket
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
phone.bind(('127.0.0.1',8080)) #插电话卡

phone.listen(5) #开机,backlog

print('starting....')
conn,addr=phone.accept() #接电话
print(conn)
print('client addr',addr)
print('ready to read msg')
client_msg=conn.recv(1024) #收消息
print('client msg: %s' %client_msg)
conn.send(client_msg.upper()) #发消息

conn.close()
phone.close()

server.py

图片 23图片 24

import socket
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8080)) #拨通电话

phone.send('hello'.encode('utf-8')) #发消息

back_msg=phone.recv(1024)
print(back_msg)

phone.close()

client.py

输出:

服务端

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', 65172)>
client addr ('127.0.0.1', 65172)
ready to read msg
client msg: b'hello'

客户端

b'HELLO'

 

5.粘包现象分析

须知:只有TCP有粘包现象,UDP永远不会粘包

图片 25

 

所谓粘包问题主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的。

udp的recvfrom是阻塞的,一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失,这意味着udp根本不会粘包,但是会丢数据,不可靠。

tcp的协议数据不会丢,没有收完包,下次接收,会继续上次继续接收,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会粘包。

两种情况下会发生粘包:

发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据段很小,会合到一起,产生粘包)。TCP使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包。

client.py

图片 26图片 27

1 import socket
2 
3 client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
4 client.connect(('127.0.0.1',9903))
5 
6 #TCP使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,
7 # 合并成一个大的数据块,然后进行封包。从而在发送端造成粘包。
8 client.send('hello'.encode('utf-8'))
9 client.send('world'.encode('utf-8'))

View Code

service.py

图片 28图片 29

 1 import socket
 2 
 3 service = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 service.bind(('127.0.0.1',9903))
 5 service.listen(5)
 6 
 7 conn,addr = service.accept()
 8 
 9 res1 = conn.recv(1024)
10 print('第一次',res1.decode())
11 
12 res2 =  conn.recv(1024)
13 print('第二次',res2.decode())

View Code

 输出结果:

第一次 helloworld
第二次 

发送端由于TCP
优化算法造成粘包

 

接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包) 

 

client.py

图片 30图片 31

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket
 4 BUFSIZE=1024
 5 ip_port=('127.0.0.1',8080)
 6 
 7 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 8 res=s.connect_ex(ip_port)
 9 
10 
11 s.send('hello feng'.encode('utf-8'))
12 
13 客户端

View Code

service.py

图片 32图片 33

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 from socket import *
 4 ip_port=('127.0.0.1',8080)
 5 
 6 tcp_socket_server=socket(AF_INET,SOCK_STREAM)
 7 tcp_socket_server.bind(ip_port)
 8 tcp_socket_server.listen(5)
 9 
10 
11 conn,addr=tcp_socket_server.accept()
12 
13 
14 data1=conn.recv(2) #一次没有收完整
15 data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的
16 
17 print('----->',data1.decode('utf-8'))
18 print('----->',data2.decode('utf-8'))
19 
20 conn.close()
21 
22 服务端

View Code

输出结果

-----> he
-----> llo feng

接收端由于没能一次将发送端一次发送的数据全部接受,导致粘包

 

拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时,tcp会将这次发送的数据拆成几个数据包发送出去。

补充问题一:为何tcp是可靠传输,udp是不可靠传输

tcp在数据传输时,发送端先把数据发送到自己的缓存中,然后协议控制将缓存中的数据发往对端,对端返回一个ack=1,发送端则清理缓存中的数据,对端返回ack=0,则重新发送数据,所以tcp是可靠的。

而udp发送数据,对端是不会返回确认信息的,因此不可靠。

补充问题二:send(字节流)和recv(1024)及sendall

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

send的字节流是先放入己端缓存,然后由协议控制将缓存内容发往对端,如果待发送的字节流大小大于缓存剩余空间,那么数据丢失,用sendall就会循环调用send,数据不会丢失。

send 和 recv:
1.不管是recv还是send都不是直接接收对方的数据,而是操作自己的操作系统内存-->不是一个send对应一个recv
2.recv阶段,耗时分析:
  wait data 耗时非常长
  copy data 耗时短
  send耗时分析:
  copy data

七. 基于TCP的套接字

 tcp服务端

ss = socket() #创建服务器套接字
ss.bind()      #把地址绑定到套接字
ss.listen()      #监听链接
inf_loop:      #服务器无限循环
    cs = ss.accept() #接受客户端链接
    comm_loop:         #通讯循环
        cs.recv()/cs.send() #对话(接收与发送)
    cs.close()    #关闭客户端套接字
ss.close()        #关闭服务器套接字(可选)

tcp客户端

cs = socket()    # 创建客户套接字
cs.connect()    # 尝试连接服务器
comm_loop:        # 通讯循环
    cs.send()/cs.recv()    # 对话(发送/接收)
cs.close()            # 关闭客户套接字

socket通信流程与打电话流程类似,我们就以打电话为例来实现一个low版的套接字通信

图片 34图片 35

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',9000)  #电话卡
BUFSIZE=1024                #收发消息的尺寸
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
s.bind(ip_port) #手机插卡
s.listen(5)     #手机待机


conn,addr=s.accept()            #手机接电话
# print(conn)
# print(addr)
print('接到来自%s的电话' %addr[0])

msg=conn.recv(BUFSIZE)             #听消息,听话
print(msg,type(msg))

conn.send(msg.upper())          #发消息,说话

conn.close()                    #挂电话

s.close()                       #手机关机

服务端

服务端

图片 36图片 37

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',9000)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect_ex(ip_port)           #拨电话

s.send('linhaifeng nb'.encode('utf-8'))         #发消息,说话(只能发送字节类型)

feedback=s.recv(BUFSIZE)                           #收消息,听话
print(feedback.decode('utf-8'))

s.close()                                       #挂电话

客户端

客户端

上述流程的问题是,服务端只能接受一次链接,然后就彻底关闭掉了,实际情况应该是,服务端不断接受链接,然后循环通信,通信完毕后只关闭链接,服务器能够继续接收下一次链接,下面是修改版

图片 38图片 39

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',8081)#电话卡
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
s.bind(ip_port) #手机插卡
s.listen(5)     #手机待机


while True:                         #新增接收链接循环,可以不停的接电话
    conn,addr=s.accept()            #手机接电话
    # print(conn)
    # print(addr)
    print('接到来自%s的电话' %addr[0])
    while True:                         #新增通信循环,可以不断的通信,收发消息
        msg=conn.recv(BUFSIZE)             #听消息,听话

        # if len(msg) == 0:break        #如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生

        print(msg,type(msg))

        conn.send(msg.upper())          #发消息,说话

    conn.close()                    #挂电话

s.close()                       #手机关机

服务端改进版

服务端改进版

图片 40图片 41

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',8081)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect_ex(ip_port)           #拨电话

while True:                             #新增通信循环,客户端可以不断发收消息
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    s.send(msg.encode('utf-8'))         #发消息,说话(只能发送字节类型)

    feedback=s.recv(BUFSIZE)                           #收消息,听话
    print(feedback.decode('utf-8'))

s.close()                                       #挂电话

客户端改进版

客户端改进版

问题:

在重启服务端时可能会遇到以下报错现象

图片 42

 

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

解决方法:

图片 43图片 44

#加入一条socket配置,重用ip和端口
phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加
phone.bind(('127.0.0.1',8080))

方法一

图片 45图片 46

发现系统存在大量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 时间

方法二

方法二

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website