zebra，中文翻译是斑马，于是我打开了宋冬野的《斑马，斑马》作为BGM来完成这个篇章，嘿嘿，小资一把！
zebra姑且戏称它是quagga项目的大内总管。
因为它负责管理其他所有协议进程的路由信息的更新与交互，并负责与内核交换信息，如下的架构：
1 +----+ +----+ +-----+ +-----+
2 |bgpd| |ripd| |ospfd| |zebra|
3 +----+ +----+ +-----+ +-----+
4 |
5 +---------------------------|--+
6 | v |
7 | UNIX Kernel routing table |
8 | |
9 +------------------------------+
好了，简介完了，开始看代码吧：
1、zebra作为其他协议进程的服务端：
1 /* Make zebra server socket, wiping any existing one (see bug #403). */
2 void
3 zebra_zserv_socket_init(char *path) {
4 #ifdef HAVE_TCP_ZEBRA
5 zebra_serv();
6 #else
7 zebra_serv_un(path ? path : ZEBRA_SERV_PATH);
8 #endif /* HAVE_TCP_ZEBRA */
9 }
zebra绑定了（loopback，2600）的地址和端口，并开始监听socket，同时加入到thread事件ZEBRA_SERV当中，来接收客户端发送过来的路由信息：
1 accept_sock = socket(AF_INET, SOCK_STREAM, 0);
2
3 addr.sin_family = AF_INET;
4
5 addr.sin_port = htons(ZEBRA_PORT);
6 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
7 addr.sin_len = sizeof(struct sockaddr_in);
8 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
9 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
10
11 ret = bind(accept_sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
12
13 ret = listen(accept_sock, 1);
zebra_event(ZEBRA_SERV, accept_sock, NULL);
2、客户端（比如isis协议）：
2.1 创建客户端，并在初始化加入到thread事件调度当中去。
1 void
2 isis_zebra_init(struct thread_master *master) {
3 zclient = zclient_new(master);
4 zclient_init(zclient, ZEBRA_ROUTE_ISIS);
5
6 ......
7
8 return;
9 }
1 void
2 zclient_init (struct zclient *zclient, int redist_default)
3 {
4 int i;
5 /* Enable zebra client connection by default. */
6 zclient->enable = 1;
7 /* Set -1 to the default socket value. */
8 zclient->sock = -1;
9 .....
10 zclient_event (ZCLIENT_SCHEDULE, zclient);
11 }
1 static void
2 zclient_event(enum event event, struct zclient *zclient) {
3 switch (event) {
4 case ZCLIENT_SCHEDULE:
5 if (!zclient->t_connect) zclient->t_connect =
6 thread_add_event(zclient->master, zclient_connect, zclient, 0);
7 break;
8 ......
9 }
10 }
2.2 在zclient_connect里调用zclient_socket完成客户端sock的初始化：
1 int zclient_socket_connect(struct zclient *zclient) {
2 #ifdef HAVE_TCP_ZEBRA
3 zclient->sock = zclient_socket();
4 #else
5 zclient->sock = zclient_socket_un(zclient_serv_path_get());
6 #endif
7 return zclient->sock;
8 }
1 static int
2 zclient_socket(void) {
3 int sock;
4 int ret;
5 struct sockaddr_in serv;
6
7 /* We should think about IPv6 connection. */
8 sock = socket(AF_INET, SOCK_STREAM, 0);
9 if (sock < 0) return -1;
10
11 /* Make server socket. */
12 memset(&serv, 0, sizeof(struct sockaddr_in));
13 serv.sin_family = AF_INET;
14 serv.sin_port = htons(ZEBRA_PORT);
15 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
16 serv.sin_len = sizeof(struct sockaddr_in);
17 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
18 serv.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
19
20 /* Connect to zebra. */
21 ret = connect(sock, (struct sockaddr *)&serv, sizeof(serv));
22 if (ret < 0) {
23 close(sock);
24 return -1;
25 }
26 return sock;
27 }
嗯，服务端和客户端就这样完成了tcp通信连接，其他的客户端（如bgpd，ospfd等等）都是调用zclient_socket完成连接，代码复用了哦！
3、下面来看看作为大内总管，zebra如何处理日常事务：
首先是在thread的调度中，增加了read事件（可以看到整个系统，都是由thread模块在在暗中维持的运转）
1 thread_add_read(zebrad.master, zebra_client_read, client, sock);
1 /* Handler of zebra service request. */
2 static int
3 zebra_client_read(struct thread *thread) {
4 ......
5 command = stream_getw(client->ibuf);
6
7 .....
8
9 switch (command) {
10 .....
11
12 case ZEBRA_IPV4_ROUTE_ADD:
13 zread_ipv4_add(client, length, vrf_id);
14 break;
15 case ZEBRA_IPV4_ROUTE_DELETE:
16 zread_ipv4_delete(client, length, vrf_id);
17 break;
18 ......
19 default:
20 zlog_info("Zebra received unknown command %d", command);
21 break;
22 }
23
24 ......
25
26 zebra_event(ZEBRA_READ, sock, client);
27 return 0;
28 }
如上述代码，从消息内容中读取到对应事件号，比如ZEBRA_IPV4_ROUTE_ADD，ZEBRA_IPV4_ROUTE_DELETE，即是增加ipv4路由和删除ipv4路由。
4、再来看看大内总管（zebra）如何与皇上（内核）交互的：
在main里对这个过程做了初始化，函数是rib_init。
1 /* Routing information base initialize. */
2 void
3 rib_init(void)
4 {
5 rib_queue_init(&zebrad);
6 }
7
8 /* fill in the work queue spec */
9 zebra->ribq->spec.workfunc = &meta_queue_process;
上面代码创建一个工作队列，作为thread调度模块的一个低等级的后台调度（THREAD_BACKGROUND）执行的任务。在meta_queue_process函数里处理各个子队列：
1 /* Dispatch the meta queue by picking, processing and unlocking the next RN from
2 * a non-empty sub-queue with lowest priority. wq is equal to zebra->ribq and data
3 * is pointed to the meta queue structure.
4 */
5 static wq_item_status
6 meta_queue_process(struct work_queue *dummy, void *data)
7 {
8 struct meta_queue *mq = data;
9 unsigned i;
10
11 for (i = 0; i < MQ_SIZE; i++) if (process_subq(mq->subq[i], i))
12 {
13 mq->size--;
14 break;
15 }
16 return mq->size ? WQ_REQUEUE : WQ_SUCCESS;
17 }
process_subq函数里调用rib_process函数，即开始了对路由信息的处理，整个内核的路由的新旧比较与更新：
1 int
2 kernel_route_rib (struct prefix *p, struct rib *old, struct rib *new)
3 {
4 int route = 0;
5
6 if (zserv_privs.change(ZPRIVS_RAISE))
7 zlog (NULL, LOG_ERR, "Can't raise privileges");
8
9 if (old)
10 route |= kernel_rtm (RTM_DELETE, p, old);
11
12 if (new)
13 route |= kernel_rtm (RTM_ADD, p, new);
14
15 if (zserv_privs.change(ZPRIVS_LOWER))
16 zlog (NULL, LOG_ERR, "Can't lower privileges");
17
18 return route;
19 }
可以看到，最后使用netlink通信来更新内核的路由信息。
