网络编程基础

#架构
C/S架构（鼻祖）
　　c：client 客户端
　　s：server 服务器

B/S架构（隶属于C/S架构）B/S架构的优点：统一了应用的入口(是一个趋势) 
　　b：browser 浏览器
　　s: server 服务器
软件开发的架构：

1.C/S架构

C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。

这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。

2.B/S架构

B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。

Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。

 

网络基础
#两个电脑如何通信：一根网线 

网卡有个mac地址，又叫做物理地址，查看mac地址命令： ipconfig -all (查看以太网，物理地址)

几十台电脑如何通信：局域网：通过交换机实现

怎样知道一个局域网里有多少台电脑：同一个局域网里有相同的网段

　　网段：192.168.12.XX（前三个在同一局域网中相同，而XX范围是0-255，所以一个网段最多能放256台电脑）

IP地址：是一个四位十进制分开的一串数字。

子网掩码：是计算机根据你的IP地址生成的一个东西

　　网段：ip地址 &子网掩码

例如：IP地址：192.168.12.84（将84=64+20=64+16+4->转换成二进制01010100）

　　　二进制：11000000.10101000.00001100.01010100

　　子网掩码：255.255.255.0

　　　子网掩码：1111111.11111111.11111111.00000000

与操作：11000000.10101000.00001100.01010100

               11111111. 11111111.  11111111.    00000000

　　　　--------------------------------------------------------

　　　　11000000.10101000.00001100.00000000

　　　　192.168.12.0：得到网段

2进制的算法：

 路由器：有一个路由表，用来记录网段信息。

交换机通信：

　　广播：吼一嗓子

　　单播：方向固定的向某一个主机发送

　　组播：朝某一部分或某一组主机发送

 更多电脑之间的通信：

　　广域网 交换机+路由器+代理IP

tcp和udp协议都是基于socket模块。两种协议可以混着用。

　　tcp：会慢一点，安全可靠，面向连接，字节流服务--代表没有边界
　　udp：不安全不可靠，不面向连接，但是效率高（大部分视频会议用udp）  （干完就 跑）面向数据表连接

端口：

　　ip + prot 唯一确定一台主机上的某一个程序（你打开一个程序就有一个端口）

　　允许开发人员使用的端口号范围从8000开始 8000-10000（每开启一个程序，会随机得到个端口号）

 TCP协议

　　　当应用程序希望通过 TCP 与另一个应用程序通信时，它会发送一个通信请求。这个请求必须被送到一个确切的地址。在双方“握手”之后，TCP 将在两个应用程序之间建立一个全双工 (full-duplex) 的通信。

　　这个全双工的通信将占用两个计算机之间的通信线路，直到它被一方或双方关闭为止。

TCP是面向连接的

三次握手：

TCP是因特网中的传输层协议，使用三次握手协议建立连接。当主动方发出SYN连接请求后，等待对方回答SYN+ACK[1]，并最终对对方的 SYN 执行 ACK 确认。这种建立连接的方法可以防止产生错误的连接。[1]
TCP三次握手的过程如下：
客户端发送SYN（SEQ=x）报文给服务器端，进入SYN_SEND状态。
服务器端收到SYN报文，回应一个SYN （SEQ=y）ACK(ACK=x+1）报文，进入SYN_RECV状态。
客户端收到服务器端的SYN报文，回应一个ACK(ACK=y+1）报文，进入Established状态。
三次握手完成，TCP客户端和服务器端成功地建立连接，可以开始传输数据了。

tcp的三次握手

 断链四次挥手

建立一个连接需要三次握手，而终止一个连接要经过四次握手，这是由TCP的半关闭（half-close）造成的。
(1) 某个应用进程首先调用close，称该端执行“主动关闭”（active close）。该端的TCP于是发送一个FIN分节，表示数据发送完毕。
(2) 接收到这个FIN的对端执行 “被动关闭”（passive close），这个FIN由TCP确认。
注意：FIN的接收也作为一个文件结束符（end-of-file）传递给接收端应用进程，放在已排队等候该应用进程接收的任何其他数据之后，因为，FIN的接收意味着接收端应用进程在相应连接上再无额外数据可接收。
(3) 一段时间后，接收到这个文件结束符的应用进程将调用close关闭它的套接字。这导致它的TCP也发送一个FIN。
(4) 接收这个最终FIN的原发送端TCP（即执行主动关闭的那一端）确认这个FIN。[1]
既然每个方向都需要一个FIN和一个ACK，因此通常需要4个分节。
注意：
(1) “通常”是指，某些情况下，步骤1的FIN随数据一起发送，另外，步骤2和步骤3发送的分节都出自执行被动关闭那一端，有可能被合并成一个分节。[2]
(2) 在步骤2与步骤3之间，从执行被动关闭一端到执行主动关闭一端流动数据是可能的，这称为“半关闭”（half-close）。
(3) 当一个Unix进程无论自愿地（调用exit或从main函数返回）还是非自愿地（收到一个终止本进程的信号）终止时，所有打开的描述符都被关闭，这也导致仍然打开的任何TCP连接上也发出一个FIN。
无论是客户还是服务器，任何一端都可以执行主动关闭。通常情况是，客户执行主动关闭，但是某些协议，例如，HTTP/1.0却由服务器执行主动关闭。[2] 

tcp的四次挥手

UDP协议

　　相对TCP协议而言，UDP协议

       当应用程序希望通过UDP与一个应用程序通信时，传输数据之前源端和终端不建立连接。

　　当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上

cp和udp的对比

TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快

互联网协议与osi模型

互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层

每层运行常见物理设备

每层运行常见的协议

理解各层作用：

 

socket概念

socket层

理解socket

　　Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

　其实站在你的角度上看，socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。 所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信。

套接字的发展史：

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

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

套接字家族的名字：AF_UNIX

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

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

套接字家族的名字：AF_INET

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

socket参数的详解

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

创建socket对象的参数说明：

面试题：
真实的：
1、你知道哪些研发相关的架构？
2、arp协议做了什么事情？：通过IP地址找到对应的mac地址。
3、交换机的通讯方式？
4、你认为tcp和udp的区别？
5、请描述出osi五层模型？

我出的：
1、网段ip怎么确定？
2、请描述B/S架构的优势

**********************************************************

双全工：是指，两端一旦建立连接之后，谁给谁先发消息都可以

tcp与udp区别

　　tcp协议，不允许在同一时间点同时和多个客户端连接通信
　　udp协议，允许在同一个时间点同时和多个客户端连接通信

　　tcp协议编码中，服务器是可以先和客户端通信的
　　udp协议编码中，服务器必选先接受客户端的消息，才能知道客户端的地址

在一台电脑上通过py文件手动通信-tcp

#服务器
import socket

sk = socket.socket()#我买一个手机

sk.bind(('127.0.0.1',8090))#买一个电话卡

sk.listen(5)#告诉了几个人我的手机号
#print(123)
fd,addr = sk.accept()#等着别人给打电话,阻塞等待客户端来连接,
#print(456)
#print(fd,addr) #通过fd就能给客户端发送信息了
#打印出<socket.socket fd=164, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0,
#  laddr=('127.0.0.1', 8090), raddr=('127.0.0.1', 58613)> ('127.0.0.1', 58613)#这里是客户端的地址，客户端的信息
#通话
while 1:
    msg_r = fd.recv(1024).decode('utf-8')
    print(msg_r)
    if msg_r == 'q':
        break
    msg_s = input('>>>')
    fd.send(msg_s.encode('utf-8'))
    if msg_s == 'q':
        break
fd.close() #挂断电话
sk.close()#关机

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8090))

#收发信息的逻辑
while 1:
    msg_s = input('>>>')
    sk.send(msg_s.encode('utf-8'))
    if msg_s == 'q':
        break
    msg_r = sk.recv(1024).decode('utf-8')
    print(msg_r)
    if msg_r == 'q':
        break

sk.close()

如何一个服务器连接多个客户端-tcp

import socket
#创建tcp socket的套接字
sk = socket.socket()

#bind
sk.bind(('127.0.0.1',8080))#8080代表http
#监听
sk.listen(5)
while 1:
#等待连接
    conn,adder =sk.accept()

    while 1:
        msg_s = input('>>>')
        conn.send(msg_s.encode('utf-8'))
        if msg_s == 'q':
            break
        msg_r = conn.recv(1024).decode('utf-8')
        if msg_r == 'q':
            break
        print(msg_r)
    conn.close()
sk.close()

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))#有个返回值
while 1:
    msg_r = sk.recv(1024).decode('utf-8')
    if msg_r == 'q':
        break
    print(msg_r)
    msg_s = input('>>>')
    sk.send(msg_s.encode('utf-8'))
    if msg_r == 'q':
        break
sk.close()

udp通信:

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',8090))
while 1 :
    msg_r,addr = sk.recvfrom(1024)
    print('接受到来自%s地址的一条消息：%s'%(addr,msg_r.decode('utf-8')))#这里可以
    msg_s =input('>>>').encode('utf-8')
    sk.sendto(msg_s,addr)

sk.close()

import socket
sk=socket.socket(type=socket.SOCK_DGRAM)
while 1:
    msg_s = input('>>>').encode('utf-8')
    sk.sendto(msg_s,('127.0.0.1',8090))
    msg_r,addr = sk.recvfrom(1024)
    print(msg_r.decode('utf-8'),addr)
sk.close()

 udp通信控制台带颜色输出

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',8090))
dic = {'小白':'33[1;31;40m'}
while 1 :
    msg_r,addr = sk.recvfrom(1024)
    msg_r = msg_r.decode('utf-8')
    name = msg_r.split(':')[0]
    color = dic.get(name,'')
    print('%s %s 33[0m'%(color,msg_r))#颜色要以33[0m为结尾，且颜色要在消息之前
    msg_s = input('>>>').encode('utf-8')
    sk.sendto(msg_s,addr)
sk.close()

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
name = input('请输入名字>>>')
while 1:
    msg_s = input('>>>')
    if msg_s == 'q':
        break
    sk.sendto((name+':'+msg_s).encode('utf-8'),('127.0.0.1',8090))
    msg_r,addr = sk.recvfrom(1024)
    if msg_r.decode('utf-8') == 'q':
        break
    print(msg_r.decode('utf-8'))
sk.close()

　　　　　　　　　　　　　　　　　　　　pycharm控制台输出带颜色

#格式：
　　设置颜色开始 ：33[显示方式;前景色;背景色m
#说明：
前景色            背景色           颜色
---------------------------------------
               40              黑色
               41              红色
               42              绿色
               43              黃色
               44              蓝色
               45              紫红色
               46              青蓝色
               47              白色
显示方式           意义
-------------------------
               终端默认设置
               高亮显示
               使用下划线
               闪烁
               反白显示
               不可见
 
#例子：
33[1;31;40m    <!--1-高亮显示 31-前景色红色  40-背景色黑色-->
033[0m          <!--采用终端默认设置，即取消颜色设置-->

举例

print('33[0;32;40m欢迎使用学生选课系统33[0m')#需要注意的要有头有尾，在消息的前后都要设置颜色，最后一个是恢复默认

获取服务器时间问题：就是一个大服务器去获取北京时间，然后其他客户端再获取这个服务器的时间，保持时间同步。udp协议快，所以用udp

import socket
import time
sk = socket.socket(type = socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',8090))
while 1:
    tm_format,addr = sk.recvfrom(1024)
    time_now = time.strftime(tm_format.decode('utf-8'))
    print(time_now)
    sk.sendto(time_now.encode('utf-8'),addr)
sk.close()

import socket
import time
sk = socket.socket(type = socket.SOCK_DGRAM)
print('''
    %Y
    %m
    %d
    %H
    %M
    %S
''')
tm_format = input('请输入一个格式>>>')
while 1:
    sk.sendto(tm_format.encode('utf-8'),('127.0.0.1',8090))
    tm_now,addr = sk.recvfrom(1024)
    print(tm_now.decode('utf-8'))
    time.sleep(2)
sk.close()

tcp与udp流程图

通过一个类来实现解码

from MySocket import My_Socket
sk=My_Socket()

sk.bind(('127.0.0.1',8090))
msg_r,addr = sk.my_recv(1024)
print(msg_r)
sk.close()

from MySocket import My_Socket
sk = My_Socket()
msg_s = input('>>>')
sk.my_send(msg_s,('127.0.0.1',8090))
sk.close()

from socket import *
class My_Socket(socket):
    def __init__(self,coding='utf-8'):
        self.coding=coding
        super(My_Socket,self).__init__(type=SOCK_DGRAM)
    def my_recv(self,num):
        msg,addr = self.recvfrom(num)
        return msg.decode(self.coding),addr
    def my_send(self,msg,addr):
        return self.sendto(msg.encode(self.coding),addr)

ftp下载

#文件传输用tcp协议 安全可靠
import socket
import json
sk = socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen(5)
conn,addr = sk.accept()

#上传下载的逻辑
str_dic = conn.recv(1024).decode('utf-8')
dic =json.loads(str_dic)
# dic = {'opt':ls.get(num),'filename':filename,'content':content}
if dic['opt']=='upload':
    filename = 'new_'+dic['filename']
    with open(filename,'w',encoding='utf-8')as f:
        f.write(dic['content'])

conn.close()
sk.close()

import socket
import os
import json
sk =socket.socket()
sk.connect(('127.0.0.1',8090))
ls = {'1':'upload','2':'download'}

while 1:
    for k, v in ls.items():
        print(k, ":", v)
    num = input('请输入功能选项>>>')
    if num == '1': #上传的逻辑
        file_path = input('请输入文件的路径>>>')
        filename= os.path.basename(file_path)
        with open(file_path,encoding='utf-8') as f:
            content = f.read()
        dic = {'opt':ls.get(num),'filename':filename,'content':content}
        str_dic = json.dumps(dic)
        sk.send(str_dic.encode('utf-8'))
        break
    elif num == '2':#下载的逻辑
        pass
    else:
        print('重新输入')
sk.close()

远控操作

mport socket
import subprocess
sk=socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen(5)
conn,addr = sk.accept()
while 1:
    cmd = conn.recv(1024).decode('utf-8')
    r = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout = r.stdout.read()
    stderr = r.stderr.read()
    if stdout:
        conn.send(stdout)
    elif stderr:
        conn.send(stderr)

conn.close()
sk.close()

import socket
sk=socket.socket()
sk.connect(('127.0.0.1',8090))
while 1:
    cmd = input('>>>')
    sk.send(cmd.encode('utf-8'))
    ret = sk.recv(1024).decode('gbk')
    print(ret)

sk.close()

import os
#使用os执行命令 有个缺陷 就是如果报错 不知道报的是什么错误
#print(os.path.basename('D:pycharmproject28\__init__.py'))
#r = os.popen('dir')
#print(r.read())
# r = os.popen('ipconfig')
# print(r.read())
# r = os.popen('calc')
# print(r.read())
# r = os.popen('mspaint')
# print(r.read()) #无论对错都能读出
import subprocess #在执行系统这一方面这个模块必要好
r = subprocess.Popen('ls',shell=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE)#shell=True意思是告诉系统把我要执行的命令当做系统命令来执行,
                    # stdout接受返回来的结果,stderr接受错误的结果。
print('stdout:',r.stdout.read().decode('gbk'))
print('stderr:',r.stderr.read().decode('gbk'))

黏包

只有TCP有粘包现象，UDP永远不会粘包

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen(5)
conn,addr = sk.accept()
msg_1 = conn.recv(10) #这时候会接受'hewo'信息出现发收混乱就叫黏包

msg_2 = conn.recv(10)
print(msg_1)
print(msg_2)
conn.close()
sk.close()

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8090))
cont_1 = sk.send(b'he')

cont_2 = sk.send(b'wo')
sk.close()

解释：就是因为有nagle算法，因为发送的间隔较短，将两个包合并成一个包进行发送，但是在接受端的缓存区是较两个数据分开的，但接受短recv(10)，又因为信息太小，将其合并接受了，最后两条消息成为了一条合并后的消息

黏包成因

TCP协议中的数据传递

1、tcp协议的拆包机制

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。 
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500。
如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度。

2、面向流的通信特点和Nagle算法

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。
收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），
将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。
这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，
即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 （消息头其实是你的地址信息）
可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

 基于tcp协议特点的黏包现象成因

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据。
也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，
这也是容易出现粘包问题的原因。
而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。
怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，
TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

socket数据传输过程中的用户态与内核态说明

 socket数据传输过程中的用户态与内核态说明

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

UDP不会发生黏包

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。 
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，
在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，
即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失，
这意味着udp根本不会粘包，但是会丢数据，不可靠。

补充说明:

用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，
则函数会返回错误。（丢弃这个包，不进行发送） 

用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。
而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。

 udp和tcp一次发送数据长度的限制

会发生黏包的两种情况

情况一 发送方的缓存机制

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

#client连续发送少量数据，时间间隔短，所以nagle算法帮你合包了，但是此时server不知道要接受多少，所以造成数据混乱#

情况二 接收方的缓存机制

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

#client直接发送了大量数据，但是server端接受的长度不够，所以造成数据混乱。#

#_*_coding:utf-8_*_
from socket import *
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()

服务端

server

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

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


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

客户端

client

总结

黏包现象只发生在tcp协议中：

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

黏包的解决方案

解决方案一

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。

 ftp上传大文件

import socket
import json
sk = socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen(5)
conn,addr = sk.accept()
#上传下载的逻辑
len_str = conn.recv(4).decode('utf-8')
str_dic = conn.recv(len_str).decode('utf-8')

#conn.send(b'success')#防止黏包，发送一条消息
dic =json.loads(str_dic)
# dic = {'opt':ls.get(num),'filename':filename,'content':content}
if dic['opt']=='upload':
    filename = 'new_'+dic['filename']
    filesize = dic['filesize']
    with open(filename,'wb')as f:
        content = conn.recv(1024)
        filesize -=len(content)
        f.write(content)
conn.close()
sk.close()

import socket
import os
import json
import struct
sk =socket.socket()
sk.connect(('127.0.0.1',8090))
ls = {'1':'upload','2':'download'}
while 1:
    for k, v in ls.items():
        print(k, ":", v)
    num = input('请输入功能选项>>>')
    if num == '1': #上传的逻辑
        file_path = input('请输入文件的路径>>>')
        file_size = os.path.getsize(file_path)
        filename= os.path.basename(file_path)
        dic = {'opt':ls.get(num),'filename':filename,'filesize':file_size}
        str_dic = json.dumps(dic)
        len_dic = len(str_dic)
        ll = struct.pack('i',len_dic).decode('utf-8')
        sk.send(ll)
        sk.send(str_dic.encode('utf-8'))
        #sk.recv(1024)#为了防止黏包
        with open(file_path, 'rb') as f:
            while file_size:
                content = f.read(1024)
                file_size -= len(content)
                sk.send(content)
        break
    elif num == '2':#下载的逻辑
        pass
    else:
        print('重新输入')
sk.close()

import struct

r = struct.pack('i',45)
print(len(r))
print(struct.unpack('i',r))

Socket更多的方法解释

服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

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

公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据
s.sendall()         发送TCP数据
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

面向锁的套接字方法
s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间 
s.gettimeout()      得到阻塞套接字操作的超时时间    #主要就是控制sk.accept()在这接受的问题

面向文件的套接字的函数
s.fileno()          套接字的文件描述符
s.makefile()        创建一个与该套接字相关的文件

send方法：socket.send方法相当于有一个自己的拆包机制，如果发送数据量大，可能会给你拆包，此时拆包和nagle算法没有关系。

解释send与sendall的区别

sock.sendall('Hello world
')

buffer = 'Hello world
'
while buffer:
   bytes = sock.send(buffer)
   buffer = buffer[bytes:]

官方文档对socket模块下的socket.send()和socket.sendall()解释如下：

socket.send(string[, flags])
Send data to the socket. The socket must be connected to a remote socket. The optional flags argument has the same meaning as for recv() above. Returns the number of bytes sent. Applications are responsible for checking that all data has been sent; if only some of the data was transmitted, the application needs to attempt delivery of the remaining data.

send()的返回值是发送的字节数量，这个数量值可能小于要发送的string的字节数，也就是说可能无法发送string中所有的数据。如果有错误则会抛出异常。

–

socket.sendall(string[, flags])
Send data to the socket. The socket must be connected to a remote socket. The optional flags argument has the same meaning as for recv() above. Unlike send(), this method continues to send data from string until either all data has been sent or an error occurs. None is returned on success. On error, an exception is raised, and there is no way to determine how much data, if any, was successfully sent.

尝试发送string的所有数据，成功则返回None，失败则抛出异常。

故，下面两段代码是等价的：

#sock.sendall('Hello world
')

#buffer = 'Hello world
'
#while buffer:
#    bytes = sock.send(buffer)
#    buffer = buffer[bytes:]

 验证客户端的合法性：

struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

>>> struct.pack('i',1111111111111)

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围

使用struct解决黏包

借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。

import socket
import hashlib
import os
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen(5)

conn,addr = sk.accept()
salt = b'fuck'
r_bytes = os.urandom(32)
conn.send(r_bytes)
md5_obj = hashlib.md5(salt)
md5_obj.update(r_bytes)
r = md5_obj.hexdigest()

client_r = conn.recv(1024).decode('utf-8')
if r == client_r:
    print('可以链接')
    while 1:
        msg_s = input('>>>').encode('utf-8')
        conn.send(msg_s)
        msg_r = conn.recv(1024).decode('utf-8')
        print(msg_r)
else:
    print('不行')
conn.close()
sk.close()

import socket
import hashlib
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
salt = b'fuck'
r_bytes = sk.recv(1024)
md5_obj = hashlib.md5(salt)
md5_obj.update(r_bytes)
r = md5_obj.hexdigest()

sk.send(r.encode('utf-8'))
while 1:
    msg_r = sk.recv(1024).decode('utf-8')
    print(msg_r)
    msg_s = input('>>>').encode('utf-8')
    sk.send(msg_s)

对代码进行优化封装

import socket
import hmac
import os
ADDR =('127.0.0.1',8080)
def create_sk():
    sk = socket.socket()
    sk.bind(ADDR)
    sk.listen(5)
    conn,addr = sk.accept()
    return conn,sk
def com():
    while 1:
        msg_s = input('>>>').encode('utf-8')
        conn.send(msg_s)
        msg_r = conn.recv(1024).decode('utf-8')
        print(msg_r)
def check_client(conn):
    salt = b'fuck'
    r_bytes = os.urandom(32)
    conn.send(r_bytes)
    md5_v = hmac.new(salt,r_bytes,digestmod='md5')
    r = md5_v.digest()
    client_r = conn.recv(1024)
    if r == client_r:
        print('合法，连接通过')
        com()
    else:
        print('不行')
        return
conn,sk = create_sk()
check_client(conn)
conn.close()
sk.close()

import socket
import hmac
def create_sk():
    sk = socket.socket()
    sk.connect(('127.0.0.1',8080))
    return sk
def md5_login(sk):
    salt = b'fuck'
    r_bytes = sk.recv(1024)
    md5_v = hmac.new(salt,r_bytes,digestmod='md5')
    r = md5_v.digest()
    sk.send(r)
def com(sk):
    while 1:
        msg_r = sk.recv(1024).decode('utf-8')
        print(msg_r)
        msg_s = input('>>>').encode('utf-8')
        sk.send(msg_s)
sk = create_sk()
md5_login(sk)
com(sk)
sk.close()

补充知识点

import os
print(os.urandom(2))#用于加密 没法解码处理来的，随机出来的2位bytes字节，括号里的值可以随意更改

import hmac
salt = b'fuck'
r_str = b'ssss'
md5_v = hmac.new(salt,r_str,digestmod='md5') #可以节省代码，简单方便些
r = md5_v.digest()
print(r)

socketserver

import socketserver

class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        print(123)
        self.request.send(b'456')
        self.request.recv(1024)
ser = socketserver.ThreadingTCPServer(('127.0.0.1',8090),
                                      MyServer)
ser.serve_forever()

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8090))
print(sk.recv(1024))
sk.send(b'hello')
sk.close()

 加入登录验证

import socketserver
import json
import hashlib
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        str_dic = self.request.recv(1024).decode('utf-8')
        dic = json.loads(str_dic)
        md5_obj = hashlib.md5(dic['username'].encode('utf-8'))
        md5_obj.update(dic['password'].encode('utf-8'))
        mw_pwd = md5_obj.hexdigest()
        print(mw_pwd)
        with open(r'D:pycharmproject29userinfo',encoding = 'utf-8') as f :
            for line in f:
                username,passwd = line.strip().split(':')
                print(username,passwd)
                if username.strip() == dic['username'] and passwd.strip() == mw_pwd:
                    print('连接')
                    return
            print('密码不对')
server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)
server.serve_forever()

import  socket
import json
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
username = input('请输入用户名>>>')
password = input('请输入密码>>>')
dic = {'username':username,'password':password}
str_dic = json.dumps(dic)
sk.send(str_dic.encode('utf-8'))

小知识点

print(123)
print(
456) #通过加
 可以移动光标 将上面的123 覆盖掉

import time
def  func():
    for i in range(1,101,1):
        num = i // 2
        print('
%s%% %s>'%(i , '='*num),end='')
        time.sleep(0.2)
func()