Annotation of embedaddon/quagga/lib/vrf.c, revision 1.1.1.1
1.1 misho 1: /*
2: * VRF functions.
3: * Copyright (C) 2014 6WIND S.A.
4: *
5: * This file is part of GNU Zebra.
6: *
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.
11: *
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.
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
19: * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20: * Boston, MA 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #ifdef HAVE_NETNS
26: #undef _GNU_SOURCE
27: #define _GNU_SOURCE
28:
29: #include <sched.h>
30: #endif
31:
32: #include "if.h"
33: #include "vrf.h"
34: #include "prefix.h"
35: #include "table.h"
36: #include "log.h"
37: #include "memory.h"
38: #include "command.h"
39: #include "vty.h"
40:
41:
42: #ifndef CLONE_NEWNET
43: #define CLONE_NEWNET 0x40000000 /* New network namespace (lo, device, names sockets, etc) */
44: #endif
45:
46: #ifndef HAVE_SETNS
47: static inline int setns(int fd, int nstype)
48: {
49: #ifdef __NR_setns
50: return syscall(__NR_setns, fd, nstype);
51: #else
52: errno = ENOSYS;
53: return -1;
54: #endif
55: }
56: #endif /* HAVE_SETNS */
57:
58: #define VRF_RUN_DIR "/var/run/netns"
59:
60: #ifdef HAVE_NETNS
61:
62: #define VRF_DEFAULT_NAME "/proc/self/ns/net"
63: static int have_netns_enabled = -1;
64:
65: #else /* !HAVE_NETNS */
66:
67: #define VRF_DEFAULT_NAME "Default-IP-Routing-Table"
68:
69: #endif /* HAVE_NETNS */
70:
71: static int have_netns(void)
72: {
73: #ifdef HAVE_NETNS
74: if (have_netns_enabled < 0)
75: {
76: int fd = open (VRF_DEFAULT_NAME, O_RDONLY);
77:
78: if (fd < 0)
79: have_netns_enabled = 0;
80: else
81: {
82: have_netns_enabled = 1;
83: close(fd);
84: }
85: }
86: return have_netns_enabled;
87: #else
88: return 0;
89: #endif
90: }
91:
92: struct vrf
93: {
94: /* Identifier, same as the vector index */
95: vrf_id_t vrf_id;
96: /* Name */
97: char *name;
98: /* File descriptor */
99: int fd;
100:
101: /* Master list of interfaces belonging to this VRF */
102: struct list *iflist;
103:
104: /* User data */
105: void *info;
106: };
107:
108: /* Holding VRF hooks */
109: struct vrf_master
110: {
111: int (*vrf_new_hook) (vrf_id_t, void **);
112: int (*vrf_delete_hook) (vrf_id_t, void **);
113: int (*vrf_enable_hook) (vrf_id_t, void **);
114: int (*vrf_disable_hook) (vrf_id_t, void **);
115: } vrf_master = {0,};
116:
117: /* VRF table */
118: struct route_table *vrf_table = NULL;
119:
120: static int vrf_is_enabled (struct vrf *vrf);
121: static int vrf_enable (struct vrf *vrf);
122: static void vrf_disable (struct vrf *vrf);
123:
124:
125: /* Build the table key */
126: static void
127: vrf_build_key (vrf_id_t vrf_id, struct prefix *p)
128: {
129: p->family = AF_INET;
130: p->prefixlen = IPV4_MAX_BITLEN;
131: p->u.prefix4.s_addr = vrf_id;
132: }
133:
134: /* Get a VRF. If not found, create one. */
135: static struct vrf *
136: vrf_get (vrf_id_t vrf_id)
137: {
138: struct prefix p;
139: struct route_node *rn;
140: struct vrf *vrf;
141:
142: vrf_build_key (vrf_id, &p);
143: rn = route_node_get (vrf_table, &p);
144: if (rn->info)
145: {
146: vrf = (struct vrf *)rn->info;
147: route_unlock_node (rn); /* get */
148: return vrf;
149: }
150:
151: vrf = XCALLOC (MTYPE_VRF, sizeof (struct vrf));
152: vrf->vrf_id = vrf_id;
153: vrf->fd = -1;
154: rn->info = vrf;
155:
156: /* Initialize interfaces. */
157: if_init (vrf_id, &vrf->iflist);
158:
159: zlog_info ("VRF %u is created.", vrf_id);
160:
161: if (vrf_master.vrf_new_hook)
162: (*vrf_master.vrf_new_hook) (vrf_id, &vrf->info);
163:
164: return vrf;
165: }
166:
167: /* Delete a VRF. This is called in vrf_terminate(). */
168: static void
169: vrf_delete (struct vrf *vrf)
170: {
171: zlog_info ("VRF %u is to be deleted.", vrf->vrf_id);
172:
173: vrf_disable (vrf);
174:
175: if (vrf_master.vrf_delete_hook)
176: (*vrf_master.vrf_delete_hook) (vrf->vrf_id, &vrf->info);
177:
178: if_terminate (vrf->vrf_id, &vrf->iflist);
179:
180: if (vrf->name)
181: XFREE (MTYPE_VRF_NAME, vrf->name);
182:
183: XFREE (MTYPE_VRF, vrf);
184: }
185:
186: /* Look up a VRF by identifier. */
187: static struct vrf *
188: vrf_lookup (vrf_id_t vrf_id)
189: {
190: struct prefix p;
191: struct route_node *rn;
192: struct vrf *vrf = NULL;
193:
194: vrf_build_key (vrf_id, &p);
195: rn = route_node_lookup (vrf_table, &p);
196: if (rn)
197: {
198: vrf = (struct vrf *)rn->info;
199: route_unlock_node (rn); /* lookup */
200: }
201: return vrf;
202: }
203:
204: /*
205: * Check whether the VRF is enabled - that is, whether the VRF
206: * is ready to allocate resources. Currently there's only one
207: * type of resource: socket.
208: */
209: static int
210: vrf_is_enabled (struct vrf *vrf)
211: {
212: if (have_netns())
213: return vrf && vrf->fd >= 0;
214: else
215: return vrf && vrf->fd == -2 && vrf->vrf_id == VRF_DEFAULT;
216: }
217:
218: /*
219: * Enable a VRF - that is, let the VRF be ready to use.
220: * The VRF_ENABLE_HOOK callback will be called to inform
221: * that they can allocate resources in this VRF.
222: *
223: * RETURN: 1 - enabled successfully; otherwise, 0.
224: */
225: static int
226: vrf_enable (struct vrf *vrf)
227: {
228:
229: if (!vrf_is_enabled (vrf))
230: {
231: if (have_netns()) {
232: vrf->fd = open (vrf->name, O_RDONLY);
233: } else {
234: vrf->fd = -2; /* Remember that vrf_enable_hook has been called */
235: errno = -ENOTSUP;
236: }
237:
238: if (!vrf_is_enabled (vrf))
239: {
240: zlog_err ("Can not enable VRF %u: %s!",
241: vrf->vrf_id, safe_strerror (errno));
242: return 0;
243: }
244:
245: if (have_netns())
246: zlog_info ("VRF %u is associated with NETNS %s.",
247: vrf->vrf_id, vrf->name);
248:
249: zlog_info ("VRF %u is enabled.", vrf->vrf_id);
250: if (vrf_master.vrf_enable_hook)
251: (*vrf_master.vrf_enable_hook) (vrf->vrf_id, &vrf->info);
252: }
253:
254: return 1;
255: }
256:
257: /*
258: * Disable a VRF - that is, let the VRF be unusable.
259: * The VRF_DELETE_HOOK callback will be called to inform
260: * that they must release the resources in the VRF.
261: */
262: static void
263: vrf_disable (struct vrf *vrf)
264: {
265: if (vrf_is_enabled (vrf))
266: {
267: zlog_info ("VRF %u is to be disabled.", vrf->vrf_id);
268:
269: if (vrf_master.vrf_disable_hook)
270: (*vrf_master.vrf_disable_hook) (vrf->vrf_id, &vrf->info);
271:
272: if (have_netns())
273: close (vrf->fd);
274:
275: vrf->fd = -1;
276: }
277: }
278:
279:
280: /* Add a VRF hook. Please add hooks before calling vrf_init(). */
281: void
282: vrf_add_hook (int type, int (*func)(vrf_id_t, void **))
283: {
284: switch (type) {
285: case VRF_NEW_HOOK:
286: vrf_master.vrf_new_hook = func;
287: break;
288: case VRF_DELETE_HOOK:
289: vrf_master.vrf_delete_hook = func;
290: break;
291: case VRF_ENABLE_HOOK:
292: vrf_master.vrf_enable_hook = func;
293: break;
294: case VRF_DISABLE_HOOK:
295: vrf_master.vrf_disable_hook = func;
296: break;
297: default:
298: break;
299: }
300: }
301:
302: /* Return the iterator of the first VRF. */
303: vrf_iter_t
304: vrf_first (void)
305: {
306: struct route_node *rn;
307:
308: for (rn = route_top (vrf_table); rn; rn = route_next (rn))
309: if (rn->info)
310: {
311: route_unlock_node (rn); /* top/next */
312: return (vrf_iter_t)rn;
313: }
314: return VRF_ITER_INVALID;
315: }
316:
317: /* Return the next VRF iterator to the given iterator. */
318: vrf_iter_t
319: vrf_next (vrf_iter_t iter)
320: {
321: struct route_node *rn = NULL;
322:
323: /* Lock it first because route_next() will unlock it. */
324: if (iter != VRF_ITER_INVALID)
325: rn = route_next (route_lock_node ((struct route_node *)iter));
326:
327: for (; rn; rn = route_next (rn))
328: if (rn->info)
329: {
330: route_unlock_node (rn); /* next */
331: return (vrf_iter_t)rn;
332: }
333: return VRF_ITER_INVALID;
334: }
335:
336: /* Return the VRF iterator of the given VRF ID. If it does not exist,
337: * the iterator of the next existing VRF is returned. */
338: vrf_iter_t
339: vrf_iterator (vrf_id_t vrf_id)
340: {
341: struct prefix p;
342: struct route_node *rn;
343:
344: vrf_build_key (vrf_id, &p);
345: rn = route_node_get (vrf_table, &p);
346: if (rn->info)
347: {
348: /* OK, the VRF exists. */
349: route_unlock_node (rn); /* get */
350: return (vrf_iter_t)rn;
351: }
352:
353: /* Find the next VRF. */
354: for (rn = route_next (rn); rn; rn = route_next (rn))
355: if (rn->info)
356: {
357: route_unlock_node (rn); /* next */
358: return (vrf_iter_t)rn;
359: }
360:
361: return VRF_ITER_INVALID;
362: }
363:
364: /* Obtain the VRF ID from the given VRF iterator. */
365: vrf_id_t
366: vrf_iter2id (vrf_iter_t iter)
367: {
368: struct route_node *rn = (struct route_node *) iter;
369: return (rn && rn->info) ? ((struct vrf *)rn->info)->vrf_id : VRF_DEFAULT;
370: }
371:
372: /* Obtain the data pointer from the given VRF iterator. */
373: void *
374: vrf_iter2info (vrf_iter_t iter)
375: {
376: struct route_node *rn = (struct route_node *) iter;
377: return (rn && rn->info) ? ((struct vrf *)rn->info)->info : NULL;
378: }
379:
380: /* Obtain the interface list from the given VRF iterator. */
381: struct list *
382: vrf_iter2iflist (vrf_iter_t iter)
383: {
384: struct route_node *rn = (struct route_node *) iter;
385: return (rn && rn->info) ? ((struct vrf *)rn->info)->iflist : NULL;
386: }
387:
388: /* Get the data pointer of the specified VRF. If not found, create one. */
389: void *
390: vrf_info_get (vrf_id_t vrf_id)
391: {
392: struct vrf *vrf = vrf_get (vrf_id);
393: return vrf->info;
394: }
395:
396: /* Look up the data pointer of the specified VRF. */
397: void *
398: vrf_info_lookup (vrf_id_t vrf_id)
399: {
400: struct vrf *vrf = vrf_lookup (vrf_id);
401: return vrf ? vrf->info : NULL;
402: }
403:
404: /* Look up the interface list in a VRF. */
405: struct list *
406: vrf_iflist (vrf_id_t vrf_id)
407: {
408: struct vrf * vrf = vrf_lookup (vrf_id);
409: return vrf ? vrf->iflist : NULL;
410: }
411:
412: /* Get the interface list of the specified VRF. Create one if not find. */
413: struct list *
414: vrf_iflist_get (vrf_id_t vrf_id)
415: {
416: struct vrf * vrf = vrf_get (vrf_id);
417: return vrf->iflist;
418: }
419:
420: /*
421: * VRF bit-map
422: */
423:
424: #define VRF_BITMAP_NUM_OF_GROUPS 8
425: #define VRF_BITMAP_NUM_OF_BITS_IN_GROUP \
426: (UINT16_MAX / VRF_BITMAP_NUM_OF_GROUPS)
427: #define VRF_BITMAP_NUM_OF_BYTES_IN_GROUP \
428: (VRF_BITMAP_NUM_OF_BITS_IN_GROUP / CHAR_BIT + 1) /* +1 for ensure */
429:
430: #define VRF_BITMAP_GROUP(_id) \
431: ((_id) / VRF_BITMAP_NUM_OF_BITS_IN_GROUP)
432: #define VRF_BITMAP_BIT_OFFSET(_id) \
433: ((_id) % VRF_BITMAP_NUM_OF_BITS_IN_GROUP)
434:
435: #define VRF_BITMAP_INDEX_IN_GROUP(_bit_offset) \
436: ((_bit_offset) / CHAR_BIT)
437: #define VRF_BITMAP_FLAG(_bit_offset) \
438: (((u_char)1) << ((_bit_offset) % CHAR_BIT))
439:
440: struct vrf_bitmap
441: {
442: u_char *groups[VRF_BITMAP_NUM_OF_GROUPS];
443: };
444:
445: vrf_bitmap_t
446: vrf_bitmap_init (void)
447: {
448: return (vrf_bitmap_t) XCALLOC (MTYPE_VRF_BITMAP, sizeof (struct vrf_bitmap));
449: }
450:
451: void
452: vrf_bitmap_free (vrf_bitmap_t bmap)
453: {
454: struct vrf_bitmap *bm = (struct vrf_bitmap *) bmap;
455: int i;
456:
457: if (bmap == VRF_BITMAP_NULL)
458: return;
459:
460: for (i = 0; i < VRF_BITMAP_NUM_OF_GROUPS; i++)
461: if (bm->groups[i])
462: XFREE (MTYPE_VRF_BITMAP, bm->groups[i]);
463:
464: XFREE (MTYPE_VRF_BITMAP, bm);
465: }
466:
467: void
468: vrf_bitmap_set (vrf_bitmap_t bmap, vrf_id_t vrf_id)
469: {
470: struct vrf_bitmap *bm = (struct vrf_bitmap *) bmap;
471: u_char group = VRF_BITMAP_GROUP (vrf_id);
472: u_char offset = VRF_BITMAP_BIT_OFFSET (vrf_id);
473:
474: if (bmap == VRF_BITMAP_NULL)
475: return;
476:
477: if (bm->groups[group] == NULL)
478: bm->groups[group] = XCALLOC (MTYPE_VRF_BITMAP,
479: VRF_BITMAP_NUM_OF_BYTES_IN_GROUP);
480:
481: SET_FLAG (bm->groups[group][VRF_BITMAP_INDEX_IN_GROUP (offset)],
482: VRF_BITMAP_FLAG (offset));
483: }
484:
485: void
486: vrf_bitmap_unset (vrf_bitmap_t bmap, vrf_id_t vrf_id)
487: {
488: struct vrf_bitmap *bm = (struct vrf_bitmap *) bmap;
489: u_char group = VRF_BITMAP_GROUP (vrf_id);
490: u_char offset = VRF_BITMAP_BIT_OFFSET (vrf_id);
491:
492: if (bmap == VRF_BITMAP_NULL || bm->groups[group] == NULL)
493: return;
494:
495: UNSET_FLAG (bm->groups[group][VRF_BITMAP_INDEX_IN_GROUP (offset)],
496: VRF_BITMAP_FLAG (offset));
497: }
498:
499: int
500: vrf_bitmap_check (vrf_bitmap_t bmap, vrf_id_t vrf_id)
501: {
502: struct vrf_bitmap *bm = (struct vrf_bitmap *) bmap;
503: u_char group = VRF_BITMAP_GROUP (vrf_id);
504: u_char offset = VRF_BITMAP_BIT_OFFSET (vrf_id);
505:
506: if (bmap == VRF_BITMAP_NULL || bm->groups[group] == NULL)
507: return 0;
508:
509: return CHECK_FLAG (bm->groups[group][VRF_BITMAP_INDEX_IN_GROUP (offset)],
510: VRF_BITMAP_FLAG (offset)) ? 1 : 0;
511: }
512:
513: /*
514: * VRF realization with NETNS
515: */
516:
517: static char *
518: vrf_netns_pathname (struct vty *vty, const char *name)
519: {
520: static char pathname[PATH_MAX];
521: char *result;
522:
523: if (name[0] == '/') /* absolute pathname */
524: result = realpath (name, pathname);
525: else /* relevant pathname */
526: {
527: char tmp_name[PATH_MAX];
528: snprintf (tmp_name, PATH_MAX, "%s/%s", VRF_RUN_DIR, name);
529: result = realpath (tmp_name, pathname);
530: }
531:
532: if (! result)
533: {
534: vty_out (vty, "Invalid pathname: %s%s", safe_strerror (errno),
535: VTY_NEWLINE);
536: return NULL;
537: }
538: return pathname;
539: }
540:
541: DEFUN (vrf_netns,
542: vrf_netns_cmd,
543: "vrf <1-65535> netns NAME",
544: "Enable a VRF\n"
545: "Specify the VRF identifier\n"
546: "Associate with a NETNS\n"
547: "The file name in " VRF_RUN_DIR ", or a full pathname\n")
548: {
549: vrf_id_t vrf_id = VRF_DEFAULT;
550: struct vrf *vrf = NULL;
551: char *pathname = vrf_netns_pathname (vty, argv[1]);
552:
553: if (!pathname)
554: return CMD_WARNING;
555:
556: VTY_GET_INTEGER ("VRF ID", vrf_id, argv[0]);
557: vrf = vrf_get (vrf_id);
558:
559: if (vrf->name && strcmp (vrf->name, pathname) != 0)
560: {
561: vty_out (vty, "VRF %u is already configured with NETNS %s%s",
562: vrf->vrf_id, vrf->name, VTY_NEWLINE);
563: return CMD_WARNING;
564: }
565:
566: if (!vrf->name)
567: vrf->name = XSTRDUP (MTYPE_VRF_NAME, pathname);
568:
569: if (!vrf_enable (vrf))
570: {
571: vty_out (vty, "Can not associate VRF %u with NETNS %s%s",
572: vrf->vrf_id, vrf->name, VTY_NEWLINE);
573: return CMD_WARNING;
574: }
575:
576: return CMD_SUCCESS;
577: }
578:
579: DEFUN (no_vrf_netns,
580: no_vrf_netns_cmd,
581: "no vrf <1-65535> netns NAME",
582: NO_STR
583: "Enable a VRF\n"
584: "Specify the VRF identifier\n"
585: "Associate with a NETNS\n"
586: "The file name in " VRF_RUN_DIR ", or a full pathname\n")
587: {
588: vrf_id_t vrf_id = VRF_DEFAULT;
589: struct vrf *vrf = NULL;
590: char *pathname = vrf_netns_pathname (vty, argv[1]);
591:
592: if (!pathname)
593: return CMD_WARNING;
594:
595: VTY_GET_INTEGER ("VRF ID", vrf_id, argv[0]);
596: vrf = vrf_lookup (vrf_id);
597:
598: if (!vrf)
599: {
600: vty_out (vty, "VRF %u is not found%s", vrf_id, VTY_NEWLINE);
601: return CMD_SUCCESS;
602: }
603:
604: if (vrf->name && strcmp (vrf->name, pathname) != 0)
605: {
606: vty_out (vty, "Incorrect NETNS file name%s", VTY_NEWLINE);
607: return CMD_WARNING;
608: }
609:
610: vrf_disable (vrf);
611:
612: if (vrf->name)
613: {
614: XFREE (MTYPE_VRF_NAME, vrf->name);
615: vrf->name = NULL;
616: }
617:
618: return CMD_SUCCESS;
619: }
620:
621: /* VRF node. */
622: static struct cmd_node vrf_node =
623: {
624: VRF_NODE,
625: "", /* VRF node has no interface. */
626: 1
627: };
628:
629: /* VRF configuration write function. */
630: static int
631: vrf_config_write (struct vty *vty)
632: {
633: struct route_node *rn;
634: struct vrf *vrf;
635: int write = 0;
636:
637: for (rn = route_top (vrf_table); rn; rn = route_next (rn))
638: if ((vrf = rn->info) != NULL &&
639: vrf->vrf_id != VRF_DEFAULT && vrf->name)
640: {
641: vty_out (vty, "vrf %u netns %s%s", vrf->vrf_id, vrf->name, VTY_NEWLINE);
642: write++;
643: }
644:
645: return write;
646: }
647:
648: /* Initialize VRF module. */
649: void
650: vrf_init (void)
651: {
652: struct vrf *default_vrf;
653:
654: /* Allocate VRF table. */
655: vrf_table = route_table_init ();
656:
657: /* The default VRF always exists. */
658: default_vrf = vrf_get (VRF_DEFAULT);
659: if (!default_vrf)
660: {
661: zlog_err ("vrf_init: failed to create the default VRF!");
662: exit (1);
663: }
664:
665: /* Set the default VRF name. */
666: default_vrf->name = XSTRDUP (MTYPE_VRF_NAME, VRF_DEFAULT_NAME);
667:
668: /* Enable the default VRF. */
669: if (!vrf_enable (default_vrf))
670: {
671: zlog_err ("vrf_init: failed to enable the default VRF!");
672: exit (1);
673: }
674:
675: if (have_netns())
676: {
677: /* Install VRF commands. */
678: install_node (&vrf_node, vrf_config_write);
679: install_element (CONFIG_NODE, &vrf_netns_cmd);
680: install_element (CONFIG_NODE, &no_vrf_netns_cmd);
681: }
682: }
683:
684: /* Terminate VRF module. */
685: void
686: vrf_terminate (void)
687: {
688: struct route_node *rn;
689: struct vrf *vrf;
690:
691: for (rn = route_top (vrf_table); rn; rn = route_next (rn))
692: if ((vrf = rn->info) != NULL)
693: vrf_delete (vrf);
694:
695: route_table_finish (vrf_table);
696: vrf_table = NULL;
697: }
698:
699: /* Create a socket for the VRF. */
700: int
701: vrf_socket (int domain, int type, int protocol, vrf_id_t vrf_id)
702: {
703: struct vrf *vrf = vrf_lookup (vrf_id);
704: int ret = -1;
705:
706: if (!vrf_is_enabled (vrf))
707: {
708: errno = ENOSYS;
709: return -1;
710: }
711:
712: if (have_netns())
713: {
714: ret = (vrf_id != VRF_DEFAULT) ? setns (vrf->fd, CLONE_NEWNET) : 0;
715: if (ret >= 0)
716: {
717: ret = socket (domain, type, protocol);
718: if (vrf_id != VRF_DEFAULT)
719: setns (vrf_lookup (VRF_DEFAULT)->fd, CLONE_NEWNET);
720: }
721: }
722: else
723: ret = socket (domain, type, protocol);
724:
725: return ret;
726: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vrf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib