zebra 的Thread机制 -- 003

比眉伴天荒 2021-10-26 22:54 799阅读 0赞

==========================================================

一、线程机制概述

zebra这个软件包整体结构大致可分为两大块：协议模块和守护进程模块。协议模块实现各协议的功能，各协议以子模块的形式加载到zebra中；守护进程模块的功能主要是管理各协议的信令传输、表项操作、系统操作调用等事务，为各协议提供底层信息以及相关的硬件处理等功能支持。Zebra与各协议的交互采用的是C-S模式，在每个协议子模块中均有一个Client端与守护进程模块中的Server端交互，它们所使用的socket为zebra内部使用的socket，不与外部交互。

zebra中的线程是分队列调度的，每个队列以一个链表的方式实现。线程队列可以分成五个列：event、timer、ready、read、write。队列的优先级由高到低排列。但是，read和write队列并不参与到优先级的排列中，实际操作时，如果read和write队列中的线程就绪，就加入ready队列中，等待调度。调度时，首先进行event队列中线程的调度，其次是timer和ready。

实际上，zebra中的线程是“假线程”，它并没有实现线程中的优先级抢占问题。在zebra的线程管理中，有个虚拟的时间轴，必须等前一时间的线程处理完，才看下一时间的线程是否触发。由于电脑处理速度较快且处理每个线程的时间间隔较小，所以处理其多线程来可以打到类似“并行处理”的效果。

zebra源码中有关线程管理的各个函数放置于zebra-0.95a\\lib文件夹的thread.h和thread.c两个文件中。

二、线程管理源码分析

这是线程队列中每一个单个线程的代码描述，线程队列被描述成双向链表的形式，thread结构体是双向链表的元素。共有六种线程：read、write、timer、event、ready、unused。因此，线程队列也有六种。

struct thread
    
    {
    
    unsigned char type;        /* thread类型，共有六种 */
    
    struct thread *next;        /* 指向下一thread的指针，双向链表 */
    
    struct thread *prev;        /*指向前一thread的指针*/
    
    struct thread_master *master;      /* 指向该thread所属thread_master结构体的指针 */
    
    int (*func) (struct thread *); /* event类型thread的函数指针 */
    
    void *arg;               /* event类型thread的参数 */
    
    union {
    
        int val;                /* event类型thread的第二个参数*/
    
        int fd;                  /* read/write类型thread相应的文件描述符 */
    
        struct timeval sands;   /* 该thread的剩余时间，timeval类型，此结构体定义在time.h中，有两个元素，秒和微秒 */
    
    } u;
    
    RUSAGE_T ru;                    /* 详细用法信息，RUSAGE这个宏在该thread有用法描述时定义为rusage类型，描述其详细进程资源信息，没有用法描述时定义为timeval类型 */
    
    };

一个thread\_list结构体描述一个thread双向链表，也即一个进程队列。

struct thread_list
    
    {
    
    struct thread *head;/* 该线程队列头指针 */
    
    struct thread *tail; /* 该线程队列尾指针 */
    
    int count; /* 该线程队列元素数目 */
    
    };

总的线程管理结构体，里面存有六种线程队列，三种文件描述符以及占用空间信息。

struct thread_master
    
    {
    
    //六种线程队列
    
    struct thread_list read;
    
    struct thread_list write;
    
    struct thread_list timer;
    
    struct thread_list event;
    
    struct thread_list ready;
    
    struct thread_list unuse;
    
    //三种文件描述符
    
    fd_set readfd;
    
    fd_set writefd;
    
    fd_set exceptfd;
    
    //该thread_master所占空间大小
    
    unsigned long alloc;
    
    };

1.1 相关函数简介  
下面给出了zebra关于线程管理的相关函数的简要功能介绍。

1.1.1 thread\_master\_create ()  
为创建一个新的thread\_master结构体动态开辟一块内存空间。

1.1.2 thread\_list\_add ()  
在list双向链表尾部插入一个新的thread。

1.1.3 thread\_list\_add\_before ()  
在函数参数point所指向的thread前面插入一个新的thread。

1.1.4 thread\_list\_delete ()  
删除参数中指定的thread。

1.1.5 thread\_add\_unuse ()  
向指定thead\_master中的unused链表尾部插入新thread。

1.1.6 thread\_list\_free ()  
从内存中释放掉指定thread\_master中的指定thread链表所占空间。

1.1.7 thread\_master\_free ()  
彻底释放指定thread\_master所占内存空间。

1.1.8 thread\_trim\_head ()  
若指定thread链表中非空，删除该链表头指针所指thread，并将其返回，即从线程队列中取出一个线程。

1.1.9 thread\_empty ()  
判断指定thread链表是否为空。

1.1.10 thread\_timer\_remain\_second ()  
得到指定线程的剩余时间。

1.1.11 thread\_get ()  
若指定thread\_master中的unuse链表非空，从该队列中取出一个thread，根据参数初始化并返回之。否则，给该thread\_master多开辟一块空间给新的thread，根据参数初始化该thread并返回之。

1.1.12 thread\_add\_read ()  
根据所给参数在指定thread\_master中添加并初始化一个read类型的thread并返回之。

1.1.13 thread\_add\_write ()  
根据所给参数在指定thread\_master中添加并初始化一个write类型的thread并返回之。

1.1.14 thread\_add\_timer ()  
根据所给参数在指定thread\_master中添加并初始化一个timer类型的thread。若timer链表不要求排序，则直接返回新thread，若要求排序，则将新thread插入到队列的相应位置后再返回之。

1.1.15 thread\_add\_event ()  
根据所给参数在指定thread\_master中添加并初始化一个event类型的thread并返回之。

1.1.16 thread\_cancel ()  
删除指定thread，删除后将其类型置为THREAD\_UNUSED，并将其插入到该thread\_master的unuse链表中。

1.1.17 thread\_cancel\_event ()  
将指定thread\_master的event链表中与参数中arg相匹配的thread删除。

1.1.18 thread\_timer\_wait ()  
找出指定thread\_master的timer链表中最小的剩余时间并将其返回。

1.1.19 thread\_run ()  
将指定thread的值赋给thread类型的fetch，然后将其类型置为THREAD\_UNUSED，并将其插入unuse链表，返回fetch。

1.1.20 thread\_process\_fd ()  
将指定thread链表中的元素取出插入到该thread\_master的ready链表中，返回该链表中插入元素的个数。

1.1.21 thread\_fetch ()  
若指定thread\_master的event队列非空取出其头元素并用run函数处理。取出并用run函数处理timer队列中每一个之前创建的线程。若指定thread\_master的ready队列非空取出其头元素并用run函数处理。拷贝该thread\_master的文件描述符。将read和write链表插到ready链表中，再从ready链表取头元素用run函数处理。如此无限循环下去直到所有进程都处理完。

1.1.22 thread\_consumed\_time ()  
得到该进程所耗费的时间。

1.1.23 thread\_call ()  
执行该thread中的功能函数，如果该thread持续时间超过CPU规定的独占时间，发出警告。

1.1.24 thread\_execute ()  
根据参数创建一个event类型的thread并用thread\_call()函数对其进行处理

====================================================================================

一、主要从 daemon 的 thread角度 分析备忘。

注意： 具体函数功能详见附录，分析要结合zebra源代码(thread.c中)。

1、每个daemon(e.g igmp-snooping、ring)都定义一个 master 的 全局变量；

2、master 内 有六个 struct thread\_list \*read、write 等六个 链表；

3、最小的 执行单元为 thread ， 必要的时候会 挂在 对应的 thread\_list 上；

4、最终 最重要的是 各个daemon的 main函数最后的 while(thread\_fetch(master, &thread))  thread\_call(&thrad);

5、thread\_fetch 功能是查找master 结构下的 几个 struct thread\_list 链；

6、其中， 三个链是 比较 重要的，struct thread\_list \*event、timer、ready；

7、thread\_fetch  的查找顺序 也是上边这个 顺序， 所以其没有真正的 优先级 抢断问题(真正的线程pthread)；

8、查找每个链的过程  就是 看看 该链上  有没有 准备好的 thread；

9、有的话从 该链上移除， 做适当的 type 等重新赋值， 然后加入到  unuse  链上； 《thread\_run() 的执行过程》

注：移到 unuse 链上 ，而不是 直接free掉， 是为了以后 有新的thread要挂到  event、timer、ready等链上的时                  候，可以直接 来 unuse 链上来取， 不用重新 malloc， 节省时间。

10、然后 返回查找到的 thread，然后main中的while下  调用thread\_call(&thrad)  执行 该块 thread；

11、此外 还有 两个重要的  明示给 用户(程序员)的  thread\_list \* read、write，对应 socket 的 read、write事件；

12、当有 read、write类型的socket 要加入 到list 时， 调用 thread\_add\_read/write 把相应的 sfd及 func以thread的形         式加入到 对应的  read 或者 write  thread\_list；

13、同时，重要的是： thread\_add\_read 里 只要是把 对应的  sfd 加入到 master->readfd/writefd(fd\_set 类型);

14、而后 thread\_fetch里调用 select 对 read、write、error 的fd\_set进行 监听；

15、并调用两次thread\_process\_fd把  有事件的fd(FD\_ISSET) 对应的 thread  从 thread\_list \* read、write 链中移除；

16、并进一步加入到ready链中；

17、在thread\_fetch 最后， 再对ready链中 移除头元素，加入unuse 链，返回该thread块，并等待thread\_call执行；

18、对于 thread\_fetch中timer链的查找，遍历timer链中所有thread，查找超时的 thread，返回该thread：过程如下：

19、当用 thread\_add\_timer 添加 timer 事件时，用参数func、time、master等， 构造一个 thread；

20、其中thread->u.sands 为 (gettimeofday + time),  是未来的 某一个时间值，遍历timer链上的thread时， 再                     gettimeofday一下， 然后与 thread->u.sands对比，确定该thread 是否  超时 可执行；

21、对于thread\_fetch中 监听 read、write事件的 select 的timeout 时间问题： 函数 thread\_time\_wait()

22、(NO sort)遍历 timer链上 所有thread，取最小的  thread->u.sands  ，与现在的gettimeofday比较，若小于(表明最                       小的thread块已经超时)则timeout,应该给一个最小的值，免得timer事件 误差太大，timeout=10us；

若大于gettimeofday(sec>=0)(还未超时)，则 timeout=该值与gettimeofday之差；再while1的时候下一个                         thread正好超时一点，不会误差太大；

若 timer链上无thread，则select 为 阻塞。(timeout=NULL);   (没有事件处理阻塞，进程挂起无影响)

二、daemon与vtysh间的通信(依赖daemon的thread机制)

注：①其间的通信主要是 vtysh从终端获取输入的CLI命令，然后解析，根据DEFSH或者其他发往指定daemon；

②vtysh进程会和每个daemon进行connect；

③connect分两种， 一种是vtysh进程main中 connect\_default(rcs默认启动的daemon)；

二是 vtysh\_send之前 会 connect 对应的 daemon

下边结合 daemon (e.g igmp-snooping) 与 vtysh 进程 通信来 举例：

1、 igmp-snooping 的 main 中，如下图所示吧:

![Center][]

![Center 1][]

![Center 2][]

2、实际上 但从 发送CLI命令字符 来看， 是daemon端 维护一个 select， vtysh 端 connect及 send；

3、可待续补充......

三、vtysh端的read、write的阻塞与  数据传输 不丢失保证

1、待 补充.....

四、daemon端接收其他报文的socket

1、igmp-snooping 要  申请一个 g\_snoop\_pkt\_sock=socket(AF\_INET,SOCK\_PACKET,htons(0800));

2、该socket 用来 接收 igmp 报文；

3、根据网上的资料，对于socket类型的文件，不显式用fcntl (sockfd,F\_SETFL,O\_NONBLOCK) 设定时，默认阻塞；

4、所以 recv(g\_snoop\_pkt\_sock， ，)  为 阻塞的；   但该阻塞 永远不会发生！！！  原因如下：  
5、在 igmp-snooping enable中用 thread\_add\_read 把 g\_snoop\_pkt\_sockadd到read 链里， 即，受select监控。

6、只有在 有 igmp 报文 到达 该g\_snoop\_pkt\_sock  时，select检测到，并执行thread块，即igmp\_snooping\_read，

进而才会执行到  阻塞的   recv(g\_snoop\_pkt\_sock， ，)，但此时为已经 有报文过来，所以该recv不会阻塞；

7、结论：对于该 接收其他AF\_INET报文的 socket，在该架构下， 阻塞与否 几乎无差异！！

8、ring 中 接收ring报文 的   几乎 和上述相同，g\_ring\_sock = socket(AF\_INET, SOCK\_PACKET, htons(0x7010));

9、下边的 步骤 同上述 2---7， 另， ring 的 socket 用的 read。

=========================================================================

**1．thread的四种创建方法**

一个新的thread可以通过如下三种方式被创建，主要是看你需要创建的thread的类型：

1，  thread\_add\_read：添加一个thread到read queue，该thread负责通过socket接受和读取从client端来的数据。

2，  thread\_add\_write：添加一个thread到write queue，该thread负责通过socket向client端填充和写数据。

3，  thread\_add\_timer function calls：添加一个thread到timer queue,该thread负责定时一个event，例如update和redistribute一个route table.

4，  thread\_add\_event：添加一个event thread到event queue。

上面这三个函数的处理过程都差不多：

1，  创建thread。首先在unuse queue查找，如果有unuse thread，就使用它，否则重新分配空间。

2，  根据参数，对thread进行赋值。

3，  将该thread加入到相应的queue中。

**2． thread的调用**

1，bgp daemon不断地从event queue中取出thread并且执行它。一旦该thread被执行了，将该thread的type设置为unuse。并且将该thread添加到unuse queue中。

2，如果event queue为空时，bgp daemon 通过select函数监控读、写、异常三个描述符集。一旦有某个描述符准备就绪，则将该描述符所对应的thread加入ready queue.

而对于timer queue中的thread，只有当select函数超时后才会进入ready queue.

**3．zebrad端的thread**

zebrad启动后会，在read queue中会出现两个thread，一个是等待来自local client端bgpd的连接，另一个是等待来自vty client端的连接。

**第1个thread**

zebra\_init ( )-> zebra\_serv\_un ( )中创建一个thread，加入read queue。该thread的处理函数为[zebra\_accept][zebra_accept]，监听内部client的socket。

[ zebra\_client\_create (client\_sock);][zebra_client_create _client_sock]创建一个新的zebra client

/\* Register myself. \*/

zebra\_event (ZEBRA\_SERV, accept\_sock, NULL);继续监听server socket

puts("<-zebra\_accept");

return 0;

[vty\_accept][vty_accept]，加入read queue。作为vty server监听internet的vty socket.。

[vty\_create][vty_create](vty\_sock, &su);

根据vty\_sock和ip地址信息su，创建一个新的vty。

puts("<-vty\_accept");

return 0;

[vty\_flush][vty_flush]。

vty\_event (VTY\_READ, vty\_sock, vty);

根据new client vty的vty\_sock创建新的VTY\_READ thread，加入read queue，该thread的处理函数为[vty\_read][vty_read]。

return vty;

[sockunion\_bind][sockunion_bind](accept\_sock, &su, port, NULL);

将accept\_socket文件描述符与一个特定的逻辑网络连系起来。服务器端使用su->sin.sin\_addr.s\_addr = htonl (INADDR\_ANY);表示接受任何一个主机网络接口上的连接请求。

if (ret < 0)

close (accept\_sock);   /\* Avoid sd leak. \*/

return;

/\* Listen socket under queue 3. \*/

ret = listen (accept\_sock, 3);

将accept\_sock套接口设置成被动监听状态，用于接受连接，只能在服务器端使用。

if (ret < 0)

zlog (NULL, LOG\_WARNING, "can't listen socket");

close (accept\_sock);   /\* Avoid sd leak. \*/

return;

/\* Add vty server event. \*/

[ vty\_event][vty_event](VTY\_SERV, accept\_sock, NULL);

sockunion\_bind操作

/\* Bind socket to specified address. \*/

int　sockunion\_bind (int sock, union sockunion \*su, unsigned short port,

union sockunion \*su\_addr)

int size = 0;

int ret;

if (su->sa.sa\_family == AF\_INET)

size = sizeof (struct sockaddr\_in);

su->sin.sin\_port = htons (port);

\#ifdef HAVE\_SIN\_LEN

su->sin.sin\_len = size;

\#endif /\* HAVE\_SIN\_LEN \*/

if (su\_addr == NULL)

su->sin.sin\_addr.s\_addr = htonl (INADDR\_ANY);

服务器一般将sin\_addr.s\_addr 字段设置为INADDR\_ANY表示套接字应接收任何一个主机网络接口上的连接请求。

客户端将sin\_addr.s\_addr字段设置为服务器主机的IP地址。

\#ifdef HAVE\_IPV6

else if (su->sa.sa\_family == AF\_INET6)

size = sizeof (struct sockaddr\_in6);

su->sin6.sin6\_port = htons (port);

\#ifdef SIN6\_LEN

su->sin6.sin6\_len = size;

\#endif /\* SIN6\_LEN \*/

if (su\_addr == NULL)

\#if defined(LINUX\_IPV6) || defined(NRL)

bzero (&su->sin6.sin6\_addr, sizeof (struct in6\_addr));

\#else

su->sin6.sin6\_addr = in6addr\_any;

\#endif /\* LINUX\_IPV6 \*/

\#endif /\* HAVE\_IPV6 \*/

ret = bind (sock, (struct sockaddr \*)su, size);

if (ret < 0)

zlog (NULL, LOG\_WARNING, "can't bind socket : %s", strerror (errno));

return ret;

vty\_event操作

/\* struct thread\_master \*master; \*/

static void　vty\_event (enum event event, int sock, struct vty \*vty)

struct thread \*vty\_serv\_thread;

switch (event)

case VTY\_SERV:

vty\_serv\_thread = thread\_add\_read (master, vty\_accept, vty, sock);

vector\_set\_index (Vvty\_serv\_thread, sock, vty\_serv\_thread);

break;

case VTY\_READ:

vty->t\_read = thread\_add\_read (master, vty\_read, vty, sock);

/\* Time out treatment. \*/

if (vty->v\_timeout)

if (vty->t\_timeout)

thread\_cancel (vty->t\_timeout);

vty->t\_timeout =

thread\_add\_timer (master, vty\_timeout, vty, vty->v\_timeout);

break;

case VTY\_WRITE:

if (! vty->t\_write)

vty->t\_write = thread\_add\_write (master, vty\_flush, vty, sock);

break;

case VTY\_TIMEOUT\_RESET:

if (vty->t\_timeout)

thread\_cancel (vty->t\_timeout);

vty->t\_timeout = NULL;

if (vty->v\_timeout)

vty->t\_timeout =

thread\_add\_timer (master, vty\_timeout, vty, vty->v\_timeout);

break;

**第2 个thread**

bgp\_serv\_sock( )-> bgp\_serv\_sock\_family( )中创建一个thread，不是通过event的方式添加的。该thread的处理函数为bgp\_accept。作为bgp\_server，接受来自 internet上的bgp连接。

bgp\_serv\_sock\_family操作

port = 179  family = AF\_INET

/\* Make bgpd's server socket. \*/

void　bgp\_serv\_sock\_family (unsigned short port, int family)

int ret;

int bgp\_sock;

union sockunion su;

bzero (&su, sizeof (union sockunion));

/\* Specify address family. \*/

su.sa.sa\_family = family;

bgp\_sock = sockunion\_stream\_socket (&su);  产生一个BGP socket

sockopt\_reuseaddr (bgp\_sock);

sockopt\_reuseport (bgp\_sock);

ret = sockunion\_bind (bgp\_sock, &su, port, NULL);

ret = listen (bgp\_sock, 3);

if (ret < 0)

zlog (NULL, LOG\_INFO, "Can't listen bgp server socket : %s",

strerror (errno));

return;

thread\_add\_read (master, bgp\_accept, NULL, bgp\_sock); 添加一个thread 到readlist中。

VTY server和BGP server 在使用accept操作的方法如下：

他们均是通过创建一个THREAD\_READ 类型的thread，加到Master的readlist的队列后面，thread 的处理函数会执行accept操作。

VTY accept：

vty\_serv\_thread = thread\_add\_read (master, vty\_accept, vty, sock);

BGP server accept:

thread\_add\_read (master, bgp\_accept, NULL, bgp\_sock);

**bgpd和zebrad间通信**

bgp和zebra是通过zebra message进行通信，格式如下：

报文头3字节 （前两字节length，后1字节为command type）

报文体长度不定。

/\* Zebra message types. \*/

\#define ZEBRA\_INTERFACE\_ADD                1

\#define ZEBRA\_INTERFACE\_DELETE             2

\#define ZEBRA\_INTERFACE\_ADDRESS\_ADD        3

\#define ZEBRA\_INTERFACE\_ADDRESS\_DELETE     4

\#define ZEBRA\_INTERFACE\_UP                 5

\#define ZEBRA\_INTERFACE\_DOWN               6

\#define ZEBRA\_IPV4\_ROUTE\_ADD               7

\#define ZEBRA\_IPV4\_ROUTE\_DELETE            8

\#define ZEBRA\_IPV6\_ROUTE\_ADD               9

\#define ZEBRA\_IPV6\_ROUTE\_DELETE           10

\#define ZEBRA\_REDISTRIBUTE\_ADD            11

\#define ZEBRA\_REDISTRIBUTE\_DELETE         12

\#define ZEBRA\_REDISTRIBUTE\_DEFAULT\_ADD    13

\#define ZEBRA\_REDISTRIBUTE\_DEFAULT\_DELETE 14

\#define ZEBRA\_IPV4\_NEXTHOP\_LOOKUP         15

\#define ZEBRA\_IPV6\_NEXTHOP\_LOOKUP         16

bgpd和zebrad之间的api接口

bgp端接受到message后，会执行相应的bgp action:

bgp action func                                         message type

int (\*interface\_add) (int, struct zclient \*, zebra\_size\_t);        ZEBRA\_INTERFACE\_ADD

int (\*interface\_delete) (int, struct zclient \*, zebra\_size\_t);                       ZEBRA\_INTERFACE\_DELETE

int (\*interface\_up) (int, struct zclient \*, zebra\_size\_t);                           ZEBRA\_INTERFACE\_UP

int (\*interface\_down) (int, struct zclient \*, zebra\_size\_t);                       ZEBRA\_INTERFACE\_DOWN

int (\*interface\_address\_add) (int, struct zclient \*, zebra\_size\_t);          ZEBRA\_INTERFACE\_ADDRESS\_ADD

int (\*interface\_address\_delete) (int, struct zclient \*, zebra\_size\_t);  ZEBRA\_INTERFACE\_ADDRESS\_DELETE

int (\*ipv4\_route\_add) (int, struct zclient \*, zebra\_size\_t);                   ZEBRA\_IPV4\_ROUTE\_ADD

int (\*ipv4\_route\_delete) (int, struct zclient \*, zebra\_size\_t);                  ZEBRA\_IPV4\_ROUTE\_DELETE

int (\*ipv6\_route\_add) (int, struct zclient \*, zebra\_size\_t);                    ZEBRA\_IPV6\_ROUTE\_ADD

int (\*ipv6\_route\_delete) (int, struct zclient \*, zebra\_size\_t);                 ZEBRA\_IPV6\_ROUTE\_DELETE

zebra 端接受到message后，会执行相应的zebra action:

zebra action func                                                              message type

void zread\_interface\_add (struct zserv \*client, u\_short length)                         ZEBRA\_INTERFACE\_ADD

void zread\_interface\_delete (struct zserv \*client, u\_short length)                     ZEBRA\_INTERFACE\_DELETE

void zread\_ipv4\_add (struct zserv \*client, u\_short length)                                    ZEBRA\_IPV4\_ROUTE\_ADD

void zread\_ipv4\_delete (struct zserv \*client, u\_short length)                                   ZEBRA\_IPV4\_ROUTE\_DELETE

void zread\_ipv6\_add (struct zserv \*client, u\_short length)                              ZEBRA\_IPV6\_ROUTE\_ADD

void zread\_ipv6\_delete (struct zserv \*client, u\_short length)                           ZEBRA\_IPV6\_ROUTE\_DELETE

void zebra\_redistribute\_add (int command, struct zserv \*client, int length)              ZEBRA\_REDISTRIBUTE\_ADD

void zebra\_redistribute\_delete (int command, struct zserv \*client, int length)           ZEBRA\_REDISTRIBUTE\_DELETE

voidzebra\_redistribute\_default\_add (int command,

struct zserv \*client, int length)                                  ZEBRA\_REDISTRIBUTE\_DEFAULT\_ADD

void zebra\_redistribute\_default\_delete (int command,

struct zserv \*client, int length)                               ZEBRA\_REDISTRIBUTE\_DEFAULT\_DELETE

void zread\_ipv4\_nexthop\_lookup (struct zserv \*client, u\_short length)     ZEBRA\_IPV4\_NEXTHOP\_LOOKUP

void zread\_ipv6\_nexthop\_lookup (struct zserv \*client, u\_short length)        ZEBRA\_IPV6\_NEXTHOP\_LOOKUP

bgp action：将local\_client\_socket中数据，写入bgp数据库。

zebra action：将zebra数据库中的信息写入local\_server\_subsocket，让local client端进行读取。

bgp peer间通信

bgp\_accept操作

/\* Accept bgp connection. \*/

int bgp\_accept (struct thread \*thread)

int bgp\_sock;

int accept\_sock;

union sockunion su;

struct peer \*peer;

struct peer \*peer1;

char buf\[SU\_ADDRSTRLEN\];

/\* Regiser accept thread. \*/

accept\_sock = THREAD\_FD (thread);

printf("->bgp\_accept \[%d\]\\n",accept\_sock);

thread\_add\_read (master, bgp\_accept, NULL, accept\_sock);

/\* Accept client connection. \*/

bgp\_sock = sockunion\_accept (accept\_sock, &su);

if (bgp\_sock < 0)

zlog\_err ("\[Error\] BGP socket accept failed (%s)", strerror (errno));

printf("\[Error\] BGP socket accept failed (%s)", strerror (errno));

puts("<-bgp\_accept 2");

return -1;

if (BGP\_DEBUG (events, EVENTS))

zlog\_info ("\[Event\] BGP connection from host %s", inet\_sutop (&su, buf));

printf("\[Event\] BGP connection from host %s", inet\_sutop (&su, buf));

/\* Check remote IP address \*/

peer1 = peer\_lookup\_by\_su (&su);

if (! peer1 || peer1->status == Idle)

if (BGP\_DEBUG (events, EVENTS))

if (! peer1)

zlog\_info ("\[Event\] BGP connection IP address %s is not configured",

inet\_sutop (&su, buf));

else

zlog\_info ("\[Event\] BGP connection IP address %s is Idle state",

inet\_sutop (&su, buf));

close (bgp\_sock);

puts("<-bgp\_accept 2");

return -1;

/\* Make dummy peer until read Open packet. \*/

if (BGP\_DEBUG (events, EVENTS))

zlog\_info ("\[Event\] Make dummy peer structure until read Open packet");

printf("\[Event\] Make dummy peer structure until read Open packet\\n");

char buf\[SU\_ADDRSTRLEN + 1\];

peer = peer\_create\_accept ();

SET\_FLAG (peer->sflags, PEER\_STATUS\_ACCEPT\_PEER);

peer->su = su;

peer->fd = bgp\_sock;

peer->status = Active;

/\* Make peer's address string. \*/

sockunion2str (&su, buf, SU\_ADDRSTRLEN);

peer->host = strdup (buf);

BGP\_EVENT\_ADD (peer, TCP\_connection\_open); 创建一个event thread执行bgp\_event函数

puts("<-bgp\_accept 0");

return 0;

bgp\_event操作

/\* Execute event process. \*/

int bgp\_event (struct thread \*thread)

int ret;

int event;

int next;

struct peer \*peer;

peer = THREAD\_ARG (thread); // get peer

event = THREAD\_VAL (thread); // get FSM event  eg.TCP\_connection\_open

puts("->bgp\_event");

/\* Logging this event. \*/

next = FSM \[peer->status -1\]\[event - 1\].next\_state;  next为下一个状态

if (BGP\_DEBUG (fsm, FSM))

plog\_info (peer->log, "%s \[FSM\] %s (%s->%s)", peer->host,

bgp\_event\_str\[event\],

LOOKUP (bgp\_status\_msg, peer->status),

LOOKUP (bgp\_status\_msg, next));

printf("%s \[FSM\] %s (%s->%s)", peer->host,

bgp\_event\_str\[event\],

LOOKUP (bgp\_status\_msg, peer->status),

LOOKUP (bgp\_status\_msg, next));

/\* Call function. \*/

ret = (\*(FSM \[peer->status - 1\]\[event - 1\].func))(peer); 执行本状态处理函数

/\* When function do not want proceed next job return -1. \*/

if (ret < 0)

puts("<-bgp\_event 1");

return ret;

/\* If status is changed. \*/

if (next != peer->status)               判断状态是否需要转变

fsm\_change\_status (peer, next);

/\* Make sure timer is set. \*/

bgp\_timer\_set (peer);

puts("<-bgp\_event 0");

return 0;

[Center]: /images/20211026/21c46588d7b842d3859c86eec23e16ab.png
[Center 1]: /images/20211026/1364f1e70b614a5998c231c64c47ae0c.png
[Center 2]: /images/20211026/c972c8085d1344bfa9e015924dcaa2d3.png
[zebra_accept]: http://blog.163.com/xu_jin_rong/blog/getBlog.do#_zebra_accept%E6%93%8D%E4%BD%9C
[zebra_client_create _client_sock]: http://blog.163.com/xu_jin_rong/blog/getBlog.do#_zebra_client_create_%E6%93%8D%E4%BD%9C
[vty_accept]: http://blog.163.com/xu_jin_rong/blog/getBlog.do#_vty_accept%E6%93%8D%E4%BD%9C
[vty_create]: http://blog.163.com/xu_jin_rong/blog/getBlog.do#_vty_create%E6%93%8D%E4%BD%9C
[vty_flush]: http://blog.163.com/xu_jin_rong/blog/getBlog.do#_vty_flush%E6%93%8D%E4%BD%9C
[vty_read]: http://blog.163.com/xu_jin_rong/blog/getBlog.do#_vty_read%E6%93%8D%E4%BD%9C
[sockunion_bind]: http://blog.163.com/xu_jin_rong/blog/getBlog.do#_sockunion_bind%E6%93%8D%E4%BD%9C
[vty_event]: http://blog.163.com/xu_jin_rong/blog/getBlog.do#_vty_event%E6%93%8D%E4%BD%9C