]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - ospf6d/ospf6_zebra.c
New upstream version 1.2.4
[quagga-debian.git] / ospf6d / ospf6_zebra.c
1 /*
2  * Copyright (C) 2003 Yasuhiro Ohara
3  *
4  * This file is part of GNU Zebra.
5  *
6  * GNU Zebra is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the
8  * Free Software Foundation; either version 2, or (at your option) any
9  * later version.
10  *
11  * GNU Zebra is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with GNU Zebra; see the file COPYING.  If not, write to the 
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
19  * Boston, MA 02111-1307, USA.  
20  */
21
22 #include <zebra.h>
23
24 #include "log.h"
25 #include "vty.h"
26 #include "command.h"
27 #include "prefix.h"
28 #include "stream.h"
29 #include "zclient.h"
30 #include "memory.h"
31
32 #include "ospf6_proto.h"
33 #include "ospf6_top.h"
34 #include "ospf6_interface.h"
35 #include "ospf6_route.h"
36 #include "ospf6_lsa.h"
37 #include "ospf6_lsdb.h"
38 #include "ospf6_asbr.h"
39 #include "ospf6_zebra.h"
40 #include "ospf6d.h"
41
42 unsigned char conf_debug_ospf6_zebra = 0;
43
44 /* information about zebra. */
45 struct zclient *zclient = NULL;
46
47 struct in_addr router_id_zebra;
48
49 /* Router-id update message from zebra. */
50 static int
51 ospf6_router_id_update_zebra (int command, struct zclient *zclient,
52                               zebra_size_t length, vrf_id_t vrf_id)
53 {
54   struct prefix router_id;
55   struct ospf6 *o = ospf6;
56
57   zebra_router_id_update_read(zclient->ibuf,&router_id);
58   router_id_zebra = router_id.u.prefix4;
59
60   if (o == NULL)
61     return 0;
62
63   if (o->router_id  == 0)
64     o->router_id = (u_int32_t) router_id_zebra.s_addr;
65
66   return 0;
67 }
68
69 /* redistribute function */
70 void
71 ospf6_zebra_redistribute (int type)
72 {
73   if (vrf_bitmap_check (zclient->redist[type], VRF_DEFAULT))
74     return;
75   vrf_bitmap_set (zclient->redist[type], VRF_DEFAULT);
76   if (zclient->sock > 0)
77     zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type,
78                              VRF_DEFAULT);
79 }
80
81 void
82 ospf6_zebra_no_redistribute (int type)
83 {
84   if (! vrf_bitmap_check (zclient->redist[type], VRF_DEFAULT))
85     return;
86   vrf_bitmap_unset (zclient->redist[type], VRF_DEFAULT);
87   if (zclient->sock > 0)
88     zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type,
89                              VRF_DEFAULT);
90 }
91
92 /* Inteface addition message from zebra. */
93 static int
94 ospf6_zebra_if_add (int command, struct zclient *zclient, zebra_size_t length,
95     vrf_id_t vrf_id)
96 {
97   struct interface *ifp;
98
99   ifp = zebra_interface_add_read (zclient->ibuf, vrf_id);
100   if (IS_OSPF6_DEBUG_ZEBRA (RECV))
101     zlog_debug ("Zebra Interface add: %s index %d mtu %d",
102                 ifp->name, ifp->ifindex, ifp->mtu6);
103   ospf6_interface_if_add (ifp);
104   return 0;
105 }
106
107 static int
108 ospf6_zebra_if_del (int command, struct zclient *zclient, zebra_size_t length,
109     vrf_id_t vrf_id)
110 {
111   struct interface *ifp;
112
113   if (!(ifp = zebra_interface_state_read (zclient->ibuf, vrf_id)))
114     return 0;
115
116   if (if_is_up (ifp))
117     zlog_warn ("Zebra: got delete of %s, but interface is still up", ifp->name);
118
119   if (IS_OSPF6_DEBUG_ZEBRA (RECV))
120     zlog_debug ("Zebra Interface delete: %s index %d mtu %d",
121                 ifp->name, ifp->ifindex, ifp->mtu6);
122
123   ifp->ifindex = IFINDEX_INTERNAL;
124   return 0;
125 }
126
127 static int
128 ospf6_zebra_if_state_update (int command, struct zclient *zclient,
129                              zebra_size_t length, vrf_id_t vrf_id)
130 {
131   struct interface *ifp;
132
133   ifp = zebra_interface_state_read (zclient->ibuf, vrf_id);
134   if (ifp == NULL)
135     return 0;
136   
137   if (IS_OSPF6_DEBUG_ZEBRA (RECV))
138     zlog_debug ("Zebra Interface state change: "
139                 "%s index %d flags %llx metric %d mtu %d bandwidth %d",
140                 ifp->name, ifp->ifindex, (unsigned long long)ifp->flags, 
141                 ifp->metric, ifp->mtu6, ifp->bandwidth);
142
143   ospf6_interface_state_update (ifp);
144   return 0;
145 }
146
147 static int
148 ospf6_zebra_if_address_update_add (int command, struct zclient *zclient,
149                                    zebra_size_t length, vrf_id_t vrf_id)
150 {
151   struct connected *c;
152   char buf[128];
153
154   c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD, zclient->ibuf,
155                                     vrf_id);
156   if (c == NULL)
157     return 0;
158
159   if (IS_OSPF6_DEBUG_ZEBRA (RECV))
160     zlog_debug ("Zebra Interface address add: %s %5s %s/%d",
161                 c->ifp->name, prefix_family_str (c->address),
162                 inet_ntop (c->address->family, &c->address->u.prefix,
163                            buf, sizeof (buf)), c->address->prefixlen);
164
165   if (c->address->family == AF_INET6)
166     {
167       ospf6_interface_state_update (c->ifp);
168       ospf6_interface_connected_route_update (c->ifp);
169     }
170   return 0;
171 }
172
173 static int
174 ospf6_zebra_if_address_update_delete (int command, struct zclient *zclient,
175                                zebra_size_t length, vrf_id_t vrf_id)
176 {
177   struct connected *c;
178   char buf[128];
179
180   c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE, zclient->ibuf,
181                                     vrf_id);
182   if (c == NULL)
183     return 0;
184
185   if (IS_OSPF6_DEBUG_ZEBRA (RECV))
186     zlog_debug ("Zebra Interface address delete: %s %5s %s/%d",
187                 c->ifp->name, prefix_family_str (c->address),
188                 inet_ntop (c->address->family, &c->address->u.prefix,
189                            buf, sizeof (buf)), c->address->prefixlen);
190
191   if (c->address->family == AF_INET6)
192     {
193       ospf6_interface_connected_route_update (c->ifp);
194       ospf6_interface_state_update (c->ifp);
195     }
196
197   return 0;
198 }
199
200 static int
201 ospf6_zebra_read_ipv6 (int command, struct zclient *zclient,
202                        zebra_size_t length, vrf_id_t vrf_id)
203 {
204   struct stream *s;
205   struct zapi_ipv6 api;
206   unsigned long ifindex;
207   struct prefix_ipv6 p;
208   struct in6_addr *nexthop;
209   unsigned char plength = 0;
210
211   s = zclient->ibuf;
212   ifindex = 0;
213   nexthop = NULL;
214   memset (&api, 0, sizeof (api));
215
216   /* Type, flags, message. */
217   api.type = stream_getc (s);
218   api.flags = stream_getc (s);
219   api.message = stream_getc (s);
220
221   /* IPv6 prefix. */
222   memset (&p, 0, sizeof (struct prefix_ipv6));
223   p.family = AF_INET6;
224   plength = stream_getc (s);
225   p.prefixlen = MIN(IPV6_MAX_PREFIXLEN, plength);
226   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
227
228   /* Nexthop, ifindex, distance, metric. */
229   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
230     {
231       api.nexthop_num = stream_getc (s);
232       nexthop = (struct in6_addr *)
233         malloc (api.nexthop_num * sizeof (struct in6_addr));
234       stream_get (nexthop, s, api.nexthop_num * sizeof (struct in6_addr));
235     }
236   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
237     {
238       api.ifindex_num = stream_getc (s);
239       ifindex = stream_getl (s);
240     }
241   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
242     api.distance = stream_getc (s);
243   else
244     api.distance = 0;
245   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
246     api.metric = stream_getl (s);
247   else
248     api.metric = 0;
249
250   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_TAG))
251     api.tag = stream_getl (s);
252   else
253     api.tag = 0;
254
255   if (IS_OSPF6_DEBUG_ZEBRA (RECV))
256     {
257       char prefixstr[128], nexthopstr[128];
258       prefix2str ((struct prefix *)&p, prefixstr, sizeof (prefixstr));
259       if (nexthop)
260         inet_ntop (AF_INET6, nexthop, nexthopstr, sizeof (nexthopstr));
261       else
262         snprintf (nexthopstr, sizeof (nexthopstr), "::");
263
264       zlog_debug ("Zebra Receive route %s: %s %s nexthop %s ifindex %ld tag %u",
265                   (command == ZEBRA_IPV6_ROUTE_ADD ? "add" : "delete"),
266                   zebra_route_string(api.type), prefixstr, nexthopstr, ifindex, api.tag);
267     }
268  
269   if (command == ZEBRA_IPV6_ROUTE_ADD)
270     ospf6_asbr_redistribute_add (api.type, ifindex, (struct prefix *) &p,
271                                  api.nexthop_num, nexthop, api.tag);
272   else
273     ospf6_asbr_redistribute_remove (api.type, ifindex, (struct prefix *) &p);
274
275   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
276     free (nexthop);
277
278   return 0;
279 }
280
281
282
283
284 DEFUN (show_zebra,
285        show_zebra_cmd,
286        "show zebra",
287        SHOW_STR
288        "Zebra information\n")
289 {
290   int i;
291   if (zclient == NULL)
292     {
293       vty_out (vty, "Not connected to zebra%s", VNL);
294       return CMD_SUCCESS;
295     }
296
297   vty_out (vty, "Zebra Infomation%s", VNL);
298   vty_out (vty, "  enable: %d fail: %d%s",
299            zclient->enable, zclient->fail, VNL);
300   vty_out (vty, "  redistribute default: %d%s",
301            vrf_bitmap_check (zclient->default_information, VRF_DEFAULT),
302            VNL);
303   vty_out (vty, "  redistribute:");
304   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
305     {
306       if (vrf_bitmap_check (zclient->redist[i], VRF_DEFAULT))
307         vty_out (vty, " %s", zebra_route_string(i));
308     }
309   vty_out (vty, "%s", VNL);
310   return CMD_SUCCESS;
311 }
312
313 DEFUN (router_zebra,
314        router_zebra_cmd,
315        "router zebra",
316        "Enable a routing process\n"
317        "Make connection to zebra daemon\n")
318 {
319   vty->node = ZEBRA_NODE;
320   zclient->enable = 1;
321   zclient_start (zclient);
322   return CMD_SUCCESS;
323 }
324
325 DEFUN (no_router_zebra,
326        no_router_zebra_cmd,
327        "no router zebra",
328        NO_STR
329        "Configure routing process\n"
330        "Disable connection to zebra daemon\n")
331 {
332   zclient->enable = 0;
333   zclient_stop (zclient);
334   return CMD_SUCCESS;
335 }
336
337 /* Zebra configuration write function. */
338 static int
339 config_write_ospf6_zebra (struct vty *vty)
340 {
341   if (! zclient->enable)
342     {
343       vty_out (vty, "no router zebra%s", VNL);
344       vty_out (vty, "!%s", VNL);
345     }
346   else if (! vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_OSPF6], VRF_DEFAULT))
347     {
348       vty_out (vty, "router zebra%s", VNL);
349       vty_out (vty, " no redistribute ospf6%s", VNL);
350       vty_out (vty, "!%s", VNL);
351     }
352   return 0;
353 }
354
355 /* Zebra node structure. */
356 static struct cmd_node zebra_node =
357 {
358   ZEBRA_NODE,
359   "%s(config-zebra)# ",
360 };
361
362 #define ADD    0
363 #define REM    1
364 static void
365 ospf6_zebra_route_update (int type, struct ospf6_route *request)
366 {
367   struct zapi_ipv6 api;
368   char buf[64];
369   int nhcount;
370   struct in6_addr **nexthops;
371   ifindex_t *ifindexes;
372   int i, ret = 0;
373   struct prefix_ipv6 *dest;
374
375   if (IS_OSPF6_DEBUG_ZEBRA (SEND))
376     {
377       prefix2str (&request->prefix, buf, sizeof (buf));
378       zlog_debug ("Send %s route: %s",
379                   (type == REM ? "remove" : "add"), buf);
380     }
381
382   if (zclient->sock < 0)
383     {
384       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
385         zlog_debug ("  Not connected to Zebra");
386       return;
387     }
388
389   if (request->path.origin.adv_router == ospf6->router_id &&
390       (request->path.type == OSPF6_PATH_TYPE_EXTERNAL1 ||
391        request->path.type == OSPF6_PATH_TYPE_EXTERNAL2))
392     {
393       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
394         zlog_debug ("  Ignore self-originated external route");
395       return;
396     }
397
398   /* If removing is the best path and if there's another path,
399      treat this request as add the secondary path */
400   if (type == REM && ospf6_route_is_best (request) &&
401       request->next && ospf6_route_is_same (request, request->next))
402     {
403       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
404         zlog_debug ("  Best-path removal resulted Sencondary addition");
405       type = ADD;
406       request = request->next;
407     }
408
409   /* Only the best path will be sent to zebra. */
410   if (! ospf6_route_is_best (request))
411     {
412       /* this is not preferred best route, ignore */
413       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
414         zlog_debug ("  Ignore non-best route");
415       return;
416     }
417
418   nhcount = 0;
419   for (i = 0; i < OSPF6_MULTI_PATH_LIMIT; i++)
420     if (ospf6_nexthop_is_set (&request->nexthop[i]))
421       nhcount++;
422
423   if (nhcount == 0)
424     {
425       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
426         zlog_debug ("  No nexthop, ignore");
427       return;
428     }
429
430   /* allocate memory for nexthop_list */
431   nexthops = XCALLOC (MTYPE_OSPF6_OTHER,
432                       nhcount * sizeof (struct in6_addr *));
433   if (nexthops == NULL)
434     {
435       zlog_warn ("Can't send route to zebra: malloc failed");
436       return;
437     }
438
439   /* allocate memory for ifindex_list */
440   ifindexes = XCALLOC (MTYPE_OSPF6_OTHER,
441                        nhcount * sizeof (unsigned int));
442   if (ifindexes == NULL)
443     {
444       zlog_warn ("Can't send route to zebra: malloc failed");
445       XFREE (MTYPE_OSPF6_OTHER, nexthops);
446       return;
447     }
448
449   for (i = 0; i < nhcount; i++)
450     {
451       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
452         {
453           const char *ifname;
454           inet_ntop (AF_INET6, &request->nexthop[i].address,
455                      buf, sizeof (buf));
456           ifname = ifindex2ifname (request->nexthop[i].ifindex);
457           zlog_debug ("  nexthop: %s%%%.*s(%d)", buf, IFNAMSIZ, ifname,
458                       request->nexthop[i].ifindex);
459         }
460       nexthops[i] = &request->nexthop[i].address;
461       ifindexes[i] = request->nexthop[i].ifindex;
462     }
463
464   api.vrf_id = VRF_DEFAULT;
465   api.type = ZEBRA_ROUTE_OSPF6;
466   api.flags = 0;
467   api.message = 0;
468   api.safi = SAFI_UNICAST;
469   SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
470   api.nexthop_num = nhcount;
471   api.nexthop = nexthops;
472   SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
473   api.ifindex_num = nhcount;
474   api.ifindex = ifindexes;
475   SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
476   api.metric = (request->path.metric_type == 2 ?
477                 request->path.cost_e2 : request->path.cost);
478   if (request->path.tag)
479     {
480       SET_FLAG (api.message, ZAPI_MESSAGE_TAG);
481       api.tag = request->path.tag;
482     }
483   
484   dest = (struct prefix_ipv6 *) &request->prefix;
485   if (type == REM)
486     ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, dest, &api);
487   else
488     ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, dest, &api);
489
490   if (ret < 0)
491     zlog_err ("zapi_ipv6_route() %s failed: %s",
492               (type == REM ? "delete" : "add"), safe_strerror (errno));
493
494   XFREE (MTYPE_OSPF6_OTHER, nexthops);
495   XFREE (MTYPE_OSPF6_OTHER, ifindexes);
496
497   return;
498 }
499
500 void
501 ospf6_zebra_route_update_add (struct ospf6_route *request)
502 {
503   if (! vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_OSPF6], VRF_DEFAULT))
504     {
505       ospf6->route_table->hook_add = NULL;
506       ospf6->route_table->hook_remove = NULL;
507       return;
508     }
509   ospf6_zebra_route_update (ADD, request);
510 }
511
512 void
513 ospf6_zebra_route_update_remove (struct ospf6_route *request)
514 {
515   if (! vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_OSPF6], VRF_DEFAULT))
516     {
517       ospf6->route_table->hook_add = NULL;
518       ospf6->route_table->hook_remove = NULL;
519       return;
520     }
521   ospf6_zebra_route_update (REM, request);
522 }
523
524 DEFUN (redistribute_ospf6,
525        redistribute_ospf6_cmd,
526        "redistribute ospf6",
527        "Redistribute control\n"
528        "OSPF6 route\n")
529 {
530   struct ospf6_route *route;
531
532   if (vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_OSPF6], VRF_DEFAULT))
533     return CMD_SUCCESS;
534
535   vrf_bitmap_set (zclient->redist[ZEBRA_ROUTE_OSPF6], VRF_DEFAULT);
536
537   if (ospf6 == NULL)
538     return CMD_SUCCESS;
539
540   /* send ospf6 route to zebra route table */
541   for (route = ospf6_route_head (ospf6->route_table); route;
542        route = ospf6_route_next (route))
543     ospf6_zebra_route_update_add (route);
544
545   ospf6->route_table->hook_add = ospf6_zebra_route_update_add;
546   ospf6->route_table->hook_remove = ospf6_zebra_route_update_remove;
547
548   return CMD_SUCCESS;
549 }
550
551 DEFUN (no_redistribute_ospf6,
552        no_redistribute_ospf6_cmd,
553        "no redistribute ospf6",
554        NO_STR
555        "Redistribute control\n"
556        "OSPF6 route\n")
557 {
558   struct ospf6_route *route;
559
560   if (! vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_OSPF6], VRF_DEFAULT))
561     return CMD_SUCCESS;
562
563   vrf_bitmap_unset (zclient->redist[ZEBRA_ROUTE_OSPF6], VRF_DEFAULT);
564
565   if (ospf6 == NULL)
566     return CMD_SUCCESS;
567
568   ospf6->route_table->hook_add = NULL;
569   ospf6->route_table->hook_remove = NULL;
570
571   /* withdraw ospf6 route from zebra route table */
572   for (route = ospf6_route_head (ospf6->route_table); route;
573        route = ospf6_route_next (route))
574     ospf6_zebra_route_update_remove (route);
575
576   return CMD_SUCCESS;
577 }
578
579 static void
580 ospf6_zebra_connected (struct zclient *zclient)
581 {
582   zclient_send_requests (zclient, VRF_DEFAULT);
583 }
584
585 static struct ospf6_distance *
586 ospf6_distance_new (void)
587 {
588   return XCALLOC (MTYPE_OSPF6_DISTANCE, sizeof (struct ospf6_distance));
589 }
590
591 static void
592 ospf6_distance_free (struct ospf6_distance *odistance)
593 {
594   XFREE (MTYPE_OSPF6_DISTANCE, odistance);
595 }
596
597 int
598 ospf6_distance_set (struct vty *vty, struct ospf6 *o,
599                     const char *distance_str,
600                     const char *ip_str,
601                     const char *access_list_str)
602 {
603   int ret;
604   struct prefix_ipv6 p;
605   u_char distance;
606   struct route_node *rn;
607   struct ospf6_distance *odistance;
608
609   ret = str2prefix_ipv6 (ip_str, &p);
610   if (ret == 0)
611     {
612       vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
613       return CMD_WARNING;
614     }
615
616   distance = atoi (distance_str);
617
618   /* Get OSPF6 distance node. */
619   rn = route_node_get (o->distance_table, (struct prefix *) &p);
620   if (rn->info)
621     {
622       odistance = rn->info;
623       route_unlock_node (rn);
624     }
625   else
626     {
627       odistance = ospf6_distance_new ();
628       rn->info = odistance;
629     }
630
631   /* Set distance value. */
632   odistance->distance = distance;
633
634   /*Reset access-list configuration. */
635   if (odistance->access_list)
636     {
637       free (odistance->access_list);
638       odistance->access_list = NULL;
639     }
640   if (access_list_str)
641     odistance->access_list = strdup (access_list_str);
642
643   return CMD_SUCCESS;
644 }
645
646 int
647 ospf6_distance_unset (struct vty *vty, struct ospf6 *o,
648                       const char *ip_str,
649                       const char *access_list_str)
650 {
651   int ret;
652   struct prefix_ipv6 p;
653   struct route_node *rn;
654   struct ospf6_distance *odistance;
655
656   ret = str2prefix_ipv6 (ip_str, &p);
657   if (ret == 0)
658     {
659       vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
660       return CMD_WARNING;
661     }
662
663   rn = route_node_lookup (o->distance_table, (struct prefix *) &p);
664   if (!rn)
665     {
666       vty_out (vty, "Cant't find specified prefix%s", VTY_NEWLINE);
667       return CMD_WARNING;
668     }
669
670   odistance = rn->info;
671
672   if (odistance->access_list)
673     free (odistance->access_list);
674   ospf6_distance_free (odistance);
675
676   rn->info = NULL;
677   route_unlock_node (rn);
678   route_unlock_node (rn);
679
680   return CMD_SUCCESS;
681 }
682
683 void
684 ospf6_distance_reset (struct ospf6 *o)
685 {
686   struct route_node *rn;
687   struct ospf6_distance *odistance;
688
689   for (rn = route_top (o->distance_table); rn; rn = route_next (rn))
690     if ((odistance = rn->info) != NULL)
691       {
692         if (odistance->access_list)
693           free (odistance->access_list);
694         ospf6_distance_free (odistance);
695         rn->info = NULL;
696         route_unlock_node (rn);
697       }
698 }
699
700 u_char
701 ospf6_distance_apply (struct ospf6_route *or, struct ospf6 *o)
702 {
703
704   if (o == NULL)
705     return 0;
706
707   if (o->distance_intra)
708     if (or->path.type == OSPF6_PATH_TYPE_INTRA)
709       return o->distance_intra;
710
711   if (o->distance_inter)
712     if (or->path.type == OSPF6_PATH_TYPE_INTER)
713       return o->distance_inter;
714
715   if (o->distance_external)
716     if(or->path.type == OSPF6_PATH_TYPE_EXTERNAL1
717        || or->path.type == OSPF6_PATH_TYPE_EXTERNAL2)
718       return o->distance_external;
719
720   if (o->distance_all)
721     return o->distance_all;
722
723   return 0;
724 }
725
726 void
727 ospf6_zebra_init (struct thread_master *master)
728 {
729   /* Allocate zebra structure. */
730   zclient = zclient_new (master);
731   zclient_init (zclient, ZEBRA_ROUTE_OSPF6);
732   zclient->zebra_connected = ospf6_zebra_connected;
733   zclient->router_id_update = ospf6_router_id_update_zebra;
734   zclient->interface_add = ospf6_zebra_if_add;
735   zclient->interface_delete = ospf6_zebra_if_del;
736   zclient->interface_up = ospf6_zebra_if_state_update;
737   zclient->interface_down = ospf6_zebra_if_state_update;
738   zclient->interface_address_add = ospf6_zebra_if_address_update_add;
739   zclient->interface_address_delete = ospf6_zebra_if_address_update_delete;
740   zclient->ipv4_route_add = NULL;
741   zclient->ipv4_route_delete = NULL;
742   zclient->ipv6_route_add = ospf6_zebra_read_ipv6;
743   zclient->ipv6_route_delete = ospf6_zebra_read_ipv6;
744
745   /* redistribute connected route by default */
746   /* ospf6_zebra_redistribute (ZEBRA_ROUTE_CONNECT); */
747
748   /* Install zebra node. */
749   install_node (&zebra_node, config_write_ospf6_zebra);
750
751   /* Install command element for zebra node. */
752   install_element (VIEW_NODE, &show_zebra_cmd);
753   install_element (CONFIG_NODE, &router_zebra_cmd);
754   install_element (CONFIG_NODE, &no_router_zebra_cmd);
755
756   install_default (ZEBRA_NODE);
757   install_element (ZEBRA_NODE, &redistribute_ospf6_cmd);
758   install_element (ZEBRA_NODE, &no_redistribute_ospf6_cmd);
759
760   return;
761 }
762
763 /* Debug */
764
765 DEFUN (debug_ospf6_zebra_sendrecv,
766        debug_ospf6_zebra_sendrecv_cmd,
767        "debug ospf6 zebra (send|recv)",
768        DEBUG_STR
769        OSPF6_STR
770        "Debug connection between zebra\n"
771        "Debug Sending zebra\n"
772        "Debug Receiving zebra\n"
773       )
774 {
775   unsigned char level = 0;
776
777   if (argc)
778     {
779       if (! strncmp (argv[0], "s", 1))
780         level = OSPF6_DEBUG_ZEBRA_SEND;
781       else if (! strncmp (argv[0], "r", 1))
782         level = OSPF6_DEBUG_ZEBRA_RECV;
783     }
784   else
785     level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
786
787   OSPF6_DEBUG_ZEBRA_ON (level);
788   return CMD_SUCCESS;
789 }
790
791 ALIAS (debug_ospf6_zebra_sendrecv,
792        debug_ospf6_zebra_cmd,
793        "debug ospf6 zebra",
794        DEBUG_STR
795        OSPF6_STR
796        "Debug connection between zebra\n"
797       )
798
799
800 DEFUN (no_debug_ospf6_zebra_sendrecv,
801        no_debug_ospf6_zebra_sendrecv_cmd,
802        "no debug ospf6 zebra (send|recv)",
803        NO_STR
804        DEBUG_STR
805        OSPF6_STR
806        "Debug connection between zebra\n"
807        "Debug Sending zebra\n"
808        "Debug Receiving zebra\n"
809       )
810 {
811   unsigned char level = 0;
812
813   if (argc)
814     {
815       if (! strncmp (argv[0], "s", 1))
816         level = OSPF6_DEBUG_ZEBRA_SEND;
817       else if (! strncmp (argv[0], "r", 1))
818         level = OSPF6_DEBUG_ZEBRA_RECV;
819     }
820   else
821     level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
822
823   OSPF6_DEBUG_ZEBRA_OFF (level);
824   return CMD_SUCCESS;
825 }
826
827 ALIAS (no_debug_ospf6_zebra_sendrecv,
828        no_debug_ospf6_zebra_cmd,
829        "no debug ospf6 zebra",
830        NO_STR
831        DEBUG_STR
832        OSPF6_STR
833        "Debug connection between zebra\n"
834       )
835
836 int
837 config_write_ospf6_debug_zebra (struct vty *vty)
838 {
839   if (IS_OSPF6_DEBUG_ZEBRA (SEND) && IS_OSPF6_DEBUG_ZEBRA (RECV))
840     vty_out (vty, "debug ospf6 zebra%s", VNL);
841   else
842     {
843       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
844         vty_out (vty, "debug ospf6 zebra send%s", VNL);
845       if (IS_OSPF6_DEBUG_ZEBRA (RECV))
846         vty_out (vty, "debug ospf6 zebra recv%s", VNL);
847     }
848   return 0;
849 }
850
851 void
852 install_element_ospf6_debug_zebra (void)
853 {
854   install_element (ENABLE_NODE, &debug_ospf6_zebra_cmd);
855   install_element (ENABLE_NODE, &no_debug_ospf6_zebra_cmd);
856   install_element (ENABLE_NODE, &debug_ospf6_zebra_sendrecv_cmd);
857   install_element (ENABLE_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
858   install_element (CONFIG_NODE, &debug_ospf6_zebra_cmd);
859   install_element (CONFIG_NODE, &no_debug_ospf6_zebra_cmd);
860   install_element (CONFIG_NODE, &debug_ospf6_zebra_sendrecv_cmd);
861   install_element (CONFIG_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
862 }
863
864