Unix/Linux编程：网络接口层

阳光穿透心脏的1/2处 2022-10-06 15:51 215阅读 0赞

网络接口层实际上并不是因特网协议组中的一部分，但是它是数据包从一个设备的网络层传输到另外一个设备的网络层的方法。这个过程能够在网卡的软件驱动程序中控制，也可以在韧体或者专用芯片中控制。这将完成如添加报头准备发送、通过物理媒介实际发送这样一些数据链路功能。另一端，链路层将完成数据帧接收、去除报头并且将接收到的包传到网络层。

网络接口层通过如下数据结构来完成与硬件的交互作用

/* netif.h - NIGET */
    
    #define	NI_MAXHWA 14			/* 任何硬件的最大尺寸	*/
                             /*（物理）网络地址*/
    struct	hwa	{
        			 /* 硬件地址 */
        int		ha_len;		/* 这个地址的长度 */
        unsigned char	ha_addr[NI_MAXHWA]; 	/* 地址 */
    };
    
    #define	NI_INQSZ	30		 /* 接口输入队列大小 */
    #define	NETNLEN		30		 /* 网络名称长度 */
    
    #define	NI_LOCAL	0		 /* 本地接口索引 */
    #define	NI_PRIMARY	1		/* 主接口索引 */
    
    #define	NI_MADD		0		/* 添加多播 (ni_mcast) */
    #define	NI_MDEL		1		/* 删除多播 (ni_mcast) */
    
    /* 接口状态  */
    
    #define	NIS_UP		0x1
    #define	NIS_DOWN	0x2
    #define	NIS_TESTING	0x3
    
    /* 网络接口结构定义（每个接口一个） 	*/
    
    struct	netif {
        				/* 关于一个网络接口的信息 	*/
        char		ni_name[NETNLEN]; /* 接口域名 	*/
        char		ni_state;	/* 接口状态: NIS_ above	*/
        IPaddr		ni_ip;		/* 此接口的 IP 地址 */
        IPaddr		ni_net;		/* 网络IP地址 		*/
        IPaddr		ni_subnet;	/* 子网IP地址 	*/
        IPaddr		ni_mask;	/* 接口的 IP 子网掩码 	*/
        IPaddr		ni_brc;		/* IP广播地址 		*/
        IPaddr		ni_nbrc;	/* IP网络广播地址 	*/
        unsigned int	ni_mtu;		/* 最大传输单位（字节） 	*/
        unsigned int	ni_hwtype;	/* 硬件类型（用于 ARP） 	*/
        struct	hwa	ni_hwa;		/* 接口硬件地址 */
        struct	hwa	ni_hwb;		/* 硬件广播地址 */
        /* multicast add/delete func.	*/
        int		(*ni_mcast)(int op,int dev,Eaddr hwa,IPaddr ipa);
        Bool		ni_ivalid;	/* ni_ip 是否有效 ?		*/
        Bool		ni_nvalid;	/*  ni_name  是否有效 ?	*/
        Bool		ni_svalid;	/*  ni_subnet  是否有效 ?	*/
        int		ni_dev;		/*  Xinu 设备描述符 	*/
        int		ni_ipinq;	/* IP输入队列 	*/
        int		ni_outq;	/* （设备）输出队列 	*/
        /* MIB接口 */
        char		*ni_descr;	/* 硬件文字说明  */
        int		    ni_mtype;	  /* MIB接口类型 */
        long		ni_speed;	    /* 每秒位数 		*/
        char		ni_admstate;	/* administrative status (NIS_*)*/
        long		ni_lastchange;	/* 上次状态更改  (1/100 sec)*/
        long		ni_ioctets;	    /* # 收到的octets 		*/
        long		ni_iucast;	    /* # 对传入的单播数据分组数目的记录 	*/
        long		ni_inucast;	    /* # 对传入的组播数据分组数目的记录 		*/
        long		ni_idiscard;	/* # 丢弃 - 输出队列已满(记录差错时必须丢弃的输入数据分组数目) */
        long		ni_ierrors;	    /* # 输入包错误 	*/
        long		ni_iunkproto;	/* # in packets for unk. protos */
        long		ni_ooctets;	    /* # 发送的octets        */
        long		ni_oucast;   	/* # 发送的单播		    */
        long		ni_onucast;	    /* # 发送的非单播          */
        long		ni_odiscard;	/* # 丢弃的输出数据包 	(记录差错时必须丢弃的输出数据分组数目)    */
        long		ni_oerrors;  	/* # 输出数据包错误 	    */
        long		ni_oqlen;	    /* 输出队列长度 	        */
        long		ni_maxreasm;	/* 可以重组的 最大数据报	*/
    };
    
    #define	NIGET(ifn)	((struct ep *)deq(nif[ifn].ni_ipinq))
    
    #define	NIF	Neth+Noth+1		/* # 接口数量，本地+1 */
    
    extern struct netif	nif[];
    
    int netwrite(struct netif *, struct ep *, unsigned);

网络接口由一个数组(nif)构成，其中每个数组远程对应于该接口上的一个硬件接口。接口数组中的各个元素通过数组索引被整个系统使用。这样，我们就能够体积“0号网络接口”或者“第一个网络接口”了

数据结构netif定义了数组nif中每个元素的组成。netif的字段不但定义了协议软件需要的所有数据项，而且定义了用于收集统计数据的变量。比如：

*  ni\_ip的内容是分配给接口的IP地址
 *  ni\_mtu的内容是最大传输单元，即网络中一个分组的最大长度，以八位组为单位
 *  以valid结尾的字段中包含的是bool变量，这些bool变量指出与其名字的前半部分相对应的字段是否有效：一旦有效，初始化软件就将它们设置为TRUE。比如，当ni\_ip中包含了有效的IP地址时，ni\_ivalid的值就为TRUE
 *  该设备驱动将已经到达的，并且将由IP进程来处理的数据报放入一个队列中。字段ni\_ipinq中包含了一个指向该队列的指针。程序利用宏NOGET从队列中依次取出这些数据报。宏NIGET以网络接口号为参数，从接口队列中取出下一个数据报，并返回指向该数据报的指针
 *  ni\_hwa和ni\_hwb记录硬件的物理地址和物理广播地址。物理地址的长度取决于底层硬件，因此协议软件利用数据结构hwa来代表这种地址。每个硬件的地址都起始于一个整数形式的长度字段，这样高层的协议软件就不必知道硬件的细节问题就可以处理硬件的地址

> 接口的逻辑状态

在故障分析中，管理人员经常需要让某个机器上的一个或者多个接口停止工作。

*  ni\_state字段提供了控制接口逻辑状态的机制，该机制与底层硬件无关。
 *  比如，网络管理员可以将ni\_state赋值为NIS\_DOWN，以完全终止输入输出。此后，可以将ni\_state赋值为NIS\_UP来重启输出输出

将接口的逻辑状态和硬件的物理状态分开是很重要的，因为这样就给了管理员控制接口操作的自由。显然，当硬件出现故障时/网络挂载时，管理员就声明此接口已经停止工作(down)。但是声明某个接口停止工作，并不是指物理硬件被拆除，也不表示硬件不能正常工作。实际上，管理员的这项声明仅仅导致软件停止接收传入分组，并阻止外发分组的发送。

# 以太网的基本定义 #

一般我们一般不需要关注底层设备驱动程序的细节问题，但是还是要知道一些基本的定义。比如，在netif.h的声明中就引用了C数据结构eq，ep定义了以太网数据报存储进入的缓冲区格式，其声明在文件ether.h中：

/* ether.h */
    
    /* 以太网定义和常量 */
    
    #define	EP_MAXMULTI	  10	/* 组播地址表大小 	*/
    
    #define	EP_MINLEN	  60	/* 最小包长度 	*/
    #define	EP_DLEN		1500	/* ep数据字段长度  	*/
    #define	EP_HLEN		  24	/*（扩展的）以太头的大小 */
    #define	EP_CRC		   4	/* 以太CRC (trailer)			*/
    #define	EP_MAXLEN	EP_HLEN+EP_DLEN
    #define	EP_ALEN	6		/*物理地址中的八位字节(octets )数 	*/
    typedef	unsigned char	Eaddr[EP_ALEN]; /* 物理以太网地址 	*/
    #define	EP_RETRY	3	/* 重试 xmit 错误的次数 	*/
    #define	EP_BRC	"\377\377\377\377\377\377" /*以太网广播地址 	*/
    #define EP_RTO 300		/* 读取超时（以秒为单位） 	*/
    
    #define EP_NUMRCV 16		/* 数量 LANCE 接收缓冲区（2 次方） 	*/
    #define EP_NUMRCVL2 4		/* 缓冲区数量的 log2 */
    
    #define	EPT_LOOP	0x0060		/* type: Loopback		*/
    #define	EPT_ECHO	0x0200		/* type: Echo			*/
    #define	EPT_PUP		0x0400		/* type: Xerox PUP		*/
    #define	EPT_IP		0x0800		/* type: Internet Protocol	*/
    #define	EPT_ARP		0x0806		/* type: ARP			*/
    #define	EPT_RARP	0x8035		/* type: Reverse ARP		*/
    
    struct	eh {
        			/* 以太网头 		*/
    	Eaddr	eh_dst;		/* 目标主机地址 */
    	Eaddr	eh_src;		/* 源主机地址 		*/
    	unsigned short	eh_type;/* 以太网数据包类型（见下文） */
    };
    
    struct	ep	{
        		    /* 以太网包的完整结构 */
    	u_long	ep_nexthop;	/* niput() uses this			*/
    	short	ep_ifn;		/* 始发接口号 	*/
    	short	ep_len;		/* 包的长度 		*/
    	short	ep_order;	/* 字节顺序掩码（用于调试） 	*/
    	struct	eh ep_eh;	/* 以太网头 			*/
    	char	ep_data[EP_DLEN];	/* 数据包中的数据 	*/
    };
    
    /*数据包字节顺序常量（设置表示主机顺序）  */
    
    #define	EPO_NET		1	/* network layer		*/
    #define	EPO_IP		2	/* level 1 protocols...		*/
    #define	EPO_ARP		2
    #define	EPO_RARP	2
    #define	EPO_ICMP	4	/* level 2 protocols		*/
    #define	EPO_IGMP	4
    #define	EPO_TCP		4
    #define	EPO_UDP		4
    #define	EPO_OSPF	4
    #define	EPO_DNS		5	/* application protocols	*/
    
    /* these allow us to pretend it's all one big happy structure */
    
    #define	ep_dst	ep_eh.eh_dst
    #define	ep_src	ep_eh.eh_src
    #define	ep_type	ep_eh.eh_type
    
    #if	Noth > 0
    /* this is for Othernet simulation */
    
    struct	otblk {
        
    	Bool	ot_valid;	/* these entries are valid?		*/
    	Eaddr	ot_paddr;	/* the Othernet physical address	*/
    	Eaddr	ot_baddr;	/* the Othernet broadcast address	*/
    	int	ot_rpid;	/* id of process reading from othernet	*/
    	int	ot_rsem;	/* mutex for reading from the othernet	*/
    	int	ot_pdev;	/* Physical device devtab index		*/
    	int	ot_intf;	/* the associate interface		*/
    	char	*ot_descr;	/* text description of the device	*/
    };
    #endif	Noth
    
    
    #define	ETOUTQSZ	30
    
    /* Ethernet control block descriptions */
    
    struct	etblk	{
        
    	int	etxpending;	/* number of packets pending output	*/
    	int	etrpending;	/* 1 => a receive is pending already	*/
    	int	etwtry;		/* num. of times to retry xmit errors	*/
    	char	*etwbuf;	/* pointer to current transmit buffer	*/
    	short	etnextbuf;	/* for checking buffers round robin	*/
    #if	Noth > 0
    	struct	otblk	*etoth[Noth];	/* eaddr to oaddr translations	*/
    #endif	Noth
    };
    
    
    /* ethernet function codes */
    
    #define	EPC_PROMON	1		/* turn on promiscuous mode	*/
    #define	EPC_PROMOFF	2		/* turn off promiscuous mode	*/
    #define	EPC_MADD	3		/* add multicast address	*/
    #define	EPC_MDEL	4		/* delete multicast address	*/
    
    struct utdev {
        
    	unsigned int	 ud_iomem;
    	unsigned int	 ud_iosize;
    	struct devsw	*ud_pdev;
    	Eaddr		 ud_paddr;
    	Eaddr		 ud_bcast;
    	char		*ud_descr;
    	int		 ud_outq;
    	int		 ud_ifnum;
    	int		 ud_nextbuf;
    	int		 ud_xpending;
    	int		 ud_xmaddr;	/* transmit base buf #		*/
    	int		 ud_wretry;
    	int		 ud_rmin;	/* receive ring buffer base addr*/
    	int		 ud_rmax;	/* receive ring buffer max addr	*/
    };
    
    struct etdev {
        
    	unsigned int	 ed_iomem;
    	unsigned int	 ed_iosize;
    	struct devsw	*ed_pdev;
    	Eaddr		 ed_paddr;
    	Eaddr		 ed_bcast;
    	char		*ed_descr;
    	int		 ed_outq;
    	int		 ed_ifnum;
    	int		 ed_wretry;
    	struct scb	*ed_scb;
    	struct cbl	*ed_cbl;
    	struct rfd	*ed_rfd;	/* first in RFD ring		*/
    	struct rfd	*ed_rfdend;	/* last in RFDring		*/
    	struct rbd	*ed_rbd;	/* first in RBD ring		*/
    	struct rbd	*ed_rbdend;	/* last in RBD ring		*/
    	struct tbd	*ed_tbd;	/* transmit buffer descriptor	*/
    	unsigned char	*ed_xmbuf;	/* transmit buffer base		*/
    	unsigned char	 ed_irq;	/* SIRQ reg value		*/
    	int		 ed_mcc;	/* # valid mca's		*/
    	Eaddr		 ed_mca[EP_MAXMULTI]; /* multicast addr. table	*/
    /* XXX */
    	int		ed_xpending;
    };
    
    extern struct utdev	ue[];
    extern struct etdev	ee[];
    
    extern	struct	etblk	eth[];

# 本地主机接口 #

IP协议除了要在各个网络接口之间给数据报选择路由外，还必须给那些往返于本地IP协议和上层协议软件之间的数据报进行选路。IP与本机之间的交互作用可由以下两种方法实现：

*  在IP程序段中对此种情况进行明确判别
 *  附加一个本机网络接口（伪网络接口）

关于“伪网络接口”技术：伪网络接口既没有与之相关的设备驱动软件，也没有具体的硬件设备，如下图所示。事实上，发往伪网络接口的数据将被转交给本机的协议软件。同样，当协议软件生成一个需要发送出去的数据报时，它通过伪网络接口将此数据报传递给IP

为本机设计伪网络接口有以下几个优点。

*  首先，它消除了特殊情况的存在，简化了IP程序。
 *  其次，它使得本机在路由表中的表示方法与其他目的站的表示方法完全一致。
 *  第三，使得网络管理员能够像查询其他接口一样方便的查询本地即可（比如，获取本地应用程序生成的分组的数目）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

# 缓冲区管理 #

**传入的分组必须被保存在内存中，并将其传递给适当的协议软件做进一步处理。同时，应用程序产生的输出数据也必须以分组的形式存储在内存中，并将其传递给网络硬件设备传送出去**。因此，网络接口层接收内存中准备外发的数据，并把将要传递给上层协议软件的传入数据放入内存中。**协议软件的有效性最终取决于如何管理保存这些分组数据的存储器**。一个良好的设计要做到快速分配存储器空间，并且避免分组在各层协议软件之间移动时的数据复制

理论上，系统可以将内存划分为大小固定的缓冲区，并使每个缓冲区都大的足以保存一个分组，以达到有效的分配内存空间的目的。然而在实际中，由于以下几个原因使得选择缓冲区的最佳大小变得复杂。

*  第一，一台计算机可能与几个网络相连，而每个网络都有各自不同的最大分组长度限制
 *  再者，它应该在不改变系统缓冲区大小的情况下，能够与其他新类型的网络建立连接
 *  其次，IP协议软件可能要保护比底层网络分组更大的数据报(比如，装配一个很长的数据报)
 *  最后，应用程序可能会发送或接收任意长度的信息

## 大缓冲区方案 ##

看起来，最理想的方法是将缓冲区划分的足够大，以能够存储最长的有效信息或分组。但是，由于IP数据报可能有64K octets 长，如果使得缓冲区大的足以容纳任何长度的数据报，有效内存空间根本划分不了几个缓冲区就会被耗尽。再者，短小的分组才是常规的，而长数据报并不多见。也就是说，使用大缓冲区将会导致内存空间的实际利用率很低，与此同时系统却没有足够多的缓冲区来满足通信量的需求

事实上，采用大缓冲区的设计者们通常会选择一个系统能够处理的数据报的最大长度限制D，然后使缓冲区足够大，可以容纳长度为D的数据报外加物理网络帧头。采用这种方法是在允许使用较长的数据报和能够给正常的通信量提供足够多的缓冲之间的折中。因此，D的大小不但取决于缓冲区大小的期望值，还取决于正常的系统利用率。典型的是分时系统给D选择了4K字节到8K字节之间的一个值

## 链表方案(mbuf) ##

除了大缓冲方案外，主要还可以采用将较小的缓冲区以链表的形式连接起来，以处理任意长度的数据报。在链表设计方案中，表中的缓冲区既可以是大小固定的，也可以是不固定的。大多数系统分配大小固定的缓冲区，因为这样做可以杜绝内存碎片，并保证内存的高利用率。通常，每个缓冲区都很小(比如在128字节到1K字节之间)，一个完整的数据报需要很多连接在一起的缓冲区来保持。比如BSD Unix使用称为mbuf结构的链接，其中每个mbuf为128字节长。各个mbuf本身不必写满，它具有一个短小的首部，指出数据从何处开始，以及一个有多少字节。

允许链表中的每个缓冲区只包含部分数据还具有一些其他优点：它允许快速封装而无须复制操作。当某一层的软件接收到上一层协议发送来的信息后，就分配到一个新的缓冲区，填写其中的首部信息，并将新缓冲区插入保存此信息的链接列表中。这样，附加的字节就可以很容易的插在某个信息的前面，而无限移动已存在的数据

## 方案举例 ##

在Xinu操作系统中，采用能有效存储任意长度数据报的大缓冲区方案和小缓冲区的链表防止之间的折中方案：它即划分了很多大小能够容纳单个分组的缓冲区，同时又划分了少量用于保存大数据报的缓冲区。系统使用小缓冲区完成分组一级的输入输出，而仅当生成或装配大数据报时才利用大缓冲区。选择这样的设计思想，是因为我们预计大多数数据报都比约定的网络最大传输单元MTU短，但同时也希望能够装配大数据报。这样，在大多数情况下，当一个分组被读入缓冲区后，就可以直接将整个缓冲区传递给IP，系统仅在装配一个大数据报才需要复制数据

为了使缓冲区的处理过程同一，Xinu系统采用了由操作系统提供的缓冲区自识别策略。为了分配一个缓冲区，系统调用getbuf函数，并且指定所要求的是大缓冲区还是小缓冲区。但是，只要缓冲区分配完成，需要保存的仅仅是指向这个缓冲区的指针。为了将缓冲区归还空闲缓冲区列表，系统调用freebuf，将被释放的缓冲区的指针交还，freebuf自动计算缓冲区的大小。缓冲区自识别策略的优点是，协议软件可以不用记住它是来自大缓冲区池，还是小缓冲区池，只需要传递指向该缓冲区的指针。因为，外发分组就能保存在一张简单的列表中，由地址来识别它们。一旦设备将一个分组发送出去，驱动程序软件就可以调用freebuf来释放此缓冲区，同样无须知道它的类型

## 有关缓冲区的其他议题 ##

直接存储器存取的存储器： 硬件上的某些要求经常会使缓冲区管理复杂化。比如，有些设备的输入输出只能在内存的DMA众进行，此时，操作系统可能会选择分配两套缓冲区：协议软件使用的缓冲区和设备传输使用的缓冲区。这种系统必须在发送数据前将常规缓冲区中的数据复制到DMA中，而将传入的数据从DMA中复制到常规缓冲区

整写散读：

*  有些设备能够在不连续的内存块中发送和接收分组。对输出来说，这种设备接收一张缓冲区地址和长度列表。它们从列表的缓冲区中，收集整理分组的所有部分，并将得到的字节流顺序发送出去，系统不必在连续的内存中重新组装分组。这种技术叫做“整写”
 *  对于支持散读的设备：硬件将根据一张由设备驱动程序填写的缓冲区地址列表，将一个分组置于不连续的内存块中。
 *  整写散读将使得链式缓冲区的分配变得容易有效，因为硬件可以直接从一张链表的缓冲区中获得一个分组的所有块，而不需要处理程序在内存中装配完整的分组。这两种技术也可以用于大小固定的缓冲区，因为它们允许驱动程序在不进行复制的情况下封装数据报。要做到这一点，驱动程序只要将帧首部存储在内存中的某个地址，然后把首部地址连同即将称为物理分组中的数据部分的数据报地址一起传递给硬件
 *  页面分配：在一个支持虚拟分页内存的计算机系统中，协议软件可以试图在页面的分界线上换分缓冲区，以使进程之间传递缓冲区的过程能够通过交换分页表格中的表项来完成，这样就不需要数据复制。这种技术对分页尺寸小的计算机来说很有用，但是对分页尺寸大的就不理想了。进一步说，当数据在操作系统和应用程序之间移动时，交换页面表格的表项将大大提高效率。但是，传入的分组中含有一系列的首部，这些首部使得在分组被解读之前，要确定用户数据的偏移量是几乎不可能的。因此，几乎没有实例程序试图将分组与页面的分界线对齐

## 传入分组的多路分解 ##

当一个分组到达时，网络接口层中的设备驱动程序软件检查分组中的类型字段，以确定使用哪种协议软件来处理此分组。

在编写接口软件时，设计者们通常采用以下两种基本手段中的一种：

*  或者将多路分解程序编成代码放在一个过程中，
 *  或者利用一张表格，将分组类型与适当的过程一一对应。

一般来说，使用代码的方式更加有效，但这意味着当又有新的协议加入时，软件必须重新编译，因此在试用阶段，用表格方式更加方便

如下，我们选择了利用一个过程对分组进行多路分解。过程ni\_in中包含了多路分解操作的代码

/* ni_in.c - ni_in */
    
    #include <conf.h>
    #include <kernel.h>
    #include <network.h>
    
    #include <ospf.h>
    
    int arp_in(struct netif *, struct ep *);
    int rarp_in(struct netif *, struct ep *);
    int ip_in(struct netif *, struct ep *);
    
    /*------------------------------------------------------------------------
     *  ni_in - network interface input function
     *------------------------------------------------------------------------
     */
    int ni_in(struct netif *pni, struct ep *pep, unsigned len)
    {
        
    	int	rv;
    
    	pep->ep_ifn = pni - &nif[0];	/* record originating intf # */
    
    	pni->ni_ioctets += len;
    	if (!memcmp(pni->ni_hwa.ha_addr, pep->ep_dst, EP_ALEN))
    		pni->ni_iucast++;
    	else
    		pni->ni_inucast++;
    	switch (pep->ep_type) {
        
    	case EPT_ARP:	rv = arp_in(pni, pep);	break;
    	case EPT_RARP:	rv = rarp_in(pni, pep);	break;
    	case EPT_IP:	rv = ip_in(pni, pep);	break;
    	default:
    		pni->ni_iunkproto++;
    		freebuf(pep);
    		rv = OK;
    	}
    	return rv;
    }

如上，一旦某个表示新的输入分组到达的中断发生时，设备驱动程序调用ni\_in。ni\_in对四种情况分别做出处理：

*  如果分组携带一个ARP信息，RARP信息或者IP数据报时，np\_in将此分组传递给适当的协议程序并返回结果
 *  否则，它将响应的缓冲区释放回缓冲池，丢弃此分组。如果分组被接收，ni\_in使相应的计数器值递增，以记录下这一广播分组或者非广播分组的到达

# 总结 #

网络接口层中的软件完成网络硬件设备与其他协议软件之间的通信。它包括缓冲区管理程序、下层设备驱动程序，并含有很多与硬件相关的细节。最为重要的是，它提供了一个称为网络接口的抽象模型，使得上层协议与硬件细节无关

在netif结构中定义了为每个网络接口保存的信息结构。它包括所有与接口有关的信息，以便上层协议在不知道具体硬件接口细节的情况下，也能访问接口信息。在netif的各个字段中，有一些含有硬件信息(比如硬件地址)，而另一些字段中所含的信息供协议软件使用(比如子网掩码)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221005/ae23e472fb3b4939b1345c622e822338.png