3 * Copyright (C) 2014 6WIND S.A.
5 * This file is part of GNU Zebra.
7 * GNU Zebra is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published
9 * by the Free Software Foundation; either version 2, or (at your
10 * option) any later version.
12 * GNU Zebra 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.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
37 #include "nexthop_group.h"
38 #include "lib_errors.h"
40 /* default VRF ID value used when VRF backend is not NETNS */
41 #define VRF_DEFAULT_INTERNAL 0
42 #define VRF_DEFAULT_NAME_INTERNAL "default"
44 DEFINE_MTYPE_STATIC(LIB
, VRF
, "VRF")
45 DEFINE_MTYPE_STATIC(LIB
, VRF_BITMAP
, "VRF bit-map")
49 static __inline
int vrf_id_compare(const struct vrf
*, const struct vrf
*);
50 static __inline
int vrf_name_compare(const struct vrf
*, const struct vrf
*);
52 RB_GENERATE(vrf_id_head
, vrf
, id_entry
, vrf_id_compare
);
53 RB_GENERATE(vrf_name_head
, vrf
, name_entry
, vrf_name_compare
);
55 struct vrf_id_head vrfs_by_id
= RB_INITIALIZER(&vrfs_by_id
);
56 struct vrf_name_head vrfs_by_name
= RB_INITIALIZER(&vrfs_by_name
);
58 static int vrf_backend
;
59 static int vrf_backend_configured
;
60 static struct zebra_privs_t
*vrf_daemon_privs
;
61 static char vrf_default_name
[VRF_NAMSIZ
] = VRF_DEFAULT_NAME_INTERNAL
;
64 * Turn on/off debug code
67 static int debug_vrf
= 0;
69 /* Holding VRF hooks */
71 int (*vrf_new_hook
)(struct vrf
*);
72 int (*vrf_delete_hook
)(struct vrf
*);
73 int (*vrf_enable_hook
)(struct vrf
*);
74 int (*vrf_disable_hook
)(struct vrf
*);
75 int (*vrf_update_name_hook
)(struct vrf
*vrf
);
80 static int vrf_is_enabled(struct vrf
*vrf
);
82 /* VRF list existance check by name. */
83 struct vrf
*vrf_lookup_by_name(const char *name
)
86 strlcpy(vrf
.name
, name
, sizeof(vrf
.name
));
87 return (RB_FIND(vrf_name_head
, &vrfs_by_name
, &vrf
));
90 static __inline
int vrf_id_compare(const struct vrf
*a
, const struct vrf
*b
)
92 return (a
->vrf_id
- b
->vrf_id
);
95 static int vrf_name_compare(const struct vrf
*a
, const struct vrf
*b
)
97 return strcmp(a
->name
, b
->name
);
100 /* if ns_id is different and not VRF_UNKNOWN,
101 * then update vrf identifier, and enable VRF
103 static void vrf_update_vrf_id(ns_id_t ns_id
, void *opaqueptr
)
105 ns_id_t vrf_id
= (vrf_id_t
)ns_id
;
107 struct vrf
*vrf
= (struct vrf
*)opaqueptr
;
111 old_vrf_id
= vrf
->vrf_id
;
112 if (vrf_id
== vrf
->vrf_id
)
114 if (vrf
->vrf_id
!= VRF_UNKNOWN
)
115 RB_REMOVE(vrf_id_head
, &vrfs_by_id
, vrf
);
116 vrf
->vrf_id
= vrf_id
;
117 RB_INSERT(vrf_id_head
, &vrfs_by_id
, vrf
);
118 if (old_vrf_id
== VRF_UNKNOWN
)
119 vrf_enable((struct vrf
*)vrf
);
122 int vrf_switch_to_netns(vrf_id_t vrf_id
)
125 struct vrf
*vrf
= vrf_lookup_by_id(vrf_id
);
127 /* VRF is default VRF. silently ignore */
128 if (!vrf
|| vrf
->vrf_id
== VRF_DEFAULT
)
129 return 1; /* 1 = default */
130 /* VRF has no NETNS backend. silently ignore */
131 if (vrf
->data
.l
.netns_name
[0] == '\0')
132 return 2; /* 2 = no netns */
133 name
= ns_netns_pathname(NULL
, vrf
->data
.l
.netns_name
);
135 zlog_debug("VRF_SWITCH: %s(%u)", name
, vrf
->vrf_id
);
136 return ns_switch_to_netns(name
);
139 int vrf_switchback_to_initial(void)
141 int ret
= ns_switchback_to_initial();
143 if (ret
== 0 && debug_vrf
)
144 zlog_debug("VRF_SWITCHBACK");
148 /* Get a VRF. If not found, create one.
150 * name - The name of the vrf. May be NULL if unknown.
151 * vrf_id - The vrf_id of the vrf. May be VRF_UNKNOWN if unknown
152 * Description: Please note that this routine can be called with just the name
155 struct vrf
*vrf_get(vrf_id_t vrf_id
, const char *name
)
157 struct vrf
*vrf
= NULL
;
161 zlog_debug("VRF_GET: %s(%u)", name
== NULL
? "(NULL)" : name
,
164 /* Nothing to see, move along here */
165 if (!name
&& vrf_id
== VRF_UNKNOWN
)
168 /* attempt to find already available VRF
171 vrf
= vrf_lookup_by_name(name
);
172 if (vrf
&& vrf_id
!= VRF_UNKNOWN
173 && vrf
->vrf_id
!= VRF_UNKNOWN
174 && vrf
->vrf_id
!= vrf_id
) {
175 zlog_debug("VRF_GET: avoid %s creation(%u), same name exists (%u)",
176 name
, vrf_id
, vrf
->vrf_id
);
179 /* look for duplicates. case is followine one:
180 * - a vrf is configured per name -> vrfA
181 * - netlink discovery creates a vrf with vrf_id ->vrfB
182 * - then, netlink discovers vrf, and associated vrf_id and name
183 * -> so vrfA and vrfB must be merged
185 if (vrf
&& vrf_id
!= VRF_UNKNOWN
186 && vrf
->vrf_id
== VRF_UNKNOWN
) {
187 struct vrf
*vrf2
= vrf_lookup_by_id(vrf_id
);
188 struct interface
*ifp
;
190 if (vrf2
&& !vrf2
->name
&& vrf2
!= vrf
) {
191 /* move vrf2 context to vrf */
192 FOR_ALL_INTERFACES (vrf2
, ifp
)
193 if_update_to_new_vrf(ifp
, vrf
);
197 /* Try to find VRF both by ID and name */
198 if (!vrf
&& vrf_id
!= VRF_UNKNOWN
)
199 vrf
= vrf_lookup_by_id(vrf_id
);
202 vrf
= XCALLOC(MTYPE_VRF
, sizeof(struct vrf
));
203 vrf
->vrf_id
= VRF_UNKNOWN
;
208 zlog_debug("VRF(%u) %s is created.", vrf_id
,
209 (name
) ? name
: "(NULL)");
213 if (vrf_id
!= VRF_UNKNOWN
&& vrf
->vrf_id
== VRF_UNKNOWN
) {
214 vrf
->vrf_id
= vrf_id
;
215 RB_INSERT(vrf_id_head
, &vrfs_by_id
, vrf
);
219 if (name
&& vrf
->name
[0] != '\0' && strcmp(name
, vrf
->name
)) {
220 RB_REMOVE(vrf_name_head
, &vrfs_by_name
, vrf
);
221 strlcpy(vrf
->name
, name
, sizeof(vrf
->name
));
222 RB_INSERT(vrf_name_head
, &vrfs_by_name
, vrf
);
223 } else if (name
&& vrf
->name
[0] == '\0') {
224 strlcpy(vrf
->name
, name
, sizeof(vrf
->name
));
225 RB_INSERT(vrf_name_head
, &vrfs_by_name
, vrf
);
227 if (new &&vrf_master
.vrf_new_hook
)
228 (*vrf_master
.vrf_new_hook
)(vrf
);
233 /* Delete a VRF. This is called when the underlying VRF goes away, a
234 * pre-configured VRF is deleted or when shutting down (vrf_terminate()).
236 void vrf_delete(struct vrf
*vrf
)
239 zlog_debug("VRF %u is to be deleted.", vrf
->vrf_id
);
241 if (vrf_is_enabled(vrf
))
244 /* If the VRF is user configured, it'll stick around, just remove
245 * the ID mapping. Interfaces assigned to this VRF should've been
246 * removed already as part of the VRF going down.
248 if (vrf_is_user_cfged(vrf
)) {
249 if (vrf
->vrf_id
!= VRF_UNKNOWN
) {
250 /* Delete any VRF interfaces - should be only
251 * the VRF itself, other interfaces should've
252 * been moved out of the VRF.
255 RB_REMOVE(vrf_id_head
, &vrfs_by_id
, vrf
);
256 vrf
->vrf_id
= VRF_UNKNOWN
;
261 if (vrf_master
.vrf_delete_hook
)
262 (*vrf_master
.vrf_delete_hook
)(vrf
);
267 if (vrf
->vrf_id
!= VRF_UNKNOWN
)
268 RB_REMOVE(vrf_id_head
, &vrfs_by_id
, vrf
);
269 if (vrf
->name
[0] != '\0')
270 RB_REMOVE(vrf_name_head
, &vrfs_by_name
, vrf
);
272 XFREE(MTYPE_VRF
, vrf
);
275 /* Look up a VRF by identifier. */
276 struct vrf
*vrf_lookup_by_id(vrf_id_t vrf_id
)
280 return (RB_FIND(vrf_id_head
, &vrfs_by_id
, &vrf
));
284 * Enable a VRF - that is, let the VRF be ready to use.
285 * The VRF_ENABLE_HOOK callback will be called to inform
286 * that they can allocate resources in this VRF.
288 * RETURN: 1 - enabled successfully; otherwise, 0.
290 int vrf_enable(struct vrf
*vrf
)
292 if (vrf_is_enabled(vrf
))
296 zlog_debug("VRF %u is enabled.", vrf
->vrf_id
);
298 SET_FLAG(vrf
->status
, VRF_ACTIVE
);
300 if (vrf_master
.vrf_enable_hook
)
301 (*vrf_master
.vrf_enable_hook
)(vrf
);
304 * If we have any nexthop group entries that
305 * are awaiting vrf initialization then
306 * let's let people know about it
308 nexthop_group_enable_vrf(vrf
);
314 * Disable a VRF - that is, let the VRF be unusable.
315 * The VRF_DELETE_HOOK callback will be called to inform
316 * that they must release the resources in the VRF.
318 void vrf_disable(struct vrf
*vrf
)
320 if (!vrf_is_enabled(vrf
))
323 UNSET_FLAG(vrf
->status
, VRF_ACTIVE
);
326 zlog_debug("VRF %u is to be disabled.", vrf
->vrf_id
);
328 /* Till now, nothing to be done for the default VRF. */
329 // Pending: see why this statement.
331 if (vrf_master
.vrf_disable_hook
)
332 (*vrf_master
.vrf_disable_hook
)(vrf
);
335 const char *vrf_id_to_name(vrf_id_t vrf_id
)
339 vrf
= vrf_lookup_by_id(vrf_id
);
346 vrf_id_t
vrf_name_to_id(const char *name
)
349 vrf_id_t vrf_id
= VRF_DEFAULT
; // Pending: need a way to return invalid
350 // id/ routine not used.
354 vrf
= vrf_lookup_by_name(name
);
356 vrf_id
= vrf
->vrf_id
;
361 /* Get the data pointer of the specified VRF. If not found, create one. */
362 void *vrf_info_get(vrf_id_t vrf_id
)
364 struct vrf
*vrf
= vrf_get(vrf_id
, NULL
);
368 /* Look up the data pointer of the specified VRF. */
369 void *vrf_info_lookup(vrf_id_t vrf_id
)
371 struct vrf
*vrf
= vrf_lookup_by_id(vrf_id
);
372 return vrf
? vrf
->info
: NULL
;
376 * VRF hash for storing set or not.
383 static unsigned int vrf_hash_bitmap_key(const void *data
)
385 const struct vrf_bit_set
*bit
= data
;
390 static bool vrf_hash_bitmap_cmp(const void *a
, const void *b
)
392 const struct vrf_bit_set
*bit1
= a
;
393 const struct vrf_bit_set
*bit2
= b
;
395 return bit1
->vrf_id
== bit2
->vrf_id
;
398 static void *vrf_hash_bitmap_alloc(void *data
)
400 struct vrf_bit_set
*copy
= data
;
401 struct vrf_bit_set
*bit
;
403 bit
= XMALLOC(MTYPE_VRF_BITMAP
, sizeof(*bit
));
404 bit
->vrf_id
= copy
->vrf_id
;
409 static void vrf_hash_bitmap_free(void *data
)
411 struct vrf_bit_set
*bit
= data
;
413 XFREE(MTYPE_VRF_BITMAP
, bit
);
416 vrf_bitmap_t
vrf_bitmap_init(void)
418 return hash_create_size(32, vrf_hash_bitmap_key
, vrf_hash_bitmap_cmp
,
422 void vrf_bitmap_free(vrf_bitmap_t bmap
)
424 struct hash
*vrf_hash
= bmap
;
426 if (vrf_hash
== NULL
)
429 hash_clean(vrf_hash
, vrf_hash_bitmap_free
);
433 void vrf_bitmap_set(vrf_bitmap_t bmap
, vrf_id_t vrf_id
)
435 struct vrf_bit_set lookup
= { .vrf_id
= vrf_id
};
436 struct hash
*vrf_hash
= bmap
;
437 struct vrf_bit_set
*bit
;
439 if (vrf_hash
== NULL
|| vrf_id
== VRF_UNKNOWN
)
442 bit
= hash_get(vrf_hash
, &lookup
, vrf_hash_bitmap_alloc
);
446 void vrf_bitmap_unset(vrf_bitmap_t bmap
, vrf_id_t vrf_id
)
448 struct vrf_bit_set lookup
= { .vrf_id
= vrf_id
};
449 struct hash
*vrf_hash
= bmap
;
450 struct vrf_bit_set
*bit
;
452 if (vrf_hash
== NULL
|| vrf_id
== VRF_UNKNOWN
)
455 bit
= hash_get(vrf_hash
, &lookup
, vrf_hash_bitmap_alloc
);
459 int vrf_bitmap_check(vrf_bitmap_t bmap
, vrf_id_t vrf_id
)
461 struct vrf_bit_set lookup
= { .vrf_id
= vrf_id
};
462 struct hash
*vrf_hash
= bmap
;
463 struct vrf_bit_set
*bit
;
465 if (vrf_hash
== NULL
|| vrf_id
== VRF_UNKNOWN
)
468 bit
= hash_lookup(vrf_hash
, &lookup
);
475 static void vrf_autocomplete(vector comps
, struct cmd_token
*token
)
477 struct vrf
*vrf
= NULL
;
479 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
)
480 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, vrf
->name
));
483 static const struct cmd_variable_handler vrf_var_handlers
[] = {
486 .completions
= vrf_autocomplete
,
488 {.completions
= NULL
},
491 /* Initialize VRF module. */
492 void vrf_init(int (*create
)(struct vrf
*), int (*enable
)(struct vrf
*),
493 int (*disable
)(struct vrf
*), int (*destroy
)(struct vrf
*),
494 int ((*update
)(struct vrf
*)))
496 struct vrf
*default_vrf
;
498 /* initialise NS, in case VRF backend if NETNS */
501 zlog_debug("%s: Initializing VRF subsystem",
502 __PRETTY_FUNCTION__
);
504 vrf_master
.vrf_new_hook
= create
;
505 vrf_master
.vrf_enable_hook
= enable
;
506 vrf_master
.vrf_disable_hook
= disable
;
507 vrf_master
.vrf_delete_hook
= destroy
;
508 vrf_master
.vrf_update_name_hook
= update
;
510 /* The default VRF always exists. */
511 default_vrf
= vrf_get(VRF_DEFAULT
, VRF_DEFAULT_NAME
);
513 flog_err(EC_LIB_VRF_START
,
514 "vrf_init: failed to create the default VRF!");
517 if (vrf_is_backend_netns()) {
520 strlcpy(default_vrf
->data
.l
.netns_name
,
521 VRF_DEFAULT_NAME
, NS_NAMSIZ
);
522 ns
= ns_lookup(ns_get_default_id());
523 ns
->vrf_ctxt
= default_vrf
;
524 default_vrf
->ns_ctxt
= ns
;
527 /* Enable the default VRF. */
528 if (!vrf_enable(default_vrf
)) {
529 flog_err(EC_LIB_VRF_START
,
530 "vrf_init: failed to enable the default VRF!");
534 cmd_variable_handler_register(vrf_var_handlers
);
537 /* Terminate VRF module. */
538 void vrf_terminate(void)
543 zlog_debug("%s: Shutting down vrf subsystem",
544 __PRETTY_FUNCTION__
);
546 while (!RB_EMPTY(vrf_id_head
, &vrfs_by_id
)) {
547 vrf
= RB_ROOT(vrf_id_head
, &vrfs_by_id
);
549 /* Clear configured flag and invoke delete. */
550 UNSET_FLAG(vrf
->status
, VRF_CONFIGURED
);
554 while (!RB_EMPTY(vrf_name_head
, &vrfs_by_name
)) {
555 vrf
= RB_ROOT(vrf_name_head
, &vrfs_by_name
);
557 /* Clear configured flag and invoke delete. */
558 UNSET_FLAG(vrf
->status
, VRF_CONFIGURED
);
563 /* Create a socket for the VRF. */
564 int vrf_socket(int domain
, int type
, int protocol
, vrf_id_t vrf_id
,
565 const char *interfacename
)
567 int ret
, save_errno
, ret2
;
569 ret
= vrf_switch_to_netns(vrf_id
);
571 flog_err_sys(EC_LIB_SOCKET
, "%s: Can't switch to VRF %u (%s)",
572 __func__
, vrf_id
, safe_strerror(errno
));
574 ret
= socket(domain
, type
, protocol
);
576 ret2
= vrf_switchback_to_initial();
578 flog_err_sys(EC_LIB_SOCKET
,
579 "%s: Can't switchback from VRF %u (%s)", __func__
,
580 vrf_id
, safe_strerror(errno
));
584 ret2
= vrf_bind(vrf_id
, ret
, interfacename
);
592 int vrf_is_backend_netns(void)
594 return (vrf_backend
== VRF_BACKEND_NETNS
);
597 int vrf_get_backend(void)
599 if (!vrf_backend_configured
)
600 return VRF_BACKEND_UNKNOWN
;
604 void vrf_configure_backend(int vrf_backend_netns
)
606 vrf_backend
= vrf_backend_netns
;
607 vrf_backend_configured
= 1;
610 int vrf_handler_create(struct vty
*vty
, const char *vrfname
,
615 if (strlen(vrfname
) > VRF_NAMSIZ
) {
618 "%% VRF name %s invalid: length exceeds %d bytes\n",
619 vrfname
, VRF_NAMSIZ
);
623 "%% VRF name %s invalid: length exceeds %d bytes\n",
624 vrfname
, VRF_NAMSIZ
);
625 return CMD_WARNING_CONFIG_FAILED
;
628 vrfp
= vrf_get(VRF_UNKNOWN
, vrfname
);
631 VTY_PUSH_CONTEXT(VRF_NODE
, vrfp
);
638 int vrf_netns_handler_create(struct vty
*vty
, struct vrf
*vrf
, char *pathname
,
639 ns_id_t ns_id
, ns_id_t internal_ns_id
)
641 struct ns
*ns
= NULL
;
644 return CMD_WARNING_CONFIG_FAILED
;
645 if (vrf
->vrf_id
!= VRF_UNKNOWN
&& vrf
->ns_ctxt
== NULL
) {
648 "VRF %u is already configured with VRF %s\n",
649 vrf
->vrf_id
, vrf
->name
);
651 zlog_info("VRF %u is already configured with VRF %s",
652 vrf
->vrf_id
, vrf
->name
);
653 return CMD_WARNING_CONFIG_FAILED
;
655 if (vrf
->ns_ctxt
!= NULL
) {
656 ns
= (struct ns
*)vrf
->ns_ctxt
;
657 if (!strcmp(ns
->name
, pathname
)) {
660 "VRF %u already configured with NETNS %s\n",
661 vrf
->vrf_id
, ns
->name
);
664 "VRF %u already configured with NETNS %s",
665 vrf
->vrf_id
, ns
->name
);
666 return CMD_WARNING_CONFIG_FAILED
;
669 ns
= ns_lookup_name(pathname
);
670 if (ns
&& ns
->vrf_ctxt
) {
671 struct vrf
*vrf2
= (struct vrf
*)ns
->vrf_ctxt
;
677 "NS %s is already configured"
678 " with VRF %u(%s)\n",
679 ns
->name
, vrf2
->vrf_id
, vrf2
->name
);
681 zlog_info("NS %s is already configured with VRF %u(%s)",
682 ns
->name
, vrf2
->vrf_id
, vrf2
->name
);
683 return CMD_WARNING_CONFIG_FAILED
;
685 ns
= ns_get_created(ns
, pathname
, ns_id
);
686 ns
->internal_ns_id
= internal_ns_id
;
687 ns
->vrf_ctxt
= (void *)vrf
;
688 vrf
->ns_ctxt
= (void *)ns
;
689 /* update VRF netns NAME */
690 strlcpy(vrf
->data
.l
.netns_name
, basename(pathname
), NS_NAMSIZ
);
692 if (!ns_enable(ns
, vrf_update_vrf_id
)) {
694 vty_out(vty
, "Can not associate NS %u with NETNS %s\n",
695 ns
->ns_id
, ns
->name
);
697 zlog_info("Can not associate NS %u with NETNS %s",
698 ns
->ns_id
, ns
->name
);
699 return CMD_WARNING_CONFIG_FAILED
;
705 /* vrf CLI commands */
709 "Exit current mode and down to previous mode\n")
711 /* We have to set vrf context to default vrf */
712 VTY_PUSH_CONTEXT(VRF_NODE
, vrf_get(VRF_DEFAULT
, VRF_DEFAULT_NAME
));
713 vty
->node
= CONFIG_NODE
;
720 "Select a VRF to configure\n"
724 const char *vrfname
= argv
[idx_name
]->arg
;
726 return vrf_handler_create(vty
, vrfname
, NULL
);
733 "Delete a pseudo VRF's configuration\n"
736 const char *vrfname
= argv
[2]->arg
;
740 vrfp
= vrf_lookup_by_name(vrfname
);
743 vty_out(vty
, "%% VRF %s does not exist\n", vrfname
);
744 return CMD_WARNING_CONFIG_FAILED
;
747 if (CHECK_FLAG(vrfp
->status
, VRF_ACTIVE
)) {
748 vty_out(vty
, "%% Only inactive VRFs can be deleted\n");
749 return CMD_WARNING_CONFIG_FAILED
;
752 /* Clear configured flag and invoke delete. */
753 UNSET_FLAG(vrfp
->status
, VRF_CONFIGURED
);
760 struct cmd_node vrf_node
= {VRF_NODE
, "%s(config-vrf)# ", 1};
762 DEFUN_NOSH (vrf_netns
,
765 "Attach VRF to a Namespace\n"
766 "The file name in " NS_RUN_DIR
", or a full pathname\n")
768 int idx_name
= 1, ret
;
769 char *pathname
= ns_netns_pathname(vty
, argv
[idx_name
]->arg
);
771 VTY_DECLVAR_CONTEXT(vrf
, vrf
);
774 return CMD_WARNING_CONFIG_FAILED
;
776 frr_elevate_privs(vrf_daemon_privs
) {
777 ret
= vrf_netns_handler_create(vty
, vrf
, pathname
,
778 NS_UNKNOWN
, NS_UNKNOWN
);
783 DEFUN_NOSH (no_vrf_netns
,
787 "Detach VRF from a Namespace\n"
788 "The file name in " NS_RUN_DIR
", or a full pathname\n")
790 struct ns
*ns
= NULL
;
792 VTY_DECLVAR_CONTEXT(vrf
, vrf
);
794 if (!vrf_is_backend_netns()) {
795 vty_out(vty
, "VRF backend is not Netns. Aborting\n");
796 return CMD_WARNING_CONFIG_FAILED
;
799 vty_out(vty
, "VRF %s(%u) is not configured with NetNS\n",
800 vrf
->name
, vrf
->vrf_id
);
801 return CMD_WARNING_CONFIG_FAILED
;
804 ns
= (struct ns
*)vrf
->ns_ctxt
;
808 /* vrf ID from VRF is necessary for Zebra
809 * so that propagate to other clients is done
817 * Debug CLI for vrf's
842 static int vrf_write_host(struct vty
*vty
)
845 vty_out(vty
, "debug vrf\n");
850 static struct cmd_node vrf_debug_node
= {VRF_DEBUG_NODE
, "", 1};
852 void vrf_install_commands(void)
854 install_node(&vrf_debug_node
, vrf_write_host
);
856 install_element(CONFIG_NODE
, &vrf_debug_cmd
);
857 install_element(ENABLE_NODE
, &vrf_debug_cmd
);
858 install_element(CONFIG_NODE
, &no_vrf_debug_cmd
);
859 install_element(ENABLE_NODE
, &no_vrf_debug_cmd
);
862 void vrf_cmd_init(int (*writefunc
)(struct vty
*vty
),
863 struct zebra_privs_t
*daemon_privs
)
865 install_element(CONFIG_NODE
, &vrf_cmd
);
866 install_element(CONFIG_NODE
, &no_vrf_cmd
);
867 install_node(&vrf_node
, writefunc
);
868 install_default(VRF_NODE
);
869 install_element(VRF_NODE
, &vrf_exit_cmd
);
870 if (vrf_is_backend_netns() && ns_have_netns()) {
871 /* Install NS commands. */
872 vrf_daemon_privs
= daemon_privs
;
873 install_element(VRF_NODE
, &vrf_netns_cmd
);
874 install_element(VRF_NODE
, &no_vrf_netns_cmd
);
878 void vrf_set_default_name(const char *default_name
, bool force
)
881 static bool def_vrf_forced
;
883 def_vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
884 assert(default_name
);
885 if (def_vrf
&& !force
&& def_vrf_forced
) {
886 zlog_debug("VRF: %s, avoid changing name to %s, previously forced (%u)",
887 def_vrf
->name
, default_name
,
892 snprintf(vrf_default_name
, VRF_NAMSIZ
, "%s", default_name
);
895 def_vrf_forced
= true;
896 RB_REMOVE(vrf_name_head
, &vrfs_by_name
, def_vrf
);
897 strlcpy(def_vrf
->data
.l
.netns_name
,
898 vrf_default_name
, NS_NAMSIZ
);
899 strlcpy(def_vrf
->name
, vrf_default_name
, sizeof(def_vrf
->name
));
900 RB_INSERT(vrf_name_head
, &vrfs_by_name
, def_vrf
);
901 if (vrf_master
.vrf_update_name_hook
)
902 (*vrf_master
.vrf_update_name_hook
)(def_vrf
);
906 const char *vrf_get_default_name(void)
908 return vrf_default_name
;
911 vrf_id_t
vrf_get_default_id(void)
913 /* backend netns is only known by zebra
914 * for other daemons, we return VRF_DEFAULT_INTERNAL
916 if (vrf_is_backend_netns())
917 return ns_get_default_id();
919 return VRF_DEFAULT_INTERNAL
;
922 int vrf_bind(vrf_id_t vrf_id
, int fd
, const char *name
)
925 struct interface
*ifp
;
926 struct vrf
*vrf
= vrf_lookup_by_id(vrf_id
);
928 if (fd
< 0 || name
== NULL
|| !vrf
)
930 /* the device should exist
931 * otherwise we should return
932 * case ifname = vrf in netns mode => return
934 ifp
= if_lookup_by_name(name
, vrf
);
937 #ifdef SO_BINDTODEVICE
938 ret
= setsockopt(fd
, SOL_SOCKET
, SO_BINDTODEVICE
, name
, strlen(name
)+1);
940 zlog_debug("bind to interface %s failed, errno=%d", name
,
942 #endif /* SO_BINDTODEVICE */
945 int vrf_getaddrinfo(const char *node
, const char *service
,
946 const struct addrinfo
*hints
, struct addrinfo
**res
,
949 int ret
, ret2
, save_errno
;
951 ret
= vrf_switch_to_netns(vrf_id
);
953 flog_err_sys(EC_LIB_SOCKET
, "%s: Can't switch to VRF %u (%s)",
954 __func__
, vrf_id
, safe_strerror(errno
));
955 ret
= getaddrinfo(node
, service
, hints
, res
);
957 ret2
= vrf_switchback_to_initial();
959 flog_err_sys(EC_LIB_SOCKET
,
960 "%s: Can't switchback from VRF %u (%s)", __func__
,
961 vrf_id
, safe_strerror(errno
));
966 int vrf_ioctl(vrf_id_t vrf_id
, int d
, unsigned long request
, char *params
)
968 int ret
, saved_errno
, rc
;
970 ret
= vrf_switch_to_netns(vrf_id
);
972 flog_err_sys(EC_LIB_SOCKET
, "%s: Can't switch to VRF %u (%s)",
973 __func__
, vrf_id
, safe_strerror(errno
));
976 rc
= ioctl(d
, request
, params
);
978 ret
= vrf_switchback_to_initial();
980 flog_err_sys(EC_LIB_SOCKET
,
981 "%s: Can't switchback from VRF %u (%s)", __func__
,
982 vrf_id
, safe_strerror(errno
));
987 int vrf_sockunion_socket(const union sockunion
*su
, vrf_id_t vrf_id
,
988 const char *interfacename
)
990 int ret
, save_errno
, ret2
;
992 ret
= vrf_switch_to_netns(vrf_id
);
994 flog_err_sys(EC_LIB_SOCKET
, "%s: Can't switch to VRF %u (%s)",
995 __func__
, vrf_id
, safe_strerror(errno
));
996 ret
= sockunion_socket(su
);
998 ret2
= vrf_switchback_to_initial();
1000 flog_err_sys(EC_LIB_SOCKET
,
1001 "%s: Can't switchback from VRF %u (%s)", __func__
,
1002 vrf_id
, safe_strerror(errno
));
1007 ret2
= vrf_bind(vrf_id
, ret
, interfacename
);
1015 vrf_id_t
vrf_generate_id(void)
1017 static int vrf_id_local
;
1019 return ++vrf_id_local
;
1022 vrf_id_t
vrf_to_id(struct vrf
*vrf
)
1024 return vrf
? vrf
->vrf_id
: VRF_UNKNOWN
;
1027 const char *vrf_to_name(struct vrf
*vrf
)
1029 return vrf
? vrf
->name
: "NIL";