网络编程

 

一.C/S，B/S架构

1.C/S架构

client <----> sever

2.B/S架构

Browser <----> sever

3.服务端特点

1.不间断提供服务

2.支持并发+高性能

二.OSI七层协议

2.1物理层

物理层指的就是网线，光纤，双绞线等等

物理层发送的是比特流

物理层功能：主要是基于电器特性发送高低电压(电信号)

2.2数据链路层

数据链路层功能:定义了电信号的分组方式

以太网协议：早期的时候各个公司都有自己的分组方式，后来形成了统一的标准，即以太网协议ethernet

ethernet规定

• 一组电信号构成一个数据豹，叫做‘帧’
• 每一数据帧分成：报头head和数据data两部分

head	data

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

• 发送者／源地址，6个字节
• 接收者／目标地址，6个字节
• 数据类型，6个字节

data包含：(最短46字节，最长1500字节)

• 数据包的具体内容

head长度＋data长度＝最短64字节，最长1518字节，超过最大限制就分片发送

mac地址：

head中包含的源和目标地址由来：ethernet规定接入internet的设备都必须具备网卡，发送端和接收端的地址便是指网卡的地址，即mac地址

mac地址：每块网卡出厂时都被烧制上一个世界唯一的mac地址，长度为48位2进制，通常由12位16进制数表示（前六位是厂商编号，后六位是流水线号）

广播：

有了mac地址，同一网络内的两台主机就可以通信了（一台主机通过arp协议获取另外一台主机的mac地址）

ethernet采用最原始的方式，广播的方式进行通信，即计算机通信基本靠吼

2.3网络层

IP地址：

网络部分：标识子网

主机部分：标识主机

子网掩码:表示子网络特征的一个参数。ip和子网掩码的二进制与运算得到子网。

IP协议作用：

1.为每一台计算机分配IP地址

2.确定哪些地址在同一个网络

ARP协议(地址解析协议):

通过对方的ip地址获取到对方的mac地址

2.4传输层

通过ip和mac找到了一台特定的主机，如何标识这台主机上的应用程序，答案就是端口

端口范围：0-65535 ， 0-1023为系统占用端口。

传输层功能：建立端口到端口之间的通信。

TCP协议：可靠的、面向连接的协议，又命名为流式协议

UDP协议：不可靠的，无连接的协议

2.5应用层

 

应用层功能：规定应用程序的数据格式

例：TCP协议可以为各种各样的程序传递数据，比如Email、WWW、FTP等等。那么，必须有不同协议规定电子邮件、网页、FTP数据的格式，这些应用程序协议就构成了”应用层”。

2.6通信理解

两台电脑上的软件相互发送数据，首先软件要有相应的端口，这就用到传输层。通过特定端口给另一台电脑上发送数据，需要知道另一台电脑所在的子网(ip)，这就用到网络层。知道了ip后，还要知道是子网下的哪一台电脑，这就用到数据链路层（出厂时会给每块网卡上烧制唯一的mac地址），然后通过物理层发送比特流数据到另一台电脑上。
其实两台计算机上的软件通信就是打包和解包的过程。
#ip数据报的长度65513字节，而数据帧的长度最长为1500字节，如果数据报的长度超过1500字节，就分片发送，给每片加上mac头。但是在物理层发送时，是将所有的电信号合在一起发送，对方电脑上收到后，会做一个判断，如果长度超过1500字节，直接给其解包。如果超过1500字节，就自动分组，然后每组进行解包。
#从传输层往下，都是电信号形式，主要是供操作系统使用。

三.TCP协议的三次握手和四次挥手

3.1三次握手

准确来说，应该是四次握手。解释：客户端第一次发送连接建立请求，服务端在接受后，同时将自己的连接请求发送给客户端（这里应该是分2步：1.回复客户端发来的连接请求。2.请求建立从自身到客户端的连接），这里组成了一步。客户端在接受到服务端的肯定后，建立连接。

3.2四次挥手

客户端在发送完数据后给服务端发送消息，要断开连接。此时服务端还没有发送完数据，一旦发送完毕，也给客户端发送同样消息，因此为四次挥手。

总结：三次握手和四次挥手都是有两条连接：A端-->B端，B端--->A端，只不过三次握手是将两条连接合成一条。

四.概念

单播：单独联系某个人
广播：给所有人发送消息
比特流：bit就是 0101 跟水流一样的源源不断的发送010101001.
以太网协议：将数据进行分组:一组称之为一帧,数据报.
mac地址: 就是计算机网卡上记录的地址,世界上所有的计算机独一无二的标识. 用于局域网内广播(单播)时查找的计算机的位置.
交换机：分流连接计算机的作用
交换机的mac学习功能：第一次发送消息以广播的形式，当学习表记录上端口与mac地址对应关系之后,在发送消息: 单播的形式发送.
广播风暴：所有的计算机都在广播的形式发送消息
路由器：外接口连接网关，是连接公网ip。内部接口连接内网ip(都是假的)。有自动分发ip地址功能
ARP协议：通过ip获取计算机mac地址
TCP协议：面向连接的协议(流式协议)，安全可靠，用来传输文件等
UDP协议：用户数据报协议，效率高，但是不可靠，如微信，QQ

　　

五.DNS协议(基于udp协议)

DNS：域名解析协议，也就是将域名转换成相应的ip地址

详解：在自己电脑上输入www.jd.com，会以单播形式（1步）找到交换机，交换机查看自己的记录表有没有相应的网址，如果没有，继续单播（2步）找到路由器，路由器将网址传给DNS服务器（3步），返回相应的ip地址（4步），然后在自己的纪录表中查询返回的ip地址，如果没有，继续向公网发送请求，直到找到对应的服务器。

路由协议：会选取最优的路线

NAT：IP置换技术。在自己电脑上输入网址A，此时的源地址和目标地址分别是自身地址和交换机地址，然后切换为交换机地址和路由器地址，一直这样找下去，直到目标地址是网址A。

六.TCP(流式协议) socket通信

参考：https://www.cnblogs.com/jin-xin/articles/10064978.html

http是用的tcp/ip协议（tcp/ip是一个协议族，规定了ftp、邮件传输等方式）。 

socket是对tcp/IP的封装。

- TCP是传输层协议，而HTTP是应用层协议
- TCP就是单纯建立连接，不涉及任何我们需要请求的实际数据，简单的传输。
- HTTP是用来收发数据，即实际应用上来的。

6.1定义

socket是处于应用层和传输层之间的抽象层，他是一组操作起来非常简单的接口，此接口接受数据后，交给操作系统。

6.2socket抽象层存在原因：

如果直接与操作系统数据交互会非常繁琐，socket是对这些繁琐操作的高度封装、简化

6.3socket通信

listen(4)解释
在缓存区最多能有4个，不包括正在通信的，所以最多有5个客户端连接。

import socket
phone = socket.socket() # 默认流式协议
phone.bind(('127.0.0.1',8889))
phone.listen(3)
print("start...")
conn,addr = phone.accept()  # 等待连接建立
ret = conn.recv(1024)
conn.send("你好".encode("utf-8"))
conn.close()
phone.close()

import socket
phone = socket.socket()
phone.connect(('127.0.0.1',8889))
phone.send("你好".encode("utf-8"))
ret = phone.recv(1024)
print(ret.decode("utf-8"))

6.4socket通信（通信循环）

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)


conn, client_addr = phone.accept()
print(conn, client_addr, sep='\n')

while 1:  # 循环收发消息
    try:
        from_client_data = conn.recv(1024)
        print(from_client_data.decode('utf-8'))
    
        conn.send(from_client_data + b'SB')
    
    except ConnectionResetError:
        break

conn.close()
phone.close()

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号

while 1:  # 循环收发消息
    client_data = input('>>>')
    phone.send(client_data.encode('utf-8'))
    
    from_server_data = phone.recv(1024)
    
    print(from_server_data.decode('utf-8'))

phone.close()  # 挂电话

6.5 通信、连接循环

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

while 1 : # 循环连接客户端
    conn, client_addr = phone.accept()
    print(client_addr)
    
    while 1:
        try:
            from_client_data = conn.recv(1024)
            print(from_client_data.decode('utf-8'))
        
            conn.send(from_client_data + b'SB')
        
        except ConnectionResetError:
            break

conn.close()
phone.close()

服务端

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号


while 1:
    client_data = input('>>>')
    phone.send(client_data.encode('utf-8'))
    
    from_server_data = phone.recv(1024)
    
    print(from_server_data.decode('utf-8'))

phone.close()  # 挂电话

6.6 远程执行命令

import socket
import subprocess

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.bind(('127.0.0.1',8080))

phone.listen(5)

while 1 : # 循环连接客户端
    conn, client_addr = phone.accept()
    print(client_addr)
    
    while 1:
        try:
            cmd = conn.recv(1024)
            ret = subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            correct_msg = ret.stdout.read()
            error_msg = ret.stderr.read()
            conn.send(correct_msg + error_msg)
        except ConnectionResetError:
            break

conn.close()
phone.close()

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号


while 1:
    cmd = input('>>>')
    phone.send(cmd.encode('utf-8'))
    
    from_server_data = phone.recv(1024)
    
    print(from_server_data.decode('gbk'))

phone.close()  # 挂电话

七.UDP(数据报协议) socket通信

udp是无链接的，先启动哪一端都不会报错

 

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，recvform接收消息，这个消息有两项，消息内容和对方客户端的地址，然后回复消息时也要带着你收到的这个客户端的地址，发送回去，最后关闭连接，一次交互结束

import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)   #创建一个服务器的套接字
udp_sk.bind(('127.0.0.1',9000))        #绑定服务器套接字
msg,addr = udp_sk.recvfrom(1024)
print(msg)
udp_sk.sendto(b'hi',addr)                 # 对话(接收与发送)
udp_sk.close()                         # 关闭服务器套接字

import socket
ip_port=('127.0.0.1',9000)
udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr)

 

八.粘包

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

 

粘包现象主要是因为缓冲区

为什么存在缓冲区：

1.暂时存储一些数据.
2.缓冲区存在如果你的网络波动,保证数据的收发稳定,匀速.

每个 socket 被创建后，都会分配两个缓冲区，输入缓冲区和输出缓冲区。

write()/send() 并不立即向网络中传输数据，而是先将数据写入缓冲区中，再由TCP协议将数据从缓冲区发送到目标机器。一旦将数据写入到缓冲区，函数就可以成功返回，不管它们有没有到达目标机器，也不管它们何时被发送到网络，这些都是TCP协议负责的事情。

TCP协议独立于 write()/send() 函数，数据有可能刚被写入缓冲区就发送到网络，也可能在缓冲区中不断积压，多次写入的数据被一次性发送到网络，这取决于当时的网络情况、当前线程是否空闲等诸多因素，不由程序员控制。

read()/recv() 函数也是如此，也从输入缓冲区中读取数据，而不是直接从网络中读取。

这些I/O缓冲区特性可整理如下：

1.I/O缓冲区在每个TCP套接字中单独存在；
2.I/O缓冲区在创建套接字时自动生成；
3.即使关闭套接字也会继续传送输出缓冲区中遗留的数据；
4.关闭套接字将丢失输入缓冲区中的数据。

输入输出缓冲区的默认大小一般都是 8K，可以通过 getsockopt() 函数获取：

1.发生粘包的两种情况

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

import socket
import subprocess

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

while 1:  # 循环连接客户端
    conn, client_addr = phone.accept()
    print(client_addr)

    while 1:
        try:
            cmd = conn.recv(1024)
            ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            correct_msg = ret.stdout.read()
            error_msg = ret.stderr.read()
            conn.send(correct_msg + error_msg)
        except ConnectionResetError:
            break

conn.close()
phone.close()

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 买电话

phone.connect(('127.0.0.1',8080))  # 与客户端建立连接， 拨号


while 1:
    cmd = input('>>>')
    phone.send(cmd.encode('utf-8'))

    from_server_data = phone.recv(1024)

    print(from_server_data.decode('gbk'))

phone.close() 

# 由于客户端发的命令获取的结果大小已经超过1024，那么下次在输入命令，会继续取上次残留到缓存区的数据。

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

import socket


phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

conn, client_addr = phone.accept()

frist_data = conn.recv(1024)
print('1:',frist_data.decode('utf-8'))  # 1: helloworld
second_data = conn.recv(1024)
print('2:',second_data.decode('utf-8'))


conn.close()
phone.close()

import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  

phone.connect(('127.0.0.1', 8080)) 

phone.send(b'hello')
phone.send(b'world')

phone.close()  

# 两次返送信息时间间隔太短，数据小，造成服务端一次收取

2.粘包的解决方案:

struct模块，可以把一个类型转换成固定长度的bytes

import struct
# 将一个数字转化成等长度的bytes类型。
ret = struct.pack('i', 183346)
print(ret, type(ret), len(ret))

# 通过unpack反解回来
ret1 = struct.unpack('i',ret)[0]
print(ret1, type(ret1))


# 但是通过struct 处理不能处理太大

ret = struct.pack('l', 4323241232132324)
print(ret, type(ret), len(ret))  # 报错

方案一:

制作固定报头(要发送字节类型内容的长度)，客户端接受到服务端发来的报头和内容，对内容进行循环获取，然后将获取的数据组合再解码。如果是接受一数据，解码一条数据，很有可能造成编码错误，因为中文字符用utf-8编码占3个字节，可能将中文对应的字节切成两半。

import socket
import subprocess
import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

while 1:
    conn, client_addr = phone.accept()
    print(client_addr)
    
    while 1:
        try:
            cmd = conn.recv(1024)
            ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            correct_msg = ret.stdout.read()
            error_msg = ret.stderr.read()
            
            # 1 制作固定报头
            total_size = len(correct_msg) + len(error_msg)
            header = struct.pack('i', total_size)
            
            # 2 发送报头
            conn.send(header)
            
            # 发送真实数据：
            conn.send(correct_msg)
            conn.send(error_msg)
        except ConnectionResetError:
            break

conn.close()
phone.close()


# 但是low版本有问题：
# 1，报头不只有总数据大小，而是还应该有MD5数据，文件名等等一些数据。
# 2，通过struct模块直接数据处理，不能处理太大。

import socket
import struct
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.1',8080))


while 1:
    cmd = input('>>>').strip()
    if not cmd: continue
    phone.send(cmd.encode('utf-8'))
    
    # 1，接收固定报头
    header = phone.recv(4)
    
    # 2，解析报头
    total_size = struct.unpack('i', header)[0]
    
    # 3，根据报头信息，接收真实数据
    recv_size = 0
    res = b''
    
    while recv_size < total_size:
        
        recv_data = phone.recv(1024)
        res += recv_data
        recv_size += len(recv_data)

    print(res.decode('gbk'))

phone.close()

 方案二:

自定制报头（自己定义的dic中有要发送的数据的长度，前面4字节为bytes类型的dic的长度）。此例子用到json，是因为没有学习json之前，特殊类型要转换为bytes类型，需要先转化成str，因为str和bytes可以互相转换，但是一旦特殊类型转为str，是不能回转的(除非用eval，不建议使用)。将特殊类型转为json字符串，可以转换回来

import socket
import subprocess
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.bind(('127.0.0.1', 8080))

phone.listen(5)

while 1:
    conn, client_addr = phone.accept()
    print(client_addr)
    
    while 1:
        try:
            cmd = conn.recv(1024)
            ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            correct_msg = ret.stdout.read()
            error_msg = ret.stderr.read()
            
            # 1 制作固定报头
            total_size = len(correct_msg) + len(error_msg)
            
            header_dict = {
                'md5': 'fdsaf2143254f',
                'file_name': 'f1.txt',
                'total_size':total_size,
            }
            
            header_dict_json = json.dumps(header_dict) # str
            bytes_headers = header_dict_json.encode('utf-8')
            
            header_size = len(bytes_headers)
            
            header = struct.pack('i', header_size)
            
            # 2 发送报头长度
            conn.send(header)
            
            # 3 发送报头
            conn.send(bytes_headers)
            
            # 4 发送真实数据：
            conn.send(correct_msg)
            conn.send(error_msg)
        except ConnectionResetError:
            break

conn.close()
phone.close()

import socket
import struct
import json
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.1',8080))


while 1:
    cmd = input('>>>').strip()
    if not cmd: continue
    phone.send(cmd.encode('utf-8'))
    
    # 1，接收固定报头
    header_size = struct.unpack('i', phone.recv(4))[0]
    
    # 2，解析报头长度
    header_bytes = phone.recv(header_size)
    
    header_dict = json.loads(header_bytes.decode('utf-8'))
    
    # 3,收取报头
    total_size = header_dict['total_size']
    
    # 3，根据报头信息，接收真实数据
    recv_size = 0
    res = b''
    
    while recv_size < total_size:
        
        recv_data = phone.recv(1024)
        res += recv_data
        recv_size += len(recv_data)

    print(res.decode('gbk'))

phone.close()