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
42unsigned char conf_debug_ospf6_zebra = 0;
43
44/* information about zebra. */
45struct zclient *zclient = NULL;
46
47struct in_addr router_id_zebra;
48
49/* Router-id update message from zebra. */
50static int
51ospf6_router_id_update_zebra (int command, struct zclient *zclient,
52			      zebra_size_t length)
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 */
70void
71ospf6_zebra_redistribute (int type)
72{
73  if (zclient->redist[type])
74    return;
75  zclient->redist[type] = 1;
76  if (zclient->sock > 0)
77    zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
78}
79
80void
81ospf6_zebra_no_redistribute (int type)
82{
83  if (! zclient->redist[type])
84    return;
85  zclient->redist[type] = 0;
86  if (zclient->sock > 0)
87    zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
88}
89
90/* Inteface addition message from zebra. */
91static int
92ospf6_zebra_if_add (int command, struct zclient *zclient, zebra_size_t length)
93{
94  struct interface *ifp;
95
96  ifp = zebra_interface_add_read (zclient->ibuf);
97  if (IS_OSPF6_DEBUG_ZEBRA (RECV))
98    zlog_debug ("Zebra Interface add: %s index %d mtu %d",
99		ifp->name, ifp->ifindex, ifp->mtu6);
100  ospf6_interface_if_add (ifp);
101  return 0;
102}
103
104static int
105ospf6_zebra_if_del (int command, struct zclient *zclient, zebra_size_t length)
106{
107  struct interface *ifp;
108
109  if (!(ifp = zebra_interface_state_read(zclient->ibuf)))
110    return 0;
111
112  if (if_is_up (ifp))
113    zlog_warn ("Zebra: got delete of %s, but interface is still up", ifp->name);
114
115  if (IS_OSPF6_DEBUG_ZEBRA (RECV))
116    zlog_debug ("Zebra Interface delete: %s index %d mtu %d",
117		ifp->name, ifp->ifindex, ifp->mtu6);
118
119#if 0
120  /* XXX: ospf6_interface_if_del is not the right way to handle this,
121   * because among other thinkable issues, it will also clear all
122   * settings as they are contained in the struct ospf6_interface. */
123  ospf6_interface_if_del (ifp);
124#endif /*0*/
125
126  ifp->ifindex = IFINDEX_INTERNAL;
127  return 0;
128}
129
130static int
131ospf6_zebra_if_state_update (int command, struct zclient *zclient,
132                             zebra_size_t length)
133{
134  struct interface *ifp;
135
136  ifp = zebra_interface_state_read (zclient->ibuf);
137  if (ifp == NULL)
138    return 0;
139
140  if (IS_OSPF6_DEBUG_ZEBRA (RECV))
141    zlog_debug ("Zebra Interface state change: "
142                "%s index %d flags %llx metric %d mtu %d bandwidth %d",
143		ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
144		ifp->metric, ifp->mtu6, ifp->bandwidth);
145
146  ospf6_interface_state_update (ifp);
147  return 0;
148}
149
150static int
151ospf6_zebra_if_address_update_add (int command, struct zclient *zclient,
152                                   zebra_size_t length)
153{
154  struct connected *c;
155  char buf[128];
156
157  c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD, zclient->ibuf);
158  if (c == NULL)
159    return 0;
160
161  if (IS_OSPF6_DEBUG_ZEBRA (RECV))
162    zlog_debug ("Zebra Interface address add: %s %5s %s/%d",
163		c->ifp->name, prefix_family_str (c->address),
164		inet_ntop (c->address->family, &c->address->u.prefix,
165			   buf, sizeof (buf)), c->address->prefixlen);
166
167  if (c->address->family == AF_INET6)
168    {
169      ospf6_interface_state_update (c->ifp);
170      ospf6_interface_connected_route_update (c->ifp);
171    }
172  return 0;
173}
174
175static int
176ospf6_zebra_if_address_update_delete (int command, struct zclient *zclient,
177                               zebra_size_t length)
178{
179  struct connected *c;
180  char buf[128];
181
182  c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE, zclient->ibuf);
183  if (c == NULL)
184    return 0;
185
186  if (IS_OSPF6_DEBUG_ZEBRA (RECV))
187    zlog_debug ("Zebra Interface address delete: %s %5s %s/%d",
188		c->ifp->name, prefix_family_str (c->address),
189		inet_ntop (c->address->family, &c->address->u.prefix,
190			   buf, sizeof (buf)), c->address->prefixlen);
191
192  if (c->address->family == AF_INET6)
193    {
194      ospf6_interface_connected_route_update (c->ifp);
195      ospf6_interface_state_update (c->ifp);
196    }
197
198  return 0;
199}
200
201static int
202ospf6_zebra_read_ipv6 (int command, struct zclient *zclient,
203                       zebra_size_t length)
204{
205  struct stream *s;
206  struct zapi_ipv6 api;
207  unsigned long ifindex;
208  struct prefix_ipv6 p;
209  struct in6_addr *nexthop;
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  p.prefixlen = stream_getc (s);
225  stream_get (&p.prefix, s, PSIZE (p.prefixlen));
226
227  /* Nexthop, ifindex, distance, metric. */
228  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
229    {
230      api.nexthop_num = stream_getc (s);
231      nexthop = (struct in6_addr *)
232        malloc (api.nexthop_num * sizeof (struct in6_addr));
233      stream_get (nexthop, s, api.nexthop_num * sizeof (struct in6_addr));
234    }
235  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
236    {
237      api.ifindex_num = stream_getc (s);
238      ifindex = stream_getl (s);
239    }
240  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
241    api.distance = stream_getc (s);
242  else
243    api.distance = 0;
244  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
245    api.metric = stream_getl (s);
246  else
247    api.metric = 0;
248
249  if (IS_OSPF6_DEBUG_ZEBRA (RECV))
250    {
251      char prefixstr[128], nexthopstr[128];
252      prefix2str ((struct prefix *)&p, prefixstr, sizeof (prefixstr));
253      if (nexthop)
254        inet_ntop (AF_INET6, nexthop, nexthopstr, sizeof (nexthopstr));
255      else
256        snprintf (nexthopstr, sizeof (nexthopstr), "::");
257
258      zlog_debug ("Zebra Receive route %s: %s %s nexthop %s ifindex %ld",
259		  (command == ZEBRA_IPV6_ROUTE_ADD ? "add" : "delete"),
260		  zebra_route_string(api.type), prefixstr, nexthopstr, ifindex);
261    }
262
263  if (command == ZEBRA_IPV6_ROUTE_ADD)
264    ospf6_asbr_redistribute_add (api.type, ifindex, (struct prefix *) &p,
265                                 api.nexthop_num, nexthop);
266  else
267    ospf6_asbr_redistribute_remove (api.type, ifindex, (struct prefix *) &p);
268
269  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
270    free (nexthop);
271
272  return 0;
273}
274
275
276
277
278DEFUN (show_zebra,
279       show_zebra_cmd,
280       "show zebra",
281       SHOW_STR
282       "Zebra information\n")
283{
284  int i;
285  if (zclient == NULL)
286    {
287      vty_out (vty, "Not connected to zebra%s", VNL);
288      return CMD_SUCCESS;
289    }
290
291  vty_out (vty, "Zebra Infomation%s", VNL);
292  vty_out (vty, "  enable: %d fail: %d%s",
293           zclient->enable, zclient->fail, VNL);
294  vty_out (vty, "  redistribute default: %d%s", zclient->redist_default,
295           VNL);
296  vty_out (vty, "  redistribute:");
297  for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
298    {
299      if (zclient->redist[i])
300        vty_out (vty, " %s", zebra_route_string(i));
301    }
302  vty_out (vty, "%s", VNL);
303  return CMD_SUCCESS;
304}
305
306DEFUN (router_zebra,
307       router_zebra_cmd,
308       "router zebra",
309       "Enable a routing process\n"
310       "Make connection to zebra daemon\n")
311{
312  vty->node = ZEBRA_NODE;
313  zclient->enable = 1;
314  zclient_start (zclient);
315  return CMD_SUCCESS;
316}
317
318DEFUN (no_router_zebra,
319       no_router_zebra_cmd,
320       "no router zebra",
321       NO_STR
322       "Configure routing process\n"
323       "Disable connection to zebra daemon\n")
324{
325  zclient->enable = 0;
326  zclient_stop (zclient);
327  return CMD_SUCCESS;
328}
329
330/* Zebra configuration write function. */
331static int
332config_write_ospf6_zebra (struct vty *vty)
333{
334  if (! zclient->enable)
335    {
336      vty_out (vty, "no router zebra%s", VNL);
337      vty_out (vty, "!%s", VNL);
338    }
339  else if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
340    {
341      vty_out (vty, "router zebra%s", VNL);
342      vty_out (vty, " no redistribute ospf6%s", VNL);
343      vty_out (vty, "!%s", VNL);
344    }
345  return 0;
346}
347
348/* Zebra node structure. */
349static struct cmd_node zebra_node =
350{
351  ZEBRA_NODE,
352  "%s(config-zebra)# ",
353};
354
355#define ADD    0
356#define REM    1
357static void
358ospf6_zebra_route_update (int type, struct ospf6_route *request)
359{
360  struct zapi_ipv6 api;
361  char buf[64];
362  int nhcount;
363  struct in6_addr **nexthops;
364  unsigned int *ifindexes;
365  int i, ret = 0;
366  struct prefix_ipv6 *dest;
367
368  if (IS_OSPF6_DEBUG_ZEBRA (SEND))
369    {
370      prefix2str (&request->prefix, buf, sizeof (buf));
371      zlog_debug ("Send %s route: %s",
372		  (type == REM ? "remove" : "add"), buf);
373    }
374
375  if (zclient->sock < 0)
376    {
377      if (IS_OSPF6_DEBUG_ZEBRA (SEND))
378        zlog_debug ("  Not connected to Zebra");
379      return;
380    }
381
382  if (request->path.origin.adv_router == ospf6->router_id &&
383      (request->path.type == OSPF6_PATH_TYPE_EXTERNAL1 ||
384       request->path.type == OSPF6_PATH_TYPE_EXTERNAL2))
385    {
386      if (IS_OSPF6_DEBUG_ZEBRA (SEND))
387        zlog_debug ("  Ignore self-originated external route");
388      return;
389    }
390
391  /* If removing is the best path and if there's another path,
392     treat this request as add the secondary path */
393  if (type == REM && ospf6_route_is_best (request) &&
394      request->next && ospf6_route_is_same (request, request->next))
395    {
396      if (IS_OSPF6_DEBUG_ZEBRA (SEND))
397        zlog_debug ("  Best-path removal resulted Sencondary addition");
398      type = ADD;
399      request = request->next;
400    }
401
402  /* Only the best path will be sent to zebra. */
403  if (! ospf6_route_is_best (request))
404    {
405      /* this is not preferred best route, ignore */
406      if (IS_OSPF6_DEBUG_ZEBRA (SEND))
407        zlog_debug ("  Ignore non-best route");
408      return;
409    }
410
411  nhcount = 0;
412  for (i = 0; i < OSPF6_MULTI_PATH_LIMIT; i++)
413    if (ospf6_nexthop_is_set (&request->nexthop[i]))
414      nhcount++;
415
416  if (nhcount == 0)
417    {
418      if (IS_OSPF6_DEBUG_ZEBRA (SEND))
419        zlog_debug ("  No nexthop, ignore");
420      return;
421    }
422
423  /* allocate memory for nexthop_list */
424  nexthops = XCALLOC (MTYPE_OSPF6_OTHER,
425                      nhcount * sizeof (struct in6_addr *));
426  if (nexthops == NULL)
427    {
428      zlog_warn ("Can't send route to zebra: malloc failed");
429      return;
430    }
431
432  /* allocate memory for ifindex_list */
433  ifindexes = XCALLOC (MTYPE_OSPF6_OTHER,
434                       nhcount * sizeof (unsigned int));
435  if (ifindexes == NULL)
436    {
437      zlog_warn ("Can't send route to zebra: malloc failed");
438      XFREE (MTYPE_OSPF6_OTHER, nexthops);
439      return;
440    }
441
442  for (i = 0; i < nhcount; i++)
443    {
444      if (IS_OSPF6_DEBUG_ZEBRA (SEND))
445	{
446	  char ifname[IFNAMSIZ];
447	  inet_ntop (AF_INET6, &request->nexthop[i].address,
448		     buf, sizeof (buf));
449	  if (!if_indextoname(request->nexthop[i].ifindex, ifname))
450	    strlcpy(ifname, "unknown", sizeof(ifname));
451	  zlog_debug ("  nexthop: %s%%%.*s(%d)", buf, IFNAMSIZ, ifname,
452		      request->nexthop[i].ifindex);
453	}
454      nexthops[i] = &request->nexthop[i].address;
455      ifindexes[i] = request->nexthop[i].ifindex;
456    }
457
458  api.type = ZEBRA_ROUTE_OSPF6;
459  api.flags = 0;
460  api.message = 0;
461  api.safi = SAFI_UNICAST;
462  SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
463  api.nexthop_num = nhcount;
464  api.nexthop = nexthops;
465  SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
466  api.ifindex_num = nhcount;
467  api.ifindex = ifindexes;
468  SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
469  api.metric = (request->path.metric_type == 2 ?
470                request->path.cost_e2 : request->path.cost);
471
472  dest = (struct prefix_ipv6 *) &request->prefix;
473  if (type == REM)
474    ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, dest, &api);
475  else
476    ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, dest, &api);
477
478  if (ret < 0)
479    zlog_err ("zapi_ipv6_route() %s failed: %s",
480              (type == REM ? "delete" : "add"), safe_strerror (errno));
481
482  XFREE (MTYPE_OSPF6_OTHER, nexthops);
483  XFREE (MTYPE_OSPF6_OTHER, ifindexes);
484
485  return;
486}
487
488void
489ospf6_zebra_route_update_add (struct ospf6_route *request)
490{
491  if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
492    {
493      ospf6->route_table->hook_add = NULL;
494      ospf6->route_table->hook_remove = NULL;
495      return;
496    }
497  ospf6_zebra_route_update (ADD, request);
498}
499
500void
501ospf6_zebra_route_update_remove (struct ospf6_route *request)
502{
503  if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
504    {
505      ospf6->route_table->hook_add = NULL;
506      ospf6->route_table->hook_remove = NULL;
507      return;
508    }
509  ospf6_zebra_route_update (REM, request);
510}
511
512DEFUN (redistribute_ospf6,
513       redistribute_ospf6_cmd,
514       "redistribute ospf6",
515       "Redistribute control\n"
516       "OSPF6 route\n")
517{
518  struct ospf6_route *route;
519
520  if (zclient->redist[ZEBRA_ROUTE_OSPF6])
521    return CMD_SUCCESS;
522
523  zclient->redist[ZEBRA_ROUTE_OSPF6] = 1;
524
525  if (ospf6 == NULL)
526    return CMD_SUCCESS;
527
528  /* send ospf6 route to zebra route table */
529  for (route = ospf6_route_head (ospf6->route_table); route;
530       route = ospf6_route_next (route))
531    ospf6_zebra_route_update_add (route);
532
533  ospf6->route_table->hook_add = ospf6_zebra_route_update_add;
534  ospf6->route_table->hook_remove = ospf6_zebra_route_update_remove;
535
536  return CMD_SUCCESS;
537}
538
539DEFUN (no_redistribute_ospf6,
540       no_redistribute_ospf6_cmd,
541       "no redistribute ospf6",
542       NO_STR
543       "Redistribute control\n"
544       "OSPF6 route\n")
545{
546  struct ospf6_route *route;
547
548  if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
549    return CMD_SUCCESS;
550
551  zclient->redist[ZEBRA_ROUTE_OSPF6] = 0;
552
553  if (ospf6 == NULL)
554    return CMD_SUCCESS;
555
556  ospf6->route_table->hook_add = NULL;
557  ospf6->route_table->hook_remove = NULL;
558
559  /* withdraw ospf6 route from zebra route table */
560  for (route = ospf6_route_head (ospf6->route_table); route;
561       route = ospf6_route_next (route))
562    ospf6_zebra_route_update_remove (route);
563
564  return CMD_SUCCESS;
565}
566
567void
568ospf6_zebra_init (void)
569{
570  /* Allocate zebra structure. */
571  zclient = zclient_new ();
572  zclient_init (zclient, ZEBRA_ROUTE_OSPF6);
573  zclient->router_id_update = ospf6_router_id_update_zebra;
574  zclient->interface_add = ospf6_zebra_if_add;
575  zclient->interface_delete = ospf6_zebra_if_del;
576  zclient->interface_up = ospf6_zebra_if_state_update;
577  zclient->interface_down = ospf6_zebra_if_state_update;
578  zclient->interface_address_add = ospf6_zebra_if_address_update_add;
579  zclient->interface_address_delete = ospf6_zebra_if_address_update_delete;
580  zclient->ipv4_route_add = NULL;
581  zclient->ipv4_route_delete = NULL;
582  zclient->ipv6_route_add = ospf6_zebra_read_ipv6;
583  zclient->ipv6_route_delete = ospf6_zebra_read_ipv6;
584
585  /* redistribute connected route by default */
586  /* ospf6_zebra_redistribute (ZEBRA_ROUTE_CONNECT); */
587
588  /* Install zebra node. */
589  install_node (&zebra_node, config_write_ospf6_zebra);
590
591  /* Install command element for zebra node. */
592  install_element (VIEW_NODE, &show_zebra_cmd);
593  install_element (ENABLE_NODE, &show_zebra_cmd);
594  install_element (CONFIG_NODE, &router_zebra_cmd);
595  install_element (CONFIG_NODE, &no_router_zebra_cmd);
596
597  install_default (ZEBRA_NODE);
598  install_element (ZEBRA_NODE, &redistribute_ospf6_cmd);
599  install_element (ZEBRA_NODE, &no_redistribute_ospf6_cmd);
600
601  return;
602}
603
604/* Debug */
605
606DEFUN (debug_ospf6_zebra_sendrecv,
607       debug_ospf6_zebra_sendrecv_cmd,
608       "debug ospf6 zebra (send|recv)",
609       DEBUG_STR
610       OSPF6_STR
611       "Debug connection between zebra\n"
612       "Debug Sending zebra\n"
613       "Debug Receiving zebra\n"
614      )
615{
616  unsigned char level = 0;
617
618  if (argc)
619    {
620      if (! strncmp (argv[0], "s", 1))
621        level = OSPF6_DEBUG_ZEBRA_SEND;
622      else if (! strncmp (argv[0], "r", 1))
623        level = OSPF6_DEBUG_ZEBRA_RECV;
624    }
625  else
626    level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
627
628  OSPF6_DEBUG_ZEBRA_ON (level);
629  return CMD_SUCCESS;
630}
631
632ALIAS (debug_ospf6_zebra_sendrecv,
633       debug_ospf6_zebra_cmd,
634       "debug ospf6 zebra",
635       DEBUG_STR
636       OSPF6_STR
637       "Debug connection between zebra\n"
638      )
639
640
641DEFUN (no_debug_ospf6_zebra_sendrecv,
642       no_debug_ospf6_zebra_sendrecv_cmd,
643       "no debug ospf6 zebra (send|recv)",
644       NO_STR
645       DEBUG_STR
646       OSPF6_STR
647       "Debug connection between zebra\n"
648       "Debug Sending zebra\n"
649       "Debug Receiving zebra\n"
650      )
651{
652  unsigned char level = 0;
653
654  if (argc)
655    {
656      if (! strncmp (argv[0], "s", 1))
657        level = OSPF6_DEBUG_ZEBRA_SEND;
658      else if (! strncmp (argv[0], "r", 1))
659        level = OSPF6_DEBUG_ZEBRA_RECV;
660    }
661  else
662    level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
663
664  OSPF6_DEBUG_ZEBRA_OFF (level);
665  return CMD_SUCCESS;
666}
667
668ALIAS (no_debug_ospf6_zebra_sendrecv,
669       no_debug_ospf6_zebra_cmd,
670       "no debug ospf6 zebra",
671       NO_STR
672       DEBUG_STR
673       OSPF6_STR
674       "Debug connection between zebra\n"
675      )
676
677int
678config_write_ospf6_debug_zebra (struct vty *vty)
679{
680  if (IS_OSPF6_DEBUG_ZEBRA (SEND) && IS_OSPF6_DEBUG_ZEBRA (RECV))
681    vty_out (vty, "debug ospf6 zebra%s", VNL);
682  else
683    {
684      if (IS_OSPF6_DEBUG_ZEBRA (SEND))
685        vty_out (vty, "debug ospf6 zebra send%s", VNL);
686      if (IS_OSPF6_DEBUG_ZEBRA (RECV))
687        vty_out (vty, "debug ospf6 zebra recv%s", VNL);
688    }
689  return 0;
690}
691
692void
693install_element_ospf6_debug_zebra (void)
694{
695  install_element (ENABLE_NODE, &debug_ospf6_zebra_cmd);
696  install_element (ENABLE_NODE, &no_debug_ospf6_zebra_cmd);
697  install_element (ENABLE_NODE, &debug_ospf6_zebra_sendrecv_cmd);
698  install_element (ENABLE_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
699  install_element (CONFIG_NODE, &debug_ospf6_zebra_cmd);
700  install_element (CONFIG_NODE, &no_debug_ospf6_zebra_cmd);
701  install_element (CONFIG_NODE, &debug_ospf6_zebra_sendrecv_cmd);
702  install_element (CONFIG_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
703}
704
705
706