网络编程

 一、软件开发的架构

　　第一种（应用类）：qq、微信、网盘、优酷这一类属于需要安装的桌面应用

　　第二种（web类）：百度、知乎、博客园等使用浏览器访问就可以直接使用的应用

　　这些应用的本质其实就是两个程序之间的通讯。而这两个分类又对应两个软件开发的架构~

1.C/S架构：

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

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

2.B/S架构

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

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

二、网络基础

1.osi七层模型

应用层、表示层、会话层、传输层、网络层、数据链路层、物理层

 2.socket概念

 

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

3.socket的发展史

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

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

　　套接字家族的名字：AF_UNIX

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

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

　　套接字家族的名字：AF_INET

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

4.tcp协议和udp协议

TCP：可靠的，面向连接的协议。传输效率低，全双工通信（发送缓存和接收缓存），面向字节流。使用TCP的应用：web浏览器、电子邮件、文件传输程序

UDP：不可靠的，无连接的服务。传输效率高，一对一，一对多，多对一，多对多都可以。尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统（DNS），视频流，IP语音。

三、套接字（socket）初使用

基于TCP协议的socket

server端：

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr = sk.accept()
while True:
    ret = conn.recv(1024).decode('utf-8')
    if ret == 'bye':
        break
    print(ret)
    info = input('>>>').strip()
    conn.send(bytes(info,encoding='utf-8'))
    if info == 'bye':
        break
conn.close()
sk.close()

client端：

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
while True:
    info = input('>>>').strip()
    sk.send(bytes(info,encoding='utf-8'))
    if info == 'bye':
        break
    ret = sk.recv(1024).decode('utf-8')
    print(ret)
    if ret == 'bye':
        break
sk.close()

解决重用端口问题：

#加入一条socket配置，重用ip和端口
import socket
from socket import SOL_SOCKET,SO_REUSEADDR
sk = socket.socket()
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
sk.bind(('127.0.0.1',8898))  #把地址绑定到套接字
sk.listen()          #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024)   #接收客户端信息
print(ret)              #打印客户端信息
conn.send(b'hi')        #向客户端发送信息
conn.close()       #关闭客户端套接字
sk.close()        #关闭服务器套接字(可选)

 基于UDP协议的socket

server

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',8080))
msg,addr = sk.recvfrom(1024)
print(msg)
sk.sendto(b'hi',addr)
sk.close()

client

import socket
ip_prod = ('127.0.0.1',8080)
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.sendto(b'hello',ip_prod)
msg,addr = sk.recvfrom(1024)
print(msg)
sk.close()

 聊天系统

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = ('127.0.0.1',8080)
sk.bind(ip_port)

while True:
    msg,addr = sk.recvfrom(1024)
    print('来自[%s:%s]的一条消息：33[1;44m%s33[0m'%(addr[0],addr[1],msg.decode('utf-8')))
    info = input('回复消息：').strip()
    sk.sendto(info.encode('utf-8'),addr)

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_pord = ('127.0.0.1',8080)
while True:
    info = input('请输入消息：').strip()
    if info == 'q':break
    sk.sendto(info.encode('utf-8'),ip_pord)
    msg,addr = sk.recvfrom(1024)
    print('来自%s:%s的一条消息：33[1;44m%s33[0m'%(addr[0],addr[1],msg.decode('utf-8')))
sk.close()

socket参数的详解

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

family	地址系列应为AF_INET(默认值),AF_INET6,AF_UNIX,AF_CAN或AF_RDS。 （AF_UNIX 域实际上是使用本地 socket 文件来通信）
type	套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。 SOCK_STREAM 是基于TCP的，有保障的（即能保证数据正确传送到对方）面向连接的SOCKET，多用于资料传送。  SOCK_DGRAM 是基于UDP的，无保障的面向消息的socket，多用于在网络上发广播信息。
proto	协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。
fileno	如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。 与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。 这可能有助于使用socket.close()关闭一个独立的插座。

四、黏包
TCP协议中的数据传递

　tcp协议的拆包机制

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

MTU：网络上传送的最大数据包。MTU的单位是字节。大部分网络设备的MTU都是1500.如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度。

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

TCP是面向连接的，面向流的，提供高可靠性的服务。

收发两端（客户端和服务器端）都有成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多将间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。

这样接收端就难于分辨出来了，必须提供科学的拆包机制。面向流的通信是无消息保护边界的。

对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容也可以被发送，udp协议会帮你封装上消息头发送过去。

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

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

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

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

UDP不会发生黏包

UDP是无连接的，面向消息的，提供高效率服务。

不会使用块的合并优化算法，由于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函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。

会发生黏包的两种情况

1.发送方的缓存机制

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

import socket
ip_port = ('127.0.0.1',8080)
sk = socket.socket()
sk.bind(ip_port)
sk.listen()
conn,addr = sk.accept()
data1 = conn.recv(10)
data2 = conn.recv(10)
print(data1.decode('utf-8'))
print(data2.decode('utf-8'))
conn.close()

import socket
ip_port = ('127.0.0.1',8080)
sk = socket.socket()
res = sk.connect_ex(ip_port)
sk.send('hello'.encode('utf-8'))
sk.send('feng'.encode('utf-8'))

2.接收方的缓存机制

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

import socket
ip_port = ('127.0.0.1',8080)
sk = socket.socket()
sk.bind(ip_port)
sk.listen()
conn,addr = sk.accept()
data1 = conn.recv(2)
data2 = conn.recv(10)
print(data1.decode('utf-8'))
print(data2.decode('utf-8'))
conn.close()

import socket
ip_port = ('127.0.0.1',8080)
sk = socket.socket()
res = sk.connect_ex(ip_port)
sk.send('hello feng'.encode('utf-8'))

总结

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

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

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

 黏包的解决方案

黏包的根本原因在于接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓。可以借用力struct模块来解决问题，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。

struct模块

import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)

#_*_coding:utf-8_*_
#http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html
__author__ = 'Linhaifeng'
import struct
import binascii
import ctypes

values1 = (1, 'abc'.encode('utf-8'), 2.7)
values2 = ('defg'.encode('utf-8'),101)
s1 = struct.Struct('I3sf')
s2 = struct.Struct('4sI')

print(s1.size,s2.size)
prebuffer=ctypes.create_string_buffer(s1.size+s2.size)
print('Before : ',binascii.hexlify(prebuffer))
# t=binascii.hexlify('asdfaf'.encode('utf-8'))
# print(t)


s1.pack_into(prebuffer,0,*values1)
s2.pack_into(prebuffer,s1.size,*values2)

print('After pack',binascii.hexlify(prebuffer))
print(s1.unpack_from(prebuffer,0))
print(s2.unpack_from(prebuffer,s1.size))

s3=struct.Struct('ii')
s3.pack_into(prebuffer,0,123,123)
print('After pack',binascii.hexlify(prebuffer))
print(s3.unpack_from(prebuffer,0))

可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节 

发送时	接收时
先发报头长度	先收报头长度，用struct取出来
再编码报头内容然后发送	根据取出的长度收取报头内容，然后解码，反序列化
最后发真实内容	从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

FTP：文件上传

import socket
import struct
import json
buffer = 1024
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr = sk.accept()
head_len = conn.recv(4)
head_len = struct.unpack('i',head_len)[0]
head = conn.recv(head_len).decode('utf-8')
head = json.loads(head)
filesize = head['file_size']
with open(head['filename'],'wb')as f:
    while filesize:
        print(filesize)
        if filesize >= buffer:
            content = conn.recv(buffer)
            f.write(content)
            filesize -= buffer
        else:
            content = conn.recv(filesize)
            f.write(content)
            break
conn.close()
sk.close()

import os
import socket
import struct
import json
buffer = 1024
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
head = {'filepath':r'D:python视频视频day8',
        'filename':r'01 python fullstack s9day8 文件操作一.mp4',
        'file_size':None}
file_path = os.path.join(head['filepath'],head['filename'])
filesize = os.path.getsize(file_path)
head['file_size'] = filesize
json_head = json.dumps(head)
bytes_head = json_head.encode('utf-8')
head_len = len(bytes_head)
pack_len = struct.pack('i',head_len)
sk.send(pack_len)
sk.send(bytes_head)
with open(file_path,'rb')as f:
    while filesize:
        print(filesize)
        if filesize >= buffer:
            contnet = f.read(buffer)
            sk.send(contnet)
            filesize -= buffer
        else:
            contnet = f.read(filesize)
            sk.send(contnet)
            break
sk.close()

 用hmac检测客户端登陆是否合法

客户端和服务端都确定好一个key，然后服务端随机发送个字节，双方加密验证是否一至。

server

import os
import hmac
import socket
secret_key = b'egg'
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
def check_conn(conn):
    msg = os.urandom(32)
    conn.send(msg)
    h = hmac.new(secret_key,msg)
    digest = h.digest()
    client_digest = conn.recv(1024)
    return hmac.compare_digest(digest,client_digest)
conn,addr = sk.accept()
res = check_conn(conn)
if res:
    print('OK')
else:
    print('NO')
conn.close()
sk.close()

client

import hmac
import socket
sectret_key = b'egg'
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
msg = sk.recv(1024)
h = hmac.new(sectret_key,msg)
digest = h.digest()
sk.send(digest)
sk.close()

socketserver

服务端可以和多人聊天

server端

import socketserver
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            # print(self.client_address)
            msg = self.request.recv(1024).decode('utf-8')
            if msg == 'q':
                break
            print(msg)
            info = input('>>>')
            self.request.send(info.encode('utf-8'))
if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)
    server.allow_reuse_address = True
    server.serve_forever()

client端，可以有多个

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
while True:
    msg = input('>>>')
    if msg == 'q':
        sk.send(b'q')
        break
    sk.send(msg.encode('utf-8'))
    ret = sk.recv(1024).decode('utf-8')
    print(ret)
sk.close()