quagga源码分析--大内总管zebra

zebra，中文翻译是斑马，于是我打开了宋冬野的《斑马，斑马》作为BGM来完成这个篇章，嘿嘿，小资一把！

zebra姑且戏称它是quagga项目的大内总管。

因为它负责管理其他所有协议进程的路由信息的更新与交互，并负责与内核交换信息，如下的架构：

 +----+  +----+  +-----+  +-----+
 |bgpd|  |ripd|  |ospfd|  |zebra|
 +----+  +----+  +-----+  +-----+
                             |
 +---------------------------|--+
 |                           v  |
 |  UNIX Kernel  routing table  |
 |                              |
 +------------------------------+

好了，简介完了，开始看代码吧：

1、zebra作为其他协议进程的服务端：

 /* Make zebra server socket, wiping any existing one (see bug #403). */
 void
 zebra_zserv_socket_init(char *path) {
 #ifdef HAVE_TCP_ZEBRA
     zebra_serv();
 #else
     zebra_serv_un(path ? path : ZEBRA_SERV_PATH);
 #endif /* HAVE_TCP_ZEBRA */
 }

zebra绑定了（loopback，2600）的地址和端口，并开始监听socket，同时加入到thread事件ZEBRA_SERV当中，来接收客户端发送过来的路由信息：

 accept_sock = socket(AF_INET, SOCK_STREAM, );

 addr.sin_family = AF_INET;

 addr.sin_port = htons(ZEBRA_PORT);
 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
     addr.sin_len = sizeof(struct sockaddr_in);
 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

 ret  = bind(accept_sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));

 ret = listen(accept_sock, );

zebra_event(ZEBRA_SERV, accept_sock, NULL);

2、客户端（比如isis协议）：

2.1 创建客户端，并在初始化加入到thread事件调度当中去。

 void
 isis_zebra_init(struct thread_master *master) {
     zclient = zclient_new(master);
     zclient_init(zclient, ZEBRA_ROUTE_ISIS);

     ......

     return;
 }

 void
 zclient_init (struct zclient *zclient, int redist_default)
 {
   int i;
   /* Enable zebra client connection by default. */
   zclient->enable = ;
   /* Set -1 to the default socket value. */
   zclient->sock = -;
   .....
   zclient_event (ZCLIENT_SCHEDULE, zclient);
 }　　

 static void
 zclient_event(enum event event, struct zclient *zclient) {
     switch (event) {
     case ZCLIENT_SCHEDULE:
         if (!zclient->t_connect) zclient->t_connect =
                 thread_add_event(zclient->master, zclient_connect, zclient, );
         break;
         ......
     }
 }

2.2 在zclient_connect里调用zclient_socket完成客户端sock的初始化：

 int zclient_socket_connect(struct zclient *zclient) {
 #ifdef HAVE_TCP_ZEBRA
     zclient->sock = zclient_socket();
 #else
     zclient->sock = zclient_socket_un(zclient_serv_path_get());
 #endif
     return zclient->sock;
 }

 static int
 zclient_socket(void) {
     int sock;
     int ret;
     struct sockaddr_in serv;

     /* We should think about IPv6 connection. */
     sock = socket(AF_INET, SOCK_STREAM, );
     if (sock < ) return -;

     /* Make server socket. */
     memset(&serv, , sizeof(struct sockaddr_in));
     serv.sin_family = AF_INET;
     serv.sin_port = htons(ZEBRA_PORT);
 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
     serv.sin_len = sizeof(struct sockaddr_in);
 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
     serv.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

     /* Connect to zebra. */
     ret = connect(sock, (struct sockaddr *)&serv, sizeof(serv));
     if (ret < ) {
         close(sock);
         return -;
     }
     return sock;
 }

嗯，服务端和客户端就这样完成了tcp通信连接，其他的客户端（如bgpd，ospfd等等）都是调用zclient_socket完成连接，代码复用了哦！

3、下面来看看作为大内总管，zebra如何处理日常事务：

首先是在thread的调度中，增加了read事件（可以看到整个系统，都是由thread模块在在暗中维持的运转）

 thread_add_read(zebrad.master, zebra_client_read, client, sock);

 /* Handler of zebra service request. */
 static int
 zebra_client_read(struct thread *thread) {
     ......
     command = stream_getw(client->ibuf);

     .....

     switch (command) {
     .....

     case ZEBRA_IPV4_ROUTE_ADD:
         zread_ipv4_add(client, length, vrf_id);
         break;
     case ZEBRA_IPV4_ROUTE_DELETE:
         zread_ipv4_delete(client, length, vrf_id);
         break;
     ......
     default:
         zlog_info("Zebra received unknown command %d", command);
         break;
     }

     ......

     zebra_event(ZEBRA_READ, sock, client);
     return ;
 }

如上述代码，从消息内容中读取到对应事件号，比如ZEBRA_IPV4_ROUTE_ADD，ZEBRA_IPV4_ROUTE_DELETE，即是增加ipv4路由和删除ipv4路由。

4、再来看看大内总管（zebra）如何与皇上（内核）交互的：

在main里对这个过程做了初始化，函数是rib_init。

 /* Routing information base initialize. */
 void
 rib_init(void)
 {
     rib_queue_init(&zebrad);
 }

     /* fill in the work queue spec */
     zebra->ribq->spec.workfunc = &meta_queue_process;

上面代码创建一个工作队列，作为thread调度模块的一个低等级的后台调度（THREAD_BACKGROUND）执行的任务。在meta_queue_process函数里处理各个子队列：

 /* Dispatch the meta queue by picking, processing and unlocking the next RN from
  * a non-empty sub-queue with lowest priority. wq is equal to zebra->ribq and data
  * is pointed to the meta queue structure.
  */
 static wq_item_status
 meta_queue_process(struct work_queue *dummy, void *data)
 {
     struct meta_queue *mq = data;
     unsigned i;

     for (i = ; i < MQ_SIZE; i++) if (process_subq(mq->subq[i], i))
         {
             mq->size--;
             break;
         }
     return mq->size ? WQ_REQUEUE : WQ_SUCCESS;
 }

process_subq函数里调用rib_process函数，即开始了对路由信息的处理，整个内核的路由的新旧比较与更新：

 int
 kernel_route_rib (struct prefix *p, struct rib *old, struct rib *new)
 {
   int route = ;

   if (zserv_privs.change(ZPRIVS_RAISE))
     zlog (NULL, LOG_ERR, "Can't raise privileges");

   if (old)
     route |= kernel_rtm (RTM_DELETE, p, old);

   if (new)
     route |= kernel_rtm (RTM_ADD, p, new);

   if (zserv_privs.change(ZPRIVS_LOWER))
     zlog (NULL, LOG_ERR, "Can't lower privileges");

   return route;
 }

可以看到，最后使用netlink通信来更新内核的路由信息。