网络编程-SOCKET开发

Posted 2020-11-24 sxy-blog

计算机基础知识

 

计算机分三层：应用程序、 操作系统、硬件。
硬件是用来干活的，应用程序想要实现一定的功能就要调用硬件工作。
但是如果每一个软件开发，都要写怎么操作硬件的代码，就会有大量重复的代码，而且十分复杂。
因此，操作系统就出现了，操作系统相当于提供了一套接口，软件的功能通过操作系统，操作系统再让硬件工作。
应用程序无法直接让硬件工作 只能间接地通过操作系统使硬件工作实现特定的功能。

 

作为应用开发程序员，我们开发的软件都是应用软件，而应用软件必须运行于操作系统之上，操作系统则运行于硬件之上，

应用软件是无法直接操作硬件的，应用软件对硬件的操作必须调用操作系统的接口，由操作系统操控硬件。

 

比如客户端软件想要基于网络发送一条消息给服务端软件，流程是：
1、客户端软件产生数据，存放于客户端软件的内存中，然后调用接口将自己内存中的数据发送／拷贝给操作系统内存
2、客户端操作系统收到数据后，按照客户端软件指定的规则（即协议）、调用网卡发送数据
3、网络传输数据
4、服务端软件调用系统接口，想要将数据从操作系统内存拷贝到自己的内存中
5、服务端操作系统收到4的指令后，使用与客户端相同的规则（即协议）从网卡接收到数据，然后拷贝给服务端软件

 

 

CS架构

C指的是client（客户端软件），S指的是Server（服务端软件），本章的重点就是教大家写一个C/S架构的软件，实现服务端软件与客户端软件基于网络通信。

 

硬件之上安装好操作系统，然后装上软件你就可以正常使用了，但此时你也只能自己使用，像下图这样，每个人都拥有一台自己的机器，然而彼此孤立。

 

然而internet为何物？举一个简单的例子： 如果把一个人与这个人的有线电话比喻为一台计算机，那么其实两台计算机之间通信与两个人打电话之间通信的原理是一样的。

两个人之间想要打电话首先一点必须是接电话线，这就好比是计算机之间的通信首先要有物理链接介质，比如网线，交换机，路由器等网络设备。

通信的线路建好之后，只是物理层面有了可以承载数据的介质，要想通信，还需要我们按照某种规则组织我们的数据，这样对方在接收到数据后就可以按照相同的规则去解析出数据，

这里说的规则指的就是：中国有很多地区，不同的地区有不同的方言，为了全中国人都可以听懂，大家统一讲普通话。

 

普通话属于中国国内人与人之间通信的标准，那如果是两个国家的人交流呢？

问题是，你不可能要求一个人／计算机掌握全世界的语言／标准，于是有了世界统一的通信标准：英语

英语成为世界上所有人通信的统一标准，计算机之间的通信也应该有一个像英语一样的通信标准，这个标准称之为互联网协议，

可以很明确地说：互联网协议就是计算机界的英语，网络就是物理链接介质+互联网协议。

 

 

我们需要做的是，让全世界的计算机都学会互联网协议，这样任意一台计算机在发消息时都严格按照协议规定的格式去组织数据，接收方就可以按照相同的协议解析出结果了，

这就实现了全世界的计算机都能无障碍通信。 按照功能不同，人们将互联网协议分为osi七层或tcp/ip五层或tcp/ip四层（我们只需要掌握tcp/ip五层协议即可），

这种分层就好比是学习英语的几个阶段，每个阶段应该掌握专门的技能或者说完成特定的任务，比如：1、学音标 2、学单词 3、学语法 4、写作文。。。

人打电话之间通信的原理是一样的。

每层运行常见物理设备（了解）

 

TCP/IP

Transmission Control Protocol/Internet Protocol的简写，中译名为传输控制协议/因特网互联协议，又名网络通讯协议，是Internet最基本的协议、Internet国际互联网络的基础。

 

TCP/IP五层模型

我们将应用层，表示层，会话层并作应用层，从tcp／ip五层协议的角度来阐述每层的由来与功能，

搞清楚了每层的主要协议，就理解了整个互联网通信的原理。

首先，用户感知到的只是最上面一层应用层，自上而下每层都依赖于下一层，所以我们从最下一层开始切入，比较好理解，

每层都运行特定的协议，越往上越靠近用户，越往下越靠近硬件。

 

物理层

物理层由来：上面提到，孤立的计算机之间要想一起玩，就必须接入internet，言外之意就是计算机之间必须完成组网。

物理层功能：主要是基于电器特性发送高低电压(电信号)，高电压对应数字1，低电压对应数字0。

 

数据链路层

数据链路层由来：单纯的电信号0和1没有任何意义，必须规定电信号多少位一组，每组什么意思

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

通过分组我们就可以把二进制对应到指定的字符，从而完成数据的解析。

以太网协议

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

ethernet规定

• 一组电信号构成一个数据包，叫做‘帧’
• 每一数据帧分成：报头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采用最原始的方式，广播的方式进行通信，即计算机通信基本靠吼。

 

网络层

网络层由来：有了ethernet、mac地址、广播的发送方式，世界上的计算机就可以彼此通信了，

问题是世界范围的互联网是由一个个彼此隔离的小的局域网组成的，那么如果所有的通信都采用以太网的广播方式，

那么一台机器发送的包全世界都会收到，这就不仅仅是效率低的问题了，这会是一种灾难。

上图结论：必须找出一种方法来区分哪些计算机属于同一广播域，哪些不是，如果是就采用广播的方式发送，

如果不是，就采用路由的方式（向不同广播域／子网分发数据包），mac地址是无法区分的，它只跟厂商有关

 

网络层功能：引入一套新的地址用来区分不同的广播域／子网，这套地址即网络地址。

IP协议

• 规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示
• 范围0.0.0.0-255.255.255.255
• 一个ip地址通常写成四段十进制数，例：172.16.10.1

子网掩码

所谓”子网掩码”，就是表示子网络特征的一个参数。

它在形式上等同于IP地址，也是一个32位二进制数字，它的网络部分全部为1，主机部分全部为0。

比如，IP地址172.16.10.1，如果已知网络部分是前24位，主机部分是后8位，

那么子网络掩码就是11111111.11111111.11111111.00000000，写成十进制就是255.255.255.0。

 

子网掩码是用来标识一个IP地址的哪些位是代表网络位，以及哪些位是代表主机位。子网掩码不能单独存在，它必须结合IP地址一起使用。

子网掩码只有一个作用，就是将某个IP地址划分成网络地址和主机地址两部分。

 

区分网络位和主机位是为了划分子网，就是把一个大网络分成多个小网络，为什么要分子网呢?

• 广播风暴：6万台主机在一个网段里，通信基本靠吼，任何一个人要吼一嗓子，6万多个人必须被动听着，一会你的网络就瘫痪啦。
• 地址浪费：运营商在公网上有很多级联的路由器，有时候2个路由器之间只会用掉几个IP,如果不进行子网划分，那同网段的其它主机也就都不能用了。举例两个级联路由器的接口ip分别为222.34.24.12/24,222.34.24.13/24, 此可承载255个主机的网段只用了2个IP,那其它的就全浪费了，因为不能再分配给别人。

划分子网本质上就是借主机位到给网络位，每借一位主机位，这个网段的可分配主机就会越少，比如192.168.1.0/24可用主机255个，借一位变成192.168.1.0/25，那可用主机就从255-128=127个

了（从最大的值开始借），再借一位192.168.1.0/26,那可用主机数就变成了255-(128+64)=63个了。

 关于IP和子网划分的具体讲解：https://www.cnblogs.com/linhaifeng/articles/5951486.html

 

IP地址分类

IP地址根据网络ID的不同分为5种类型，A类地址、B类地址、C类地址、D类地址和E类地址。

1. A类IP地址：一个A类IP地址由1字节的网络地址和3字节主机地址组成，网络地址的最高位必须是“0”， 地址范围从1.0.0.0 到126.0.0.0。可用的A类网络有126个，每个网络能容纳1亿多个主机。
2. B类IP地址 ：一个B类IP地址由2个字节的网络地址和2个字节的主机地址组成，网络地址的最高位必须是“10”，地址范围从128.0.0.0到191.255.255.255。可用的B类网络有16382个，每个网络能容纳6万多个主机 。
3. C类IP地址：一个C类IP地址由3字节的网络地址和1字节的主机地址组成，网络地址的最高位必须是“110”。范围从192.0.0.0到223.255.255.255。C类网络可达209万余个，每个网络能容纳254个主机。
4. D类地址用于多点广播（Multicast）： D类IP地址第一个字节以“lll0”开始，它是一个专门保留的地址。它并不指向特定的网络，目前这一类地址被用在多点广播（Multicast）中。多点广播地址用来一次寻址一组计算机，它标识共享同一协议的一组计算机。
5. E类IP地址 以“llll0”开始，为将来使用保留。

全零（“0．0．0．0”）地址对应于当前主机。全“1”的IP地址（“255．255．255．255”）是当前子网的广播地址。

环回地址(127.0.0.1) 又称为本机地址。

环回接口（loopback）。平时我们用127.0.0.1来尝试自己的机器服务器好使不好使。走的就是这个loopback接口。对于环回接口，有如下三点值得注意:

• 传给环回地址（一般是127.0.0.1）的任何数据均作为IP输入。
• 传给广播地址或多播地址的数据报复制一份传给环回接口，然后送到以太网上。这是 因为广播传送和多播传送的定义包含主机本身。
• 任何传给该主机IP地址的数据均送到环回接口。

IP报文

IP协议是TCP/IP协议的核心，所有的TCP，UDP，IMCP，IGCP的数据都以IP数据格式传输，要注意的是，IP不是可靠的协议，这是说，IP协议没有提供一种数据未传达以后的处理机制－－这被认为是上层协议－－TCP或UDP要做的事情。所以这也就出现了TCP是一个可靠的协议，而UDP就没有那么可靠的区别。这是后话，暂且不提。

IP协议头

我感兴趣的只是那八位的TTL字段，还记得这个字段是做什么的么？这个字段规定该数据包在穿过多少个路由之后才会被抛弃(这里就体现出来IP协议包的不可靠性，它不保证数据被送达)，某个ip数据包每穿过一个路由器，该数据包的TTL数值就会减少1，当该数据包的TTL成为零，它就会被自动抛弃。这个字段的最大值也就是255，也就是说一个协议包也就在路由器里面穿行255次就会被抛弃了，根据系统的不同，这个数字也不一样，一般是32或者是64。

 

ARP协议

arp协议由来：计算机通信基本靠吼，即广播的方式，所有上层的包到最后都要封装上以太网头，然后通过以太网协议发送，在谈及以太网协议时候，我门了解到

通信是基于mac的广播方式实现，计算机在发包时，获取自身的mac是容易的，如何获取目标主机的mac，就需要通过arp协议

arp协议功能：广播的方式发送数据包，获取目标主机的mac地址。

协议工作方式：每台主机ip都是已知的。

传输层

传输层的由来：网络层的ip帮我们区分子网，以太网层的mac帮我们找到主机，然后大家使用的都是应用程序，你的电脑上可能同时开启qq，暴风影音，迅雷等多个应用程序，

那么我们通过ip和mac找到了一台特定的主机，如何标识这台主机上的应用程序呢？答案就是端口，端口即应用程序与网卡关联的编号。

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

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

传输层有两种协议，TCP和UDP,见下图

TCP协议

可靠传输，TCP数据包没有长度限制，理论上可以无限长，但是为了保证网络的效率，通常TCP数据包的长度不会超过IP数据包的长度，以确保单个TCP数据包不必再分割。

为什么tcp是可靠的数据传输呢？

最可靠的方式就是只要不得到确认，就重新发送数据报，直到得到对方的确认为止。

 特点：

• 面向连接：传输数据之前需要建立连接。
• 在连接过程中进行大量数据传输。
• 通过“三次握手”的方式完成连接，是安全可靠协议。
• 传输速度慢，效率低。

 

UDP协议

不可靠传输，”报头”部分一共只有8个字节，总长度不超过65,535字节，正好放进一个IP数据包。

特点：

• 面向无连接：传输数据之前源端和目的端不需要建立连接。
• 每个数据报的大小都限制在64K（8个字节）以内。
• 面向报文的不可靠协议。（即：发送出去的数据不一定会接收得到）
• 传输速率快，效率高。
• 现实生活实例：邮局寄件、实时在线聊天、视频会议…等。

总结

TCP协议虽然安全性很高，但是网络开销大，而UDP协议虽然没有提供安全机制，但是网络开销小，在现在这个网络安全已经相对较高的情况下，

为了保证传输的速率，我们一般还是会优先考虑UDP协议。

 

经过五层的数据报

 

数据传输就是一个封装包和拆包的过程。

 

SOCKET

我们已经知道，假设我现在要写一个程序，给另一台计算机发数据，必须通过tcp/ip协议 ，但具体的实现过程是什么呢？

我应该怎么操作才能把数据封装成tcp/ip的包，又执行什么指令才能把数据发到对端机器上呢? 

socket就是帮你把tcp/ip协议层的各种数据封装啦、数据发送、接收等通过代码已经给你封装好了，你只需要调用几行代码，就可以给别的机器发消息了。

 

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，

它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部。

 

socket起源于Unix，而Unix/Linux 基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式 来操作。

Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭)。

你想给另一台计算机发消息，你知道他的IP地址，他的机器上同时运行着qq、迅雷、word、浏览器等程序，你想给他的qq发消息，

那想一下，你现在只能通过ip找到他的机器，但如果让这台机器知道把消息发给qq程序呢？

答案就是通过port,一个机器上可以有0-65535个端口，你的程序想从网络上收发数据，就必须绑定一个端口，这样，远程发到这个端口上的数据，就全会转给这个程序啦。

 

SOCKET通信流程

 

 

# 流程描述：
# 
# 1 服务器根据地址类型（ipv4,ipv6）、socket类型、协议创建socket
# 
# 2 服务器为socket绑定ip地址和端口号
# 
# 3 服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开
# 
# 4 客户端创建socket
# 
# 5 客户端打开socket，根据服务器ip地址和端口号试图连接服务器socket
# 
# 6 服务器socket接收到客户端socket请求，被动打开，开始接收客户端请求，直到客户端返回连接信息。这时候socket进入阻塞状态，所谓阻塞即accept()方法一直等到客户端返回连接信息后才返回，开始接收下一个客户端连接请求
# 
# 7 客户端连接成功，向服务器发送连接状态信息
# 
# 8 服务器accept方法返回，连接成功
# 
# 9 客户端向socket写入信息(或服务端向socket写入信息)
# 
# 10 服务器读取信息(客户端读取信息)
# 
# 11 客户端关闭
# 
# 12 服务器端关闭

 

Socket套接字方法

socket实例

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


family(socket家族)

• socket.AF_UNIX：用于本机进程间通讯，为了保证程序安全，两个独立的程序(进程)间是不能互相访问彼此的内存的，但为了实现进程间的通讯，可以通过创建一个本地的socket来完成
• socket.AF_INET:(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

socket type类型

• socket.SOCK_STREAM  # for tcp
• socket.SOCK_DGRAM  # 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 #废弃了

proto=0 请忽略，特殊用途

fileno=None 请忽略，特殊用途

sk.bind(address)

　　#s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog)

　　#开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

      #backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
      #这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool)

　　#是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept()

　　#接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　#接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)

　　#连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　#同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　#关闭套接字

sk.recv(bufsize[,flag])

　　#接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])

　　#与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag])

　　#将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag])

　　#将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

      #内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)

　　#将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout)

　　#设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()

　　#返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname()

　　#返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()

　　#套接字的文件描述符
socket.getfqdn()  # 拿到本机的主机名
socket.gethostbyname()  # 通过域名解析ip地址

 

Socket代码实例

1.聊天软件

# server 端
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 可以重复利用端口 解决端口被占用的问题
address = (‘127.0.0.1‘, 8080)  
phone.bind(address)
phone.listen(5)
conn, addr = phone.accept()
while True:
    try:
        data = conn.recv(1024)
        print(type(data), data)
        conn.send(data.upper())
    except ConnectionResetError:  # 解决客户端单方面终止连接的bug
        break
conn.close()
phone.close()


# client端
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8089)
phone.connect(address)
while True:
    msg = input(">>>: ").strip()
    if not msg:
        continue  # 解决输入为空的bug  输入为空 操作系统就不会继续下面四层的操作 程序就会卡死
    phone.send(msg.encode(‘utf-8‘))
    data = phone.recv(1024)
    print(data)
phone.close()

 

2. 远程文件传输

简单版

# server 端
import socket
import os
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)  # 0 - 1024 是操作系统占用的端口
phone.bind(address)
phone.listen(5)

server_dir = r‘serverserver_base‘
while True:
    print(‘waiting...‘)
    conn, addr = phone.accept()
    while True:
        order = conn.recv(8096)  # 接收命令 get a.txt
        cmds = order.decode(‘utf-8‘).split(‘ ‘)
        order_type = cmds[0]
        filename = cmds[1]

        # 制作报头
        header_info = {
            ‘filename‘: filename,
            ‘file_size‘: os.path.getsize(r‘%s\\%s‘ % (server_dir, filename)),  # 保存位置路径拼接
            ‘time‘: ‘now‘
        }

        header_byte = json.dumps(header_info).encode(‘utf-8‘)
        len_header = struct.pack(‘i‘, len(header_byte))
        conn.send(len_header)  # 发送报头长度
        conn.send(header_byte)  # 发送报头

        # 发送真实数据
        with open(r‘%s\\%s‘ % (server_dir, filename), ‘rb‘) as f:
            for line in f:  # 每次读取一行 节省空间
                conn.send(line)

    conn.close()

phone.close()


# clien端
import socket
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)
phone.connect(address)
download_dir = ‘clientdownload‘
while True:

    order = input(‘>>>: ‘).strip()
    phone.send(order.encode(‘utf-8‘))

    # 拿到报头的长度
    header = phone.recv(4)
    header_len = struct.unpack(‘i‘, header)[0]

    # 通过报头的长度拿到报头
    header_info = phone.recv(header_len)
    header_ = json.loads(header_info.decode(‘utf-8‘))
    print(header_)

    # 拿到文件的总大小
    file_size = header_[‘file_size‘]
    filename = header_[‘filename‘]

    with open(r‘%s\\%s‘ % (download_dir, filename), ‘wb‘) as f:
        size = 0
        while size < file_size:
            data = phone.recv(1024)
            f.write(data)
            size += len(data)
            print(‘当前进度%s‘ % (size/file_size*100))
phone.close()

 

面向对象版

服务器端

server端
import socket
import struct
import os
import json


class My_socket:
    host = ‘127.0.0.1‘
    port = 9000
    family = socket.AF_INET
    cooperation = socket.SOCK_STREAM
    server_dir = r‘serverserver_base‘

    def __init__(self, is_activate=True):
        self.phone = socket.socket(self.family, self.cooperation)
        if is_activate:
            self.bind()
            self.listen()

    def listen(self):
        self.phone.listen(5)

    def bind(self):
        self.phone.bind((self.host, self.port))

    def run(self):
        print(‘wait.....‘)
        self.conn, self.addr = self.phone.accept()
        self.take_order()

    def take_order(self):
        order = self.conn.recv(1024)
        cmd_ = order.decode(‘utf-8‘)
        cmd_list = cmd_.split(‘ ‘)
        cmd = cmd_list[0]
        filename = cmd_list[1]
        if hasattr(self, cmd):
            func = getattr(self, cmd)
            func(filename)

    def get(self, filename):
        self.make_head(filename)
        self.file_read(filename)

    def file_read(self, filename):
        with open(r‘%s\\%s‘ % (self.server_dir, filename), ‘rb‘) as f:
            for line in f:
                self.conn.send(line)

    def make_head(self, filename):
        file_dict = {
            ‘filename‘: filename,
            ‘file_size‘: os.path.getsize(r‘%s\\%s‘ % (self.server_dir, filename)),
            ‘md5‘: ‘xxxxxxxxx‘
        }

        file_json = json.dumps(file_dict).encode(‘utf-8‘)
        file_len = len(file_json)
        header = struct.pack(‘i‘, file_len)
        self.conn.send(header)
        self.conn.send(file_json)
        self.file_read(filename)

    def put(self):
        pass

    def data_transport(self):
        pass

    def close(self):
        self.conn.close()
        self.phone.close()


my_socket = My_socket()
my_socket.run()

 

客户端

import socket
import struct
import json


class My_socket:
    family = socket.AF_INET
    cooperation = socket.SOCK_STREAM
    download_dir = r‘clientdownload‘

    def __init__(self, address):
        self.phone = socket.socket(self.family, self.cooperation)
        self.address = address
        self.connect()

    def connect(self):
        self.phone.connect(self.address)

    def read_head(self):
        header = self.phone.recv(4)
        header_len = struct.unpack(‘i‘, header)[0]
        header_info = self.phone.recv(header_len)
        header_dict = json.loads(header_info)
        file_size = header_dict[‘file_size‘]
        filename = header_dict[‘filename‘]
        self.recv_data(file_size, filename)

    def recv_data(self, file_size, filename):
        size = 0
        with open(r‘%s\\%s‘ % (self.download_dir, filename), ‘wb‘) as f:
            while size < file_size:
                data = self.phone.recv(1024)
                f.write(data)
                size += len(data)
                print(‘已传输百分之%s‘ % int((size / file_size*100)),end=‘
‘)

    def close(self):
        self.phone.close()

    def run(self):
        inp = input(">>>: ")
        self.phone.send(inp.encode(‘utf-8‘))
        self.read_head()


my_socket = My_socket((‘127.0.0.1‘, 9000))
my_socket.run()
my_socket.close()

 

TCP VS UDP

tcp基于链接通信

• 基于链接，则需要listen（backlog），指定连接池的大小
• 基于链接，必须先运行的服务端，然后客户端发起链接请求
• 对于mac系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端在收消息后加上if判断，空消息就break掉通信循环)
• 对于windows/linux系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端通信循环内加异常处理，捕捉到异常后就break掉通讯循环)

udp无链接

• 无链接，因而无需listen（backlog），更加没有什么连接池之说了
• 无链接，udp的sendinto不用管是否有一个正在运行的服务端，可以己端一个劲的发消息，只不过数据丢失
• recvfrom收的数据小于sendinto发送的数据时，在mac和linux系统上数据直接丢失，在windows系统上发送的比接收的大直接报错
• 只有sendinto发送数据没有recvfrom收数据，数据丢失

 

粘包现象及解决方案

我们来写一个远程执行命令的程序，写一个socket client端在windows端发送指令，一个socket server在Linux端执行命令并返回结果给客户端。

执行命令的话，肯定是用subprocess模块，但注意：

res = subprocess.Popen(cmd.decode(‘utf-8‘),shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE)

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

Linux是utf-8编码的，接收端以utf-8解码。

 

远程执行命令

# server端
import socket
import subprocess
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 可以重复利用端口 解决端口被占用的问题
address = (‘127.0.0.1‘, 8080)  # 0 - 1024 是操作系统占用的端口
phone.bind(address)
phone.listen(5)
while True:  # 实现了对多个客户端的服务 但每次只能服务一个客户端
    print("waiting...")
    conn, addr = phone.accept()
    print(‘客户端： ‘, addr)
    while True:
        try:
            # 接受命令
            cmd = conn.recv(1024)  # 1024是一个坑
            # 执行命令 拿到结果
            obj = subprocess.Popen(cmd.decode(‘utf-8‘), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            # shell 解析字符串成为命令 相当于开启了一个终端  同时要注意操作系统编码的问题
            # PIPE是建立一个管道 stdout是正确命令的执行结果 stderr是错误命令的结果
            # PIPE的执行内部其实是执行了一个方法 加了一个property
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 发送结果
            conn.send(stdout+stderr)  # 会新开辟一片内存空间浪费资源
        except ConnectionResetError:  # 解决客户端单方面终止连接的bug
            break
    conn.close()

phone.close()

 

# dir  查看某一个文件夹下的子文件名和子文件夹名
# ipconfig 查看本地网卡的ip信息
# tasklist: 查看本地运行的进程

# client端
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8080)
phone.connect(address)
while True:
    cmd = input(">>>: ").strip()
    if not cmd:
        continue  # 解决输入为空的bug
    phone.send(cmd.encode(‘utf-8‘))
    data = phone.recv(1024)
    print(data.decode(‘gbk‘))  # windows下默认编码gbk ;linux 下默认编码utf-8
phone.close()

尝试执行dir命令,你惊喜的发现，拿到了正确的结果！

但如果执行ipconfig你会发现结果并不完整，之后再执行一次dir,会发现输出有ipconfig的部分结果，之后才是dir的结果，这是什么原因呢？

是因为，top命令的结果比较长，但客户端只recv(1024), 可结果比1024长呀，那怎么办，只好在服务器端的IO缓冲区里把客户端还没收走的暂时存下来，等客户端下次再来收，所以当客户端第2次调用recv(1024)就会首先把上次没收完的数据先收下来，再收dir命令的结果。

那怎么解决呢？有的人说直接把recv(1024)改大不就好了，改成500010000或whatever. 可我这样干并不能解决实际问题，因为你不可能提前知道对方返回的结果数据大下，无论你改成多大，对方的结果都有可能比你设置的大，另外这个recv并不是真的可以随便改特别大的，有关部门建议的不要超过8192，再大反而会出现影响收发速度和不稳定的情况。

这个现象叫做粘包，就是指两次结果粘到一起了。它的发生主要是因为socket缓冲区导致的，来看一下。

你的程序实际上无权直接操作网卡的，你操作网卡都是通过操作系统给用户程序暴露出来的接口，那每次你的程序要给远程发数据时，其实是先把数据从用户态copy到内核态，

这样的操作是耗资源和时间的，频繁的在内核态和用户态之前交换数据势必会导致发送效率降低， 因此socket 为提高传输效率，发送方往往要收集到足够多的数据后才发送一次数据给对方。

若连续几次需要send的数据都很少，通常TCP socket 会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

 

粘包问题只存在于TCP中

还是看上图，发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，

也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。

而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。

怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

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

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

 

总结

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

 

基于UDP的命令执行程序

服务器端

# server端
import socket
import subprocess

ip_port = (‘127.0.0.1‘, 9003)
bufsize = 1024

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

while True:
    # 收消息
    cmd, addr = udp_server.recvfrom(bufsize)
#Windows下 当接收数据报的缓冲区比数据报小时会报错
# OSError: [WinError 10040] 一个在数据报套接字上发送的消息大于内部消息缓冲区或其他一些网络限制，或该用户用于接收数据报的缓冲区比数据报小。
# linux 当接收的缓冲区小于数据报时 多出的数据会丢失
    print(‘用户命令----->‘, cmd,addr)

    res = subprocess.Popen(cmd.decode(‘utf-8‘), shell=True, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                           stdout=subprocess.PIPE)
    stderr = res.stderr.read()
    stdout = res.stdout.read()

    # 发消息
    udp_server.sendto(stdout + stderr, addr)

udp_server.close()

 

客户端

from socket import *

import time

ip_port = (‘127.0.0.1‘, 9003)
bufsize = 1024

udp_client = socket(AF_INET, SOCK_DGRAM)

while True:
    msg = input(‘>>: ‘).strip()
    if len(msg) == 0:
        continue

    udp_client.sendto(msg.encode(‘utf-8‘), ip_port)
    data, addr = udp_client.recvfrom(bufsize)
 # udp 可以发空信息 因为udp每发一次就是发一份完整的数据报 都会有自己的ip端口信息
 #  udp协议一次发 对应一次收
    print(data.decode(‘utf-8‘), end=‘‘)

UDP协议一发对应一收，每发一次都是一份完整的数据报，不会出现粘包现象。

 

解决粘包现象

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

然后接收端来一个死循环接收完所有数据。

我们先来做一下试验。

1.
server
phone.send(‘hello‘.encode(‘utf-8‘))
phone.send(‘world‘.encode(‘utf-8‘))  # 这时候就发生了粘包现象  两个数据比较小 并且发送的间隔短(小于一次IO的时间）

client
data = conn.recv(1024)
print(data.decode(‘utf-8‘))  # helloworld  这时候就发生了粘包现象  两个数据比较小 并且发送的间隔短(小于一次IO的时间）


2.
server
phone.send(‘hello‘.encode(‘utf-8‘))
phone.send(‘world‘.encode(‘utf-8‘))  # 这时候就发生了粘包现象  两个数据比较小 并且发送的间隔短(小于一次IO的时间）

client
res1 = conn.recv(1)  # 只接收一个数据 剩下的数据都在操作系统内存当中
print(‘第一个数据: ‘, res1)  # b‘h‘

# res2 = conn.recv(9)
# print("第二个数据: ", res2)  # b‘elloworld‘  第二次发送的数据在第一次未接收数据的后面

3.
server
phone.send(‘hello‘.encode(‘utf-8‘))
time.sleep(5)
phone.send(‘world‘.encode(‘utf-8‘))  # 这时候不会发生粘包

client
res_1 = conn.recv(1024)
res_2 = conn.recv(1024)
print("第一个数据: ", res_1)  # 第一个数据:  b‘hello‘
print("第二个数据: ", res_2)  # 第二个数据:  b‘world‘

4.
server
phone.send(‘hello‘.encode(‘utf-8‘))
time.sleep(5)
phone.send(‘world‘.encode(‘utf-8‘))  # 这时候不会发生粘包


client
res_1 = conn.recv(1)  # 第一个数据:  b‘h‘
print("第一个数据: ", res_1)
res_2 = conn.recv(1024)  # 第二个数据:  b‘ello‘   这样数据并没有接收完
# 在第一次recv之后 就会到第二次recv 如果有就接收 如果没有就等待  会导致数据接收不完整
print("第二个数据: ", res_2)


5. 
server
phone.send(‘hello‘.encode(‘utf-8‘))
time.sleep(5)
phone.send(‘world‘.encode(‘utf-8‘))

client
res_1 = conn.recv(1)  # 第一个数据:  b‘h‘
print("第一个数据: ", res_1)
time.sleep(6)  # 第二个数据:  b‘elloworld‘  想要数据接收完整 等待的时间大于client端即可
res_2 = conn.recv(1024)
print("第二个数据: ", res_2)

 

解决粘包问题简单版

服务器端

server端
import socket
import subprocess
import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)  # 0 - 1024 是操作系统占用的端口
phone.bind(address)
phone.listen(5)
conn, addr = phone.accept()
while True:
    order = conn.recv(8096)
    obj = subprocess.Popen(order.decode(‘utf-8‘), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout = obj.stdout.read()
    stderr = obj.stderr.read()
    # 数据的大小 即数据的描述信息 就是报头 报头一定是固定长度的

    # 第一步 制作固定长度的报头
    total_size = len(stdout) + len(stderr)
    header = struct.pack(‘i‘, total_size)

    # 第二步 把数据的报头发给客户端
    conn.send(header)

    # 第三步 发送真实的数据
    # data = stdout+stderr
    conn.send(stdout)
    conn.send(stderr)  # 利用粘包现象完成数据的拼接
conn.close()

phone.close()

客户端

import socket
import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)
phone.connect(address)
while True:
    # 1.发命令
    order = input(‘>>>: ‘).strip()
    phone.send(order.encode(‘utf-8‘))

    # 2.拿到命令结果并打印
    # 第一步：收报头
    header = phone.recv(4)

    # 第二步 从报头信息中解析出数据的信息
    head_data = struct.unpack(‘i‘, header)  # 是一个元组
    total_size = head_data[0]

    current_data = b‘‘
    size = 0
    while size < total_size:
        data = phone.recv(1024)
        current_data += data
        size += len(data)
    print(current_data.decode(‘gbk‘))
phone.close()

 

解决粘包问题终极版

服务器端

import socket
import subprocess
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)  # 0 - 1024 是操作系统占用的端口
phone.bind(address)
phone.listen(5)
conn, addr = phone.accept()
while True:
    order = conn.recv(8096)
    obj = subprocess.Popen(order.decode(‘utf-8‘), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout = obj.stdout.read()
    stderr = obj.stderr.read()
    # 数据的大小 即数据的描述信息 就是报头 报头一定是固定长度的

    total_size = len(stdout) + len(stderr)
    # 报头的信息可能不只有大小 还有很多信息比如文件名 md5值
    # 并且struct能制作报头的文件大小也有限 因此应该想别的办法
    # 将文件的描述信息放到字典中 文件大小也放到字典中
    header_info = {
        ‘filename‘: ‘a.txt‘,
        ‘total_size‘: total_size,
        ‘time‘: ‘now‘
    }

    # 序列化成字符串 再转换成bytes类型 得到的长度就会小很多
    # 到时再转为字典就可以拿到文件的总大小 这样就解决了这个问题
    header_byte = json.dumps(header_info).encode(‘utf-8‘)
    len_header = struct.pack(‘i‘, len(header_byte))
    conn.send(len_header)  # 发送报头长度

    conn.send(header_byte)  # 发送报头
    # 第三步 发送真实的数据
    conn.send(stdout)
    conn.send(stderr)  # 利用粘包现象完成数据的拼接
conn.close()

phone.close()

客户端

import socket
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)
phone.connect(address)
while True:

    order = input(‘>>>: ‘).strip()
    phone.send(order.encode(‘utf-8‘))

    # 拿到报头的长度
    header = phone.recv(4)
    header_len = struct.unpack(‘i‘, header)[0]

    # 通过报头的长度拿到报头
    header_info = phone.recv(header_len)
    header_ = json.loads(header_info.decode(‘utf-8‘))
    print(header_)

    # 拿到文件的总大小
    total_size = header_[‘total_size‘]

    current_data = b‘‘
    size = 0
    while size < total_size:
        data = phone.recv(1024)
        current_data += data
        size += len(data)
    print(current_data.decode(‘gbk‘))
phone.close()

 

send 与 recv

不管是send还是recv都不是直接发送接收数据，而是操作自己操作系统的内存。

send的作用就是把数据拷贝到操作系统之后就结束了，发不发，怎么发是操作系统的事，

但是效率比较高，只需要本地拷贝数据。

recv经历两个过程，等待数据，然后把数据从操作系统拷贝到应用程序中，耗时非常长。

并不是一个send对应一个recv，因为send把数据发送到操作系统，怎么发，分成几次发，是操作系统的事情。

 

注：此篇博客大部分参考自路飞学城以及yuan先生博客园。