Python基础（十）socket编程

软件架构

C/S架构

概念：

　　C指client，客户机、客户端，供用户使用

　　S指server，服务器，处理软件的逻辑

　　例如：QQ、WPS等软件

特点：

　　软户需要安装客户端，通过客户端访问服务器 

　　软件更新时，服务器和客户端都需要更新 

　　C/S架构出的一个软件不可以跨平台 

　　客户端和服务器通信采用自由协议，相对安全 

B/S架构

概念： 

　　B指brower,浏览器，可以看做特殊的客户端（B/S可以看作特殊的C/S） 

　　例如：京东官网、知乎官网等 

特点： 

　　用户通过浏览器访问网页的形式访问服务器 

　　只需要更新服务器 

　　可以跨平台（只需要系统中有浏览器） 

　　客户端和服务器通信采用通用的HTTP协议，相对不安全（https比http的网站更安全）

socket概念及分类

作用：socket（套接字）可以实现客户端与服务端的网络通信

OSI七层

如果向实现网络基于网络通信的软件就必须实现一系列网络协议（网络的核心就是一堆协议）

软件属于应用层

tcp是双向连接的

socket抽象层

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

也有人将socket说成 ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序

而程序的pid是同一台机器上不同进程或者线程的标识

 socket分类

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

套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。 

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

　　　套接字家族的名字：AF_UNIX

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

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

　　　套接字家族的名字：AF_INET

　　　(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

socket工作流程

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

基于tcp的套接字

服务端

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

客户端

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

tcp

三次握手时，是为了建立客户端和服务端之间的双向连接，此时二者之间没有进行数据传输。

客户端向服务端发送连接请求（访问）；

服务端接收到并返回同意（ACK），此时，从客户端到服务器的单向连接打通，一起返回的还有服务端对客户端的连接请求；

客户端收到请求并返回同意（ACK），服务器到客户端的单向连接打通。客户端和服务端的双向连接成功建立

四次挥手

客户端数据发完了，向服务端发送断开连接的请求；

服务端收到请求，返回同意（ACK），此时客户端到服务端的单向连接断开；

服务端再向客户端发送断开连接的请求；

客户端收到后，返回同意，此时服务端到客户端的单向连接也断开。

为什么握手三次，挥手要四次？

第二次挥手后，服务端可能发送到客户端的数据还没有传输结束，所以不能再第二次挥手时同时返回断开连接的请求，就要加入第三次挥手。

通常四次挥手的FIN 1 一般都是由服务器发起的，服务器每次传输完数据后都会主动断开连接，以节省资源，不会把时间浪费在TIME_WAIT上。这样可以提高服务器的对外访问速度

 例子

tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM )
# socket.AF_INET  指地址家族
# socket.SOCK_STREM 指面向连接，基于tcp协议

phone.bind(('192.168.0.106', 8000))

phone.listen(5) #允许建立的最大连接数

connect, addr = phone.accept()

recv_msg = connect.recv(1024)
print('从客户端发来的信息是：', recv_msg)

send_msg = '我已经收到你的消息了，是不是：'.encode('utf-8') + recv_msg
connect.send(send_msg)

connect.close()
phone.close()

import socket

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

phone.connect(('192.168.0.106', 8000)) #连接到服务的的端口

phone.send('hello python!'.encode('utf-8'))

msg = phone.recv(1024)
print('收到的消息是：', msg.decode('utf-8'))

添加连接循环、通信循环和异常处理

# 加入while循环，实现交互

# import socket

from socket import *

ip_port = ('192.168.0.106', 7000)
back_log = 5
buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True: #添加连接循环
    print('服务端开始运行====>')
    connect, addr = tcp_server.accept()
    print('双向连接：', connect)
    print('客户端地址：', addr)
    while True: #添加通信循环
        try:
            rec_msg = connect.recv(buffer_size)
            print('从客户端收到的消息：', rec_msg.decode('utf-8'))
            connect.send(rec_msg.upper())
            print('客户端信息发送成功')
        except Exception:
            break
    connect.close()

tcp_server.close()

from socket import *

ip_port = ('192.168.0.106', 7000)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:
    msg = input('请输入-->')
    if not msg:continue
    tcp_client.send(msg.encode('utf-8'))
    print('客户端a发送成功')
    rev_msg = tcp_client.recv(buffer_size)
    print('从服务端收到的消息：', rev_msg.decode('utf-8'))

tcp_client.close()

from socket import *

ip_port = ('192.168.0.106', 7000)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:
    msg = input('请输入-->')
    if not msg:continue
    tcp_client.send(msg.encode('utf-8'))
    print('客户端b发送成功')
    rev_msg = tcp_client.recv(buffer_size)
    print('从服务端收到的消息：', rev_msg.decode('utf-8'))

tcp_client.close()

注意：

　　这个例子中 tcp 话不能实现并发

　　rec send都要经过操作系统-网卡，从内核态内存中读取数据到用户态内存. 客户端如果发送为空（比如回车），此时服务端的缓冲区为空，recv就会卡住，可以加入if 解决

　　内核态内存存放操作系统的相关内存

　　用户态内存存放其他用户程序的相关内存

　　

Address already in use 这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址

 解决方法：

#加入一条socket配置，重用ip和端口

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))

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

基于udp的套接字

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

服务端

 ss = socket()   #创建一个服务器的套接字
 ss.bind()       #绑定服务器套接字
 inf_loop:       #服务器无限循环
     cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
 ss.close()                         # 关闭服务器套接字

客户端

cs = socket()   # 创建客户套接字
comm_loop:      # 通讯循环
    cs.sendto()/cs.recvfrom()   # 对话(发送/接收)
cs.close()                      # 关闭客户套接字

简单示例

import time
from socket import *

ip_port = ('192.168.0.106', 7000)
buffer_size = 1024

udp_server = socket(AF_INET, SOCK_DGRAM)
udp_server.bind(ip_port)

while True:
    msg, addr = udp_server.recvfrom(buffer_size)

    if not msg:
        fmt = '%Y-%m-%d %X'
    else:
        fmt = msg.decode('utf-8')
    send_msg = time.strftime(fmt)

    udp_server.sendto(send_msg.encode('utf-8'), addr)

 

from socket import *

ip_port = ('192.168.0.106', 7000)
buffer_size = 1024

udp_client = socket(AF_INET, SOCK_DGRAM) #数据包 data gram

while True:
    msg = input('请输入-->')
    udp_client.sendto(msg.encode('utf-8'), ip_port)

    re_msg, addr = udp_client.recvfrom(buffer_size)
    print(re_msg)

from socket import *

ip_port = ('192.168.0.106', 7000)
buffer_size = 1024

udp_client = socket(AF_INET, SOCK_DGRAM) #数据包 data gram

while True:
    msg = input('请输入-->')
    udp_client.sendto(msg.encode('utf-8'), ip_port)

    re_msg, addr = udp_client.recvfrom(buffer_size)
    print(re_msg)

由于udp是无连接的，所以多个客户端可以同时跟服务端通信

粘包

粘包现象

利用tcp制作一个远程执行命令的程序

read出的结果是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码

且只能从管道里读一次结果

from  socket import *
import subprocess

ip_port = ('192.168.0.106', 7070)
back_log = 5
buffer_size = 1024

s_server = socket(AF_INET, SOCK_STREAM)
s_server.bind(ip_port)
s_server.listen(back_log)

while True:
    con, addr = s_server.accept()
    print('连接成功', addr)

    while True:
        try:
            cmd = con.recv(buffer_size)
            if not cmd:break
            # 执行命令并得到命令的执行结果
            res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
                                   stderr=subprocess.PIPE,
                                   stdout=subprocess.PIPE,
                                   stdin=subprocess.PIPE)
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()

            if not cmd_res:
                cmd_res = '执行成功呀呀呀'.encode('GBK')
            con.send(cmd_res)
        except Exception as e:
            print(e)
            break
            # con.close()
s_server.close()

from  socket import *

ip_port = ('192.168.0.106', 7070)
back_log = 5
buffer_size = 1024

s_client = socket(AF_INET, SOCK_STREAM)
s_client.connect(ip_port)

while True:
    cmd = input('请输入-->')
    if not cmd:continue
    s_client.send(cmd.encode('utf-8'))

    cmd_res = s_client.recv(buffer_size)
    print('命令执行结果是：', cmd_res.decode('GBK'))

s_client.close()

  

 利用udp制作一个远程执行命令的程序

from socket import *
import subprocess

ip_port = ('192.168.0.106', 6060)
buffer_size = 1024

udp_ser = socket(AF_INET, SOCK_DGRAM)
udp_ser.bind(ip_port)

while True:
    msg, addr = udp_ser.recvfrom(buffer_size)

    res = subprocess.Popen(msg.decode('utf-8'), shell=True,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE,
                     stdin=subprocess.PIPE)
    err = res.stderr.read()

    if err:
        msg_send = err
    else:
        msg_send = res.stdout.read()
    if not msg_send:
        msg_send = '执行成功呀呀呀'.encode('GBK')

    udp_ser.sendto(msg_send, addr)


udp_ser.close()

from  socket import *

ip_port = ('192.168.0.106', 6060)
buffer_size = 1024

udp_client = socket(AF_INET, SOCK_DGRAM)

while True:
    msg_send = input('请输入-->')
    udp_client.sendto(msg_send.encode('utf-8'), ip_port)

    msg_rev, addr = udp_client.recvfrom(buffer_size)
    print(msg_rev.decode('gbk'),end='')

# udp_client.close()

粘包分析

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

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。

而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

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

所谓粘包问题主要是因为接收方不知道不同信息之间的界限，不知道该提取多少字节而造成的

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。

tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头

tcp: send发消息  recv收消息

udp： sendto发消息  recvfrom收消息

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

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

粘包的两种情况

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

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

拆包的情况

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

为什么tcp是可靠传输，udp是不可靠传输？

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

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

send(字节流)和recv(1024)及sendall

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

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

解决粘包

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

low版本的解决方法

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket,subprocess
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    print('客户端',addr)
    while True:
        msg=conn.recv(1024)
        if not msg:break
        res=subprocess.Popen(msg.decode('utf-8'),shell=True,
                            stdin=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         stdout=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            ret=err
        else:
            ret=res.stdout.read()
        data_length=len(ret)
        conn.send(str(data_length).encode('utf-8')) #告诉对面真正数据的长度
        data=conn.recv(1024).decode('utf-8')
        if data == 'recv_ready': #发送真正的数据
            conn.sendall(ret)
    conn.close()

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))
    length=int(s.recv(1024).decode('utf-8')) #知道了该接收多少字节的数据
    s.send('recv_ready'.encode('utf-8'))
    send_size=0
    recv_size=0
    data=b''
    while recv_size < length:
        data+=s.recv(1024)
        recv_size+=len(data)


    print(data.decode('utf-8'))

为何low：

程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗

解决方法：

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据。

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)

sruct模块

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

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

。。。。。。。。。

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

recv和recvfrom

tcp: send发消息  recv收消息

udp： sendto发消息  recvfrom收消息

（1）tcp协议：

　　如果收消息时缓冲区中数据为空，那么recv会堵塞

　　tcp基于链接通信，如果一端断开了链接，那么另一端的链接也跟着结束，recv不会堵塞，会一直收空

（2）udp协议

　　如果消息缓冲区数据为空，recvfrom不会堵塞

　　recvfrom收的数据小于sento发送的数据时，数据丢失

　　只有sendto没有recvfrom，数据也会丢失

udp协议只把包发出去，不管对方收不收，而tcp是基于链接的，必须有一个服务端在运行着，客户端去和服务端建立双向链接才能传递信息，任何一方摧毁链接都会导致对方程序崩溃。

总结：

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

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

socketserver实现并发

基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环

socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）

服务端：

import socketserver

class MyServer(socketserver.BaseRequestHandler):

    def handle(self): #进行通信循环
        print('双向连接:', self.request)
        print('客户端地址:', self.client_address)
        print('套接字对象:', self.server)

        while True:
            try:
                # 收
                rec_msg = self.request.recv(1024)
                if not rec_msg:break
                print('客户端传来的消息是：', rec_msg)

                # 发
                self.request.sendall(rec_msg.upper())
            except Exception as err:
                print(err)
                break

if __name__ == '__main__':
    s = socketserver.ThreadingTCPServer(('192.168.0.106', 6060), MyServer) #进行连接循环,实现并发
    s.serve_forever()

from socket import *

ip_port = ('192.168.0.106', 6060)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:
    msg = input('请输入-->')
    if not msg:continue
    tcp_client.send(msg.encode('utf-8'))
    print('客户端a发送成功')
    rev_msg = tcp_client.recv(buffer_size)
    print('从服务端收到的消息：', rev_msg.decode('utf-8'))

tcp_client.close()

基于tcp的socketserver我们自己定义的类中的

1. 　　self.server即套接字对象
2. 　　self.request即一个链接
3. 　　self.client_address即客户端地址

基于udp的socketserver我们自己定义的类中的

1. 　　self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
2. 　　self.client_address即客户端地址

 认证客户端的合法性

如果你想在分布式系统中实现一个简单的客户端链接认证功能，又不像SSL那么复杂，那么利用hmac+加盐的方式来实现

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang'
def conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    print('开始验证新链接的合法性')
    msg=os.urandom(32)
    conn.sendall(msg)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    respone=conn.recv(len(digest))
    return hmac.compare_digest(respone,digest)

def data_handler(conn,bufsize=1024):
    if not conn_auth(conn):
        print('该链接不合法,关闭')
        conn.close()
        return
    print('链接合法,开始通信')
    while True:
        data=conn.recv(bufsize)
        if not data:break
        conn.sendall(data.upper())

def server_handler(ip_port,bufsize,backlog=5):
    '''
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server=socket(AF_INET,SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn,addr=tcp_socket_server.accept()
        print('新连接[%s:%s]' %(addr[0],addr[1]))
        data_handler(conn,bufsize)

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    server_handler(ip_port,bufsize)

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang'
def conn_auth(conn):
    '''
    验证客户端到服务器的链接
    :param conn:
    :return:
    '''
    msg=conn.recv(32)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    conn.sendall(digest)

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    conn_auth(tcp_socket_client)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang1111'
def conn_auth(conn):
    '''
    验证客户端到服务器的链接
    :param conn:
    :return:
    '''
    msg=conn.recv(32)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    conn.sendall(digest)

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    conn_auth(tcp_socket_client)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)

项目：开发一个支持多用户在线的FTP程序

项目要求

1. 用户加密认证
2. 允许同时多用户登录
3. 每个用户有自己的家目录 ，且只能访问自己的家目录
4. 对用户进行磁盘配额，每个用户的可用空间不同
5. 允许用户在ftp server上随意切换目录
6. 允许用户查看当前目录下文件
7. 允许上传和下载文件，保证文件一致性
8. 文件传输过程中显示进度条
9. 附加功能：支持文件的断点续传

项目分析

1.用户加密认证

参考

网络基础之网络协议篇https://www.cnblogs.com/linhaifeng/articles/5937962.html

socket编程https://www.cnblogs.com/linhaifeng/articles/6129246.html#_label2