← Back to branch summary

~ubuntu-branches/ubuntu/breezy/quagga/breezy-security

« back to all changes in this revision

Viewing changes to ospf6d/ospf6_zebra.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Mueller
  • Date: 2005-05-20 13:16:12 UTC
  • Revision ID: james.westby@ubuntu.com-20050520131612-pr6paalox60o3x3n
Tags: upstream-0.99.1
Import upstream version 0.99.1

Show diffs side-by-side

added added

removed removed

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