python 基础之socket编程

一：客户端/服务端架构
二：osi七层模型
三：socket层
四：socket是什么
五：套接字发展史及分类
六：套接字工作流程
七：基于tcp的套接字
八：基于udp的套接字
九：粘包现象
十：什么是粘包
十一：解决粘包的处理方式（low版）
十二：峰哥解决粘包的方法
十三：socketserver

一：客户端/服务端架构

pass

三：socket层

四：socket是什么

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

所以，我们无需深入理解tcp/ip协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/ip协议的标准

也有人将socket说成是ip+port, ip是用来表示互联网中的一台物理主机的物理位置，而port是用来表示一台主机上的一个应用程序。ip地址是配置到网卡上的，而port是应用程序开启的，ip+port的绑定就标示了互联网中独一无二的一个应用程序而程序的pid是同一台机器上不同进程或者线程的标识

六：套接字工作流程

一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时候你和你的朋友就建立起了链接，就可以讲话了。等交流结束，挂掉电话结束此次交谈。生活中的场景就解释了这工作原理

先从服务端说起。服务端先初始化Socket,然后于绑定ip（bind），对端口进行监听（listen），调用accept阻塞，知道有客户端连接

客户端：也要初始化一个Socket，然后连接服务端（connnect），如果连接成功，这时候客户端与服务端的连接就建立了。

客户端发送数据请求，服务端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

socket（）模块函数用法

import socket
#获取tcp/ip套接字
tcpsocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#获取udp套接字
udpsocket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

服务端套接字函数

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在待发送数据量大于自己端缓存区剩余空间时，数据不丢失，循环使用shend知道发完

s.recvfrom()接收udp数据

s.sendto()发送udp数据

s.getpeername()连接到当前套接字的远端的地址

s.getsockname()当前套接字的地址

s.getsockopt()返回制定套接字的参数

s.setsocketopt()设置指定套接字的参数

s.close()关闭套接字

面向锁的套接字的方法

s.setblocking()设置套接字的阻塞和非阻塞模式

s.settimeout()设置阻塞套接字操作的超时时间

s.gettimeout()得到阻塞套接字操作的超时时间

面向文件的套接字的函数

s.fileno()套接字的文件描述符

s.makefile()创建一个与该套接字相关的文件

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

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

参数一：地址簇

　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6

　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信

参数二：类型

　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
　　socket.SOCK_DGRAM　　数据报式socket , 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 可靠的连续数据包服务

参数三：协议

　　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

参数一：地址簇

　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6

　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信

参数二：类型

　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
　　socket.SOCK_DGRAM　　数据报式socket , for UDP

参数三：协议

　　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

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)
while True:#新增接收链接循环，可以不停的接电话
    conn,addr=s.accept()
    while True: #新增通信循环，可以不停的收发消息
        try:
            msg=conn.recv(bufsize)
            if len(msg)==0:break#若接收的msg长度为o直接跳出本次循环
            print(msg,type(msg))
            conn.send(msg.upper())
        except Exception as e:
            print(e)
            break
    conn.close()
s.close()

server端

import socket
bufsize=1024
ip_port=("127.0.0.1",9000)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(ip_port)
while True: #新增通信循环
    msg=input("input:>> ").strip()
    if len(msg)==0:continue #判断输入为空，跳出本次循环
    s.send(msg.encode('utf-8')) #只能传输bytes类型
    data=s.recv(bufsize)
    print(data.decode("utf-8"))
s.close()

client端

八，基于udp的套接字没有连接状态！

udp服务端

1 ss=socket() 创建服务端的一个套接字

2 ss.bind（）绑定服务器套接字

3 while True：服务器连接无限循环

　　4 cs=ss.recvfrom()对话-接收消息

　　5 ss.sendto()对话-发送消息

6 ss.close（）关闭服务器套接字

udp客户端

cs=socket() 创建客户端套接字

while True：通讯循环

　　cs.sendto() 对话-发送消息

　　cs.recvfrom() 对话-接收消息

cs.close() 关闭客户端套接字

qq聊天案例

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机
udp_server_sock.bind(ip_port)

while True:
    qq_msg,addr=udp_server_sock.recvfrom(1024)
    print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg=input('回复消息: ').strip()

    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

server端

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
BUFSIZE=1024
udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

qq_name_dic={
    '狗哥alex':('127.0.0.1',8081),
    '瞎驴':('127.0.0.1',8081),
    '一棵树':('127.0.0.1',8081),
    '武大郎':('127.0.0.1',8081),
}


while True:
    qq_name=input('请选择聊天对象: ').strip()
    while True:
        msg=input('请输入消息,回车发送: ').strip()
        if msg == 'quit':break
        if not msg or not qq_name or qq_name not in qq_name_dic:continue
        udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
        print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))

udp_client_socket.close()

client1

九，粘包现象

让我们基于tcp先制作一个远程执行命令的程序（1：执行错误命令，2执行ls,3 执行ifconfig）

注意下：

res=subprocess.Popen(cmd.decode("utf-8")),

shell=True,

stderr=subprocess.PIPE,

stdout=subprocess.PIPE)

的结果的编码是以当前所在的系统为准，如果是Windows，那么，res.stdout.read()读出的就是GBK编码的，在接收端需要GBK解码，而且只能从管道里读一次结果

注意;命令ls-l ；abcd;pwd 的结果是既有正确的stdout结果，又有stderr错误的结果（多个命令拼接在一起）

十什么是粘包：

须知：只有TCP有粘包现象，UDP永远不会粘包，为何，且听我娓娓道来

首先需要掌握一个socket收发消息的原理

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

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

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

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

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通信是无消息保护边界的。
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略

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

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

两种情况下会发生粘包。

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

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

十一解决粘包的low比处理方法

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

实现ssh远程执行命令low版

import socket
import subprocess
import struct

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议
phone.bind(('127.0.0.1',8080))
phone.listen(5)

while True:
    conn,client_addr=phone.accept() #(套接字链接,客户端的ip和port)
    print(client_addr)

    while True: #通信循环
        #收消息
        try:
            cmd=conn.recv(1024) # 1024最大的限制
            if not cmd:break #针对linux系统

            #执行，拿到执行结果
            obj = subprocess.Popen(cmd.decode('gbk'), shell=True,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)

            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()
            #先发报头
            total_size=len(stderr_res)+len(stdout_res)
            conn.send(struct.pack('i',total_size))

            #再发真是的数据
            # conn.send(stdout_res+stderr_res)
            conn.send(stdout_res)
            conn.send(stderr_res)
        except ConnectionResetError:
            break

    #挂电话
    conn.close()

#关机
phone.close()

服务端

import socket
import struct

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#发起电话链接
phone.connect(('127.0.0.1',8080))


while True:
    #发消息
    cmd=input('>>: ').strip()
    if not cmd:continue
    phone.send(cmd.encode('gbk'))

    #先收报头
    header_struct=phone.recv(4)
    total_size=struct.unpack('i',header_struct)[0]

    #再收消息
    cmd_res=b''
    recv_size=0
    while recv_size < total_size:
        recv_data=phone.recv(1024)
        cmd_res+=recv_data
        recv_size+=len(recv_data)

    print(cmd_res.decode('gbk'))

#关机
phone.close()

客户端

为何low：

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

十二峰哥解决粘包的方法

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

struct模块

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

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

。。。。。。。。。

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

import socket
import subprocess
import struct
import json

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议
phone.bind(('127.0.0.1',8080))
phone.listen(5)

while True:
    conn,client_addr=phone.accept() #(套接字链接,客户端的ip和port)
    print(client_addr)

    while True: #通信循环
        #收消息
        try:
            cmd=conn.recv(1024) # 1024最大的限制
            if not cmd:break #针对linux系统

            #执行，拿到执行结果
            obj = subprocess.Popen(cmd.decode('gbk'), shell=True,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)

            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()

            # 制作报头
            header_dic = {
                'filename': 'a.txt',
                'total_size': len(stdout_res)+len(stderr_res),
                'md5': 'xxxxxxxxx'
            }
            head_json = json.dumps(header_dic)
            head_bytes = head_json.encode('utf-8')




            #先发报头长度
            conn.send(struct.pack('i',len(head_bytes)))

            #先发报头
            conn.send(head_bytes)

            #再发真是的数据
            # conn.send(stdout_res+stderr_res)
            conn.send(stdout_res)
            conn.send(stderr_res)
        except ConnectionResetError:
            break

    #挂电话
    conn.close()

#关机
phone.close()

服务端

import socket
import struct
import json

#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM代表TCP协议

#发起电话链接
phone.connect(('127.0.0.1',8080))


while True:
    #发消息
    cmd=input('>>: ').strip()
    if not cmd:continue
    phone.send(cmd.encode('gbk'))

    #先收报头长度
    struct_res=phone.recv(4)
    header_size=struct.unpack('i',struct_res)[0]

    #再收报头
    head_bytes=phone.recv(header_size)
    head_json=head_bytes.decode('utf-8')
    head_dic=json.loads(head_json)
    print(head_dic)

    #最收消息
    cmd_res=b''
    recv_size=0
    total_size=head_dic['total_size']
    while recv_size < total_size:
        recv_data=phone.recv(1024)
        cmd_res+=recv_data
        recv_size+=len(recv_data)

    print(cmd_res.decode('gbk'))

#关机
phone.close()

客户端

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

发送时：

先发报头长度

再编码报头内容然后发送

最后发真实内容

接收时：

先手报头长度，用struct取出来

根据取出的长度收取报头内容，然后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

十三 socketserver 实现并发

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

socketserver模块中分为两大类：

server类（）解决链接问题

request类（）解决通信问题

源码分析总结：

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

1 self.server 即套接字对象

2 self.request 即一个链接

3 self.client_addr 即客户端地址

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

1 self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象）

2 self.client_addr 即客户端地址

import socketserver
import struct
import json
import os
class FtpServer(socketserver.BaseRequestHandler):
    coding='utf-8'
    server_dir='file_upload'
    max_packet_size=1024
    BASE_DIR=os.path.dirname(os.path.abspath(__file__))
    def handle(self):
        print(self.request)
        while True:
            data=self.request.recv(4)
            data_len=struct.unpack('i',data)[0]
            head_json=self.request.recv(data_len).decode(self.coding)
            head_dic=json.loads(head_json)
            # print(head_dic)
            cmd=head_dic['cmd']
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func(head_dic)
    def put(self,args):
        file_path = os.path.normpath(os.path.join(
            self.BASE_DIR,
            self.server_dir,
            args['filename']
        ))

        filesize = args['filesize']
        recv_size = 0
        print('----->', file_path)
        with open(file_path, 'wb') as f:
            while recv_size < filesize:
                recv_data = self.request.recv(self.max_packet_size)
                f.write(recv_data)
                recv_size += len(recv_data)
                print('recvsize:%s filesize:%s' % (recv_size, filesize))


ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
ftpserver.serve_forever()

FtpServer

import socket
import struct
import json
import os



class MYTCPClient:
    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding='utf-8'

    request_queue_size = 5

    def __init__(self, server_address, connect=True):
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if connect:
            try:
                self.client_connect()
            except:
                self.client_close()
                raise

    def client_connect(self):
        self.socket.connect(self.server_address)

    def client_close(self):
        self.socket.close()

    def run(self):
        while True:
            inp=input(">>: ").strip()
            if not inp:continue
            l=inp.split()
            cmd=l[0]
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func(l)


    def put(self,args):
        cmd=args[0]
        filename=args[1]
        if not os.path.isfile(filename):
            print('file:%s is not exists' %filename)
            return
        else:
            filesize=os.path.getsize(filename)

        head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
        print(head_dic)
        head_json=json.dumps(head_dic)
        head_json_bytes=bytes(head_json,encoding=self.coding)

        head_struct=struct.pack('i',len(head_json_bytes))
        self.socket.send(head_struct)
        self.socket.send(head_json_bytes)
        send_size=0
        with open(filename,'rb') as f:
            for line in f:
                self.socket.send(line)
                send_size+=len(line)
                print(send_size)
            else:
                print('upload successful')




client=MYTCPClient(('127.0.0.1',8080))

client.run()

发表于 2017-11-08 10:25 huazai007 阅读(160) 评论(0) 收藏举报

十一 解决粘包的low比处理方法

十二 峰哥解决粘包的方法

十一解决粘包的low比处理方法

十二峰哥解决粘包的方法