]>
Commit | Line | Data |
---|---|---|
7c551956 DS |
1 | /* |
2 | * Copyright (C) 2016 CumulusNetworks | |
3 | * Donald Sharp | |
4 | * | |
5 | * This file is part of Quagga | |
6 | * | |
7 | * Quagga is free software; you can redistribute it and/or modify it | |
8 | * under the terms of the GNU General Public License as published by the | |
9 | * Free Software Foundation; either version 2, or (at your option) any | |
10 | * later version. | |
11 | * | |
12 | * Quagga is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with GNU Zebra; see the file COPYING. If not, write to the Free | |
19 | * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA | |
20 | * 02111-1307, USA. | |
21 | */ | |
22 | #include <zebra.h> | |
23 | ||
24 | #include "log.h" | |
25 | #include "linklist.h" | |
f30c50b9 | 26 | #include "command.h" |
4a1ab8e4 | 27 | #include "memory.h" |
05737783 | 28 | #include "srcdest_table.h" |
7c551956 | 29 | |
82f97584 | 30 | #include "vty.h" |
7c551956 DS |
31 | #include "zebra/debug.h" |
32 | #include "zebra/zserv.h" | |
33 | #include "zebra/rib.h" | |
34 | #include "zebra/zebra_vrf.h" | |
5a8dfcd8 | 35 | #include "zebra/zebra_rnh.h" |
7c551956 | 36 | #include "zebra/router-id.h" |
4a1ab8e4 | 37 | #include "zebra/zebra_memory.h" |
28f6dde8 | 38 | #include "zebra/zebra_static.h" |
5a8dfcd8 | 39 | #include "zebra/interface.h" |
7758e3f3 | 40 | #include "zebra/zebra_mpls.h" |
7c551956 DS |
41 | |
42 | extern struct zebra_t zebrad; | |
43 | ||
44 | /* VRF information update. */ | |
45 | static void | |
46 | zebra_vrf_add_update (struct zebra_vrf *zvrf) | |
47 | { | |
48 | struct listnode *node, *nnode; | |
49 | struct zserv *client; | |
50 | ||
51 | if (IS_ZEBRA_DEBUG_EVENT) | |
661512bf | 52 | zlog_debug ("MESSAGE: ZEBRA_VRF_ADD %s", zvrf_name (zvrf)); |
7c551956 DS |
53 | |
54 | for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client)) | |
55 | zsend_vrf_add (client, zvrf); | |
56 | } | |
57 | ||
58 | static void | |
59 | zebra_vrf_delete_update (struct zebra_vrf *zvrf) | |
60 | { | |
61 | struct listnode *node, *nnode; | |
62 | struct zserv *client; | |
63 | ||
64 | if (IS_ZEBRA_DEBUG_EVENT) | |
661512bf | 65 | zlog_debug ("MESSAGE: ZEBRA_VRF_DELETE %s", zvrf_name (zvrf)); |
7c551956 DS |
66 | |
67 | for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client)) | |
68 | zsend_vrf_delete (client, zvrf); | |
69 | } | |
70 | ||
71 | void | |
72 | zebra_vrf_update_all (struct zserv *client) | |
73 | { | |
74 | struct vrf *vrf; | |
7c551956 | 75 | |
1a1a7065 | 76 | RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) |
7c551956 | 77 | { |
1a1a7065 | 78 | if (vrf->vrf_id) |
7c551956 DS |
79 | zsend_vrf_add (client, vrf_info_lookup (vrf->vrf_id)); |
80 | } | |
81 | } | |
82 | ||
83 | /* Callback upon creating a new VRF. */ | |
84 | static int | |
661512bf | 85 | zebra_vrf_new (struct vrf *vrf) |
7c551956 | 86 | { |
661512bf | 87 | struct zebra_vrf *zvrf; |
7c551956 | 88 | |
3f6d6a5d | 89 | if (IS_ZEBRA_DEBUG_EVENT) |
661512bf | 90 | zlog_info ("ZVRF %s with id %u", vrf->name, vrf->vrf_id); |
7c551956 | 91 | |
661512bf RW |
92 | zvrf = zebra_vrf_alloc (); |
93 | zvrf->zns = zebra_ns_lookup (NS_DEFAULT); /* Point to the global (single) NS */ | |
94 | router_id_init (zvrf); | |
95 | vrf->info = zvrf; | |
96 | zvrf->vrf = vrf; | |
34f8e6af | 97 | |
7c551956 DS |
98 | return 0; |
99 | } | |
100 | ||
fb148af4 DS |
101 | /* |
102 | * Moving an interface amongst different vrf's | |
103 | * causes the interface to get a new ifindex | |
104 | * so we need to find static routes with | |
105 | * the old ifindex and replace with new | |
106 | * ifindex to insert back into the table | |
107 | */ | |
108 | void | |
109 | zebra_vrf_static_route_interface_fixup (struct interface *ifp) | |
110 | { | |
111 | afi_t afi; | |
112 | safi_t safi; | |
5f3d1bdf | 113 | struct zebra_vrf *zvrf = zebra_vrf_lookup_by_id (ifp->vrf_id); |
fb148af4 DS |
114 | struct route_table *stable = NULL; |
115 | struct route_node *rn = NULL; | |
116 | struct static_route *si = NULL; | |
117 | ||
118 | if (!zvrf) | |
119 | return; | |
120 | ||
121 | for (afi = AFI_IP; afi < AFI_MAX; afi++) | |
122 | { | |
123 | for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++) | |
124 | { | |
125 | stable = zvrf->stable[afi][safi]; | |
126 | if (stable) | |
127 | for (rn = route_top (stable); rn; rn = route_next (rn)) | |
128 | { | |
129 | if (rn->info) | |
130 | { | |
131 | si = rn->info; | |
132 | if ((strcmp (si->ifname, ifp->name) == 0) && | |
133 | (si->ifindex != ifp->ifindex)) | |
134 | { | |
135 | si->ifindex = ifp->ifindex; | |
c423229b | 136 | static_install_route (afi, safi, &rn->p, NULL, si); |
fb148af4 DS |
137 | } |
138 | } | |
139 | } | |
140 | } | |
141 | } | |
142 | ||
143 | } | |
144 | ||
7c551956 DS |
145 | /* Callback upon enabling a VRF. */ |
146 | static int | |
661512bf | 147 | zebra_vrf_enable (struct vrf *vrf) |
7c551956 | 148 | { |
661512bf | 149 | struct zebra_vrf *zvrf = vrf->info; |
2414ffe5 RW |
150 | struct route_table *stable; |
151 | struct route_node *rn; | |
152 | struct static_route *si; | |
153 | struct interface *ifp; | |
fb148af4 DS |
154 | afi_t afi; |
155 | safi_t safi; | |
7c551956 DS |
156 | |
157 | assert (zvrf); | |
158 | ||
159 | zebra_vrf_add_update (zvrf); | |
160 | ||
fb148af4 | 161 | for (afi = AFI_IP; afi < AFI_MAX; afi++) |
2414ffe5 RW |
162 | for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++) |
163 | { | |
164 | stable = zvrf->stable[afi][safi]; | |
165 | if (! stable) | |
166 | continue; | |
167 | ||
168 | for (rn = route_top (stable); rn; rn = route_next (rn)) | |
169 | for (si = rn->info; si; si = si->next) | |
fb148af4 | 170 | { |
2414ffe5 RW |
171 | si->vrf_id = vrf->vrf_id; |
172 | if (si->ifindex) | |
fb148af4 | 173 | { |
1306c09a | 174 | ifp = if_lookup_by_name (si->ifname, si->vrf_id); |
2414ffe5 RW |
175 | if (ifp) |
176 | si->ifindex = ifp->ifindex; | |
177 | else | |
178 | continue; | |
fb148af4 | 179 | } |
c423229b | 180 | static_install_route (afi, safi, &rn->p, NULL, si); |
fb148af4 | 181 | } |
2414ffe5 RW |
182 | } |
183 | ||
7c551956 DS |
184 | return 0; |
185 | } | |
186 | ||
187 | /* Callback upon disabling a VRF. */ | |
188 | static int | |
661512bf | 189 | zebra_vrf_disable (struct vrf *vrf) |
7c551956 | 190 | { |
661512bf | 191 | struct zebra_vrf *zvrf = vrf->info; |
2414ffe5 RW |
192 | struct route_table *stable; |
193 | struct route_node *rn; | |
194 | struct static_route *si; | |
fb148af4 DS |
195 | afi_t afi; |
196 | safi_t safi; | |
7c551956 DS |
197 | |
198 | if (IS_ZEBRA_DEBUG_KERNEL) | |
199 | zlog_debug ("VRF %s id %u is now disabled.", | |
661512bf | 200 | zvrf_name (zvrf), zvrf_id (zvrf)); |
7c551956 | 201 | |
fb148af4 | 202 | for (afi = AFI_IP; afi < AFI_MAX; afi++) |
2414ffe5 RW |
203 | for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++) |
204 | { | |
205 | stable = zvrf->stable[afi][safi]; | |
206 | if (! stable) | |
207 | continue; | |
208 | ||
209 | for (rn = route_top (stable); rn; rn = route_next (rn)) | |
210 | for (si = rn->info; si; si = si->next) | |
c423229b | 211 | static_uninstall_route(afi, safi, &rn->p, NULL, si); |
2414ffe5 RW |
212 | } |
213 | ||
7c551956 DS |
214 | return 0; |
215 | } | |
216 | ||
217 | static int | |
661512bf | 218 | zebra_vrf_delete (struct vrf *vrf) |
7c551956 | 219 | { |
661512bf | 220 | struct zebra_vrf *zvrf = vrf->info; |
5a8dfcd8 RW |
221 | struct route_table *table; |
222 | u_int32_t table_id; | |
223 | afi_t afi; | |
224 | safi_t safi; | |
225 | unsigned i; | |
7c551956 DS |
226 | |
227 | assert (zvrf); | |
228 | ||
229 | zebra_vrf_delete_update (zvrf); | |
230 | ||
5a8dfcd8 RW |
231 | /* uninstall everything */ |
232 | if (! CHECK_FLAG (zvrf->flags, ZEBRA_VRF_RETAIN)) | |
233 | { | |
234 | struct listnode *node; | |
235 | struct interface *ifp; | |
7c551956 | 236 | |
5a8dfcd8 RW |
237 | for (afi = AFI_IP; afi <= AFI_IP6; afi++) |
238 | { | |
239 | for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) | |
240 | rib_close_table (zvrf->table[afi][safi]); | |
241 | ||
242 | if (vrf->vrf_id == VRF_DEFAULT) | |
243 | for (table_id = 0; table_id < ZEBRA_KERNEL_TABLE_MAX; table_id++) | |
244 | if (zvrf->other_table[afi][table_id]) | |
245 | rib_close_table (zvrf->other_table[afi][table_id]); | |
246 | } | |
247 | ||
248 | zebra_mpls_close_tables (zvrf); | |
6da80de9 | 249 | zebra_pw_exit (zvrf); |
7c551956 | 250 | |
5a8dfcd8 RW |
251 | for (ALL_LIST_ELEMENTS_RO (vrf->iflist, node, ifp)) |
252 | if_nbr_ipv6ll_to_ipv4ll_neigh_del_all (ifp); | |
253 | } | |
254 | ||
255 | /* clean-up work queues */ | |
256 | for (i = 0; i < MQ_SIZE; i++) | |
257 | { | |
258 | struct listnode *lnode, *nnode; | |
259 | struct route_node *rnode; | |
260 | rib_dest_t *dest; | |
261 | ||
262 | for (ALL_LIST_ELEMENTS (zebrad.mq->subq[i], lnode, nnode, rnode)) | |
263 | { | |
264 | dest = rib_dest_from_rnode (rnode); | |
265 | if (dest && rib_dest_vrf (dest) == zvrf) | |
266 | { | |
267 | route_unlock_node (rnode); | |
268 | list_delete_node (zebrad.mq->subq[i], lnode); | |
06b57ec2 | 269 | zebrad.mq->size--; |
5a8dfcd8 RW |
270 | } |
271 | } | |
272 | } | |
273 | ||
274 | /* release allocated memory */ | |
275 | for (afi = AFI_IP; afi <= AFI_IP6; afi++) | |
276 | { | |
0f124559 RW |
277 | void *table_info; |
278 | ||
5a8dfcd8 RW |
279 | for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) |
280 | { | |
281 | table = zvrf->table[afi][safi]; | |
0f124559 | 282 | table_info = table->info; |
5a8dfcd8 | 283 | route_table_finish (table); |
0f124559 | 284 | XFREE (MTYPE_RIB_TABLE_INFO, table_info); |
5a8dfcd8 RW |
285 | |
286 | table = zvrf->stable[afi][safi]; | |
287 | route_table_finish (table); | |
288 | } | |
289 | ||
290 | for (table_id = 0; table_id < ZEBRA_KERNEL_TABLE_MAX; table_id++) | |
291 | if (zvrf->other_table[afi][table_id]) | |
292 | { | |
293 | table = zvrf->other_table[afi][table_id]; | |
0f124559 | 294 | table_info = table->info; |
5a8dfcd8 | 295 | route_table_finish (table); |
0f124559 | 296 | XFREE (MTYPE_RIB_TABLE_INFO, table_info); |
5a8dfcd8 RW |
297 | } |
298 | ||
299 | route_table_finish (zvrf->rnh_table[afi]); | |
300 | route_table_finish (zvrf->import_check_table[afi]); | |
301 | } | |
7c551956 DS |
302 | list_delete_all_node (zvrf->rid_all_sorted_list); |
303 | list_delete_all_node (zvrf->rid_lo_sorted_list); | |
5a8dfcd8 | 304 | XFREE (MTYPE_ZEBRA_VRF, zvrf); |
661512bf | 305 | vrf->info = NULL; |
7c551956 | 306 | |
7c551956 DS |
307 | return 0; |
308 | } | |
309 | ||
310 | /* Lookup the routing table in a VRF based on both VRF-Id and table-id. | |
311 | * NOTE: Table-id is relevant only in the Default VRF. | |
312 | */ | |
313 | struct route_table * | |
314 | zebra_vrf_table_with_table_id (afi_t afi, safi_t safi, | |
315 | vrf_id_t vrf_id, u_int32_t table_id) | |
316 | { | |
317 | struct route_table *table = NULL; | |
318 | ||
319 | if (afi >= AFI_MAX || safi >= SAFI_MAX) | |
320 | return NULL; | |
321 | ||
322 | if (vrf_id == VRF_DEFAULT) | |
323 | { | |
324 | if (table_id == RT_TABLE_MAIN || | |
325 | table_id == zebrad.rtm_table_default) | |
326 | table = zebra_vrf_table (afi, safi, vrf_id); | |
327 | else | |
328 | table = zebra_vrf_other_route_table (afi, table_id, vrf_id); | |
329 | } | |
330 | else | |
331 | table = zebra_vrf_table (afi, safi, vrf_id); | |
332 | ||
333 | return table; | |
334 | } | |
335 | ||
5a8dfcd8 | 336 | static void |
05737783 | 337 | zebra_rtable_node_cleanup (struct route_table *table, struct route_node *node) |
5a8dfcd8 RW |
338 | { |
339 | struct rib *rib, *next; | |
340 | ||
341 | RNODE_FOREACH_RIB_SAFE (node, rib, next) | |
342 | rib_unlink (node, rib); | |
343 | ||
344 | if (node->info) | |
345 | XFREE (MTYPE_RIB_DEST, node->info); | |
5a8dfcd8 RW |
346 | } |
347 | ||
348 | static void | |
c423229b | 349 | zebra_stable_node_cleanup (struct route_table *table, struct route_node *node) |
5a8dfcd8 RW |
350 | { |
351 | struct static_route *si, *next; | |
352 | ||
353 | if (node->info) | |
354 | for (si = node->info; si; si = next) | |
355 | { | |
356 | next = si->next; | |
357 | XFREE (MTYPE_STATIC_ROUTE, si); | |
358 | } | |
5a8dfcd8 RW |
359 | } |
360 | ||
361 | static void | |
05737783 | 362 | zebra_rnhtable_node_cleanup (struct route_table *table, struct route_node *node) |
5a8dfcd8 RW |
363 | { |
364 | if (node->info) | |
365 | zebra_free_rnh (node->info); | |
5a8dfcd8 RW |
366 | } |
367 | ||
7c551956 DS |
368 | /* |
369 | * Create a routing table for the specific AFI/SAFI in the given VRF. | |
370 | */ | |
371 | static void | |
372 | zebra_vrf_table_create (struct zebra_vrf *zvrf, afi_t afi, safi_t safi) | |
373 | { | |
374 | rib_table_info_t *info; | |
375 | struct route_table *table; | |
376 | ||
377 | assert (!zvrf->table[afi][safi]); | |
378 | ||
05737783 CF |
379 | if (afi == AFI_IP6) |
380 | table = srcdest_table_init(); | |
381 | else | |
382 | table = route_table_init(); | |
383 | table->cleanup = zebra_rtable_node_cleanup; | |
7c551956 DS |
384 | zvrf->table[afi][safi] = table; |
385 | ||
386 | info = XCALLOC (MTYPE_RIB_TABLE_INFO, sizeof (*info)); | |
387 | info->zvrf = zvrf; | |
388 | info->afi = afi; | |
389 | info->safi = safi; | |
390 | table->info = info; | |
391 | } | |
392 | ||
393 | /* Allocate new zebra VRF. */ | |
394 | struct zebra_vrf * | |
661512bf | 395 | zebra_vrf_alloc (void) |
7c551956 DS |
396 | { |
397 | struct zebra_vrf *zvrf; | |
5a8dfcd8 RW |
398 | afi_t afi; |
399 | safi_t safi; | |
05737783 | 400 | struct route_table *table; |
7c551956 DS |
401 | |
402 | zvrf = XCALLOC (MTYPE_ZEBRA_VRF, sizeof (struct zebra_vrf)); | |
403 | ||
5a8dfcd8 | 404 | for (afi = AFI_IP; afi <= AFI_IP6; afi++) |
7c551956 | 405 | { |
5a8dfcd8 | 406 | for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) |
c423229b CF |
407 | { |
408 | zebra_vrf_table_create (zvrf, afi, safi); | |
409 | if (afi == AFI_IP6) | |
410 | table = srcdest_table_init(); | |
411 | else | |
412 | table = route_table_init(); | |
413 | table->cleanup = zebra_stable_node_cleanup; | |
414 | zvrf->stable[afi][safi] = table; | |
415 | } | |
5a8dfcd8 | 416 | |
05737783 CF |
417 | table = route_table_init(); |
418 | table->cleanup = zebra_rnhtable_node_cleanup; | |
419 | zvrf->rnh_table[afi] = table; | |
420 | ||
421 | table = route_table_init(); | |
422 | table->cleanup = zebra_rnhtable_node_cleanup; | |
423 | zvrf->import_check_table[afi] = table; | |
7c551956 DS |
424 | } |
425 | ||
7758e3f3 | 426 | zebra_mpls_init_tables (zvrf); |
6da80de9 | 427 | zebra_pw_init (zvrf); |
7758e3f3 | 428 | |
7c551956 DS |
429 | return zvrf; |
430 | } | |
431 | ||
432 | /* Lookup VRF by identifier. */ | |
433 | struct zebra_vrf * | |
5f3d1bdf | 434 | zebra_vrf_lookup_by_id (vrf_id_t vrf_id) |
7c551956 DS |
435 | { |
436 | return vrf_info_lookup (vrf_id); | |
437 | } | |
438 | ||
51bdc5f8 | 439 | /* Lookup VRF by name. */ |
871d39b3 | 440 | struct zebra_vrf * |
05e8e11e | 441 | zebra_vrf_lookup_by_name (const char *name) |
871d39b3 | 442 | { |
51bdc5f8 | 443 | struct vrf *vrf; |
871d39b3 | 444 | |
a3d21ef3 DS |
445 | if (!name) |
446 | name = VRF_DEFAULT_NAME; | |
447 | ||
05e8e11e | 448 | vrf = vrf_lookup_by_name (name); |
51bdc5f8 RW |
449 | if (vrf) |
450 | return ((struct zebra_vrf *) vrf->info); | |
451 | ||
871d39b3 DS |
452 | return NULL; |
453 | } | |
454 | ||
7c551956 DS |
455 | /* Lookup the routing table in an enabled VRF. */ |
456 | struct route_table * | |
457 | zebra_vrf_table (afi_t afi, safi_t safi, vrf_id_t vrf_id) | |
458 | { | |
459 | struct zebra_vrf *zvrf = vrf_info_lookup (vrf_id); | |
460 | ||
461 | if (!zvrf) | |
462 | return NULL; | |
463 | ||
464 | if (afi >= AFI_MAX || safi >= SAFI_MAX) | |
465 | return NULL; | |
466 | ||
467 | return zvrf->table[afi][safi]; | |
468 | } | |
469 | ||
470 | /* Lookup the static routing table in a VRF. */ | |
471 | struct route_table * | |
01bb6d57 | 472 | zebra_vrf_static_table (afi_t afi, safi_t safi, struct zebra_vrf *zvrf) |
7c551956 | 473 | { |
7c551956 DS |
474 | if (!zvrf) |
475 | return NULL; | |
476 | ||
477 | if (afi >= AFI_MAX || safi >= SAFI_MAX) | |
478 | return NULL; | |
479 | ||
480 | return zvrf->stable[afi][safi]; | |
481 | } | |
482 | ||
483 | struct route_table * | |
484 | zebra_vrf_other_route_table (afi_t afi, u_int32_t table_id, vrf_id_t vrf_id) | |
485 | { | |
486 | struct zebra_vrf *zvrf; | |
487 | rib_table_info_t *info; | |
488 | struct route_table *table; | |
489 | ||
490 | zvrf = vrf_info_lookup (vrf_id); | |
491 | if (! zvrf) | |
492 | return NULL; | |
493 | ||
494 | if(afi >= AFI_MAX) | |
495 | return NULL; | |
496 | ||
497 | if (table_id >= ZEBRA_KERNEL_TABLE_MAX) | |
498 | return NULL; | |
499 | ||
500 | if ((vrf_id == VRF_DEFAULT) && (table_id != RT_TABLE_MAIN) && (table_id != zebrad.rtm_table_default)) | |
501 | { | |
502 | if (zvrf->other_table[afi][table_id] == NULL) | |
503 | { | |
05737783 | 504 | table = (afi == AFI_IP6) ? srcdest_table_init() : route_table_init(); |
7c551956 DS |
505 | info = XCALLOC (MTYPE_RIB_TABLE_INFO, sizeof (*info)); |
506 | info->zvrf = zvrf; | |
507 | info->afi = afi; | |
508 | info->safi = SAFI_UNICAST; | |
509 | table->info = info; | |
510 | zvrf->other_table[afi][table_id] = table; | |
511 | } | |
512 | ||
513 | return (zvrf->other_table[afi][table_id]); | |
514 | } | |
515 | ||
516 | return zvrf->table[afi][SAFI_UNICAST]; | |
517 | } | |
518 | ||
f30c50b9 RW |
519 | static int |
520 | vrf_config_write (struct vty *vty) | |
521 | { | |
51bdc5f8 | 522 | struct vrf *vrf; |
f30c50b9 RW |
523 | struct zebra_vrf *zvrf; |
524 | ||
806f8760 | 525 | RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) |
f30c50b9 | 526 | { |
51bdc5f8 | 527 | zvrf = vrf->info; |
661512bf | 528 | if (! zvrf || strcmp (zvrf_name (zvrf), VRF_DEFAULT_NAME)) |
f30c50b9 | 529 | { |
661512bf | 530 | vty_out (vty, "vrf %s%s", zvrf_name (zvrf), VTY_NEWLINE); |
f30c50b9 RW |
531 | vty_out (vty, "!%s", VTY_NEWLINE); |
532 | } | |
533 | } | |
534 | return 0; | |
535 | } | |
536 | ||
7c551956 DS |
537 | /* Zebra VRF initialization. */ |
538 | void | |
539 | zebra_vrf_init (void) | |
540 | { | |
541 | vrf_add_hook (VRF_NEW_HOOK, zebra_vrf_new); | |
542 | vrf_add_hook (VRF_ENABLE_HOOK, zebra_vrf_enable); | |
543 | vrf_add_hook (VRF_DISABLE_HOOK, zebra_vrf_disable); | |
544 | vrf_add_hook (VRF_DELETE_HOOK, zebra_vrf_delete); | |
545 | ||
546 | vrf_init (); | |
7ddcfca4 | 547 | vrf_cmd_init (vrf_config_write); |
7c551956 | 548 | } |