back to topotato report
topotato coverage report
Current view: top level - lib - ns.h (source / functions) Hit Total Coverage
Test: test_pim_basic2.py::PIMTopo2Test Lines: 1 1 100.0 %
Date: 2023-02-24 18:39:36 Functions: 0 0 -

          Line data    Source code
       1             : /*
       2             :  * NS related header.
       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 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
      20             :  */
      21             : 
      22             : #ifndef _ZEBRA_NS_H
      23             : #define _ZEBRA_NS_H
      24             : 
      25             : #include "openbsd-tree.h"
      26             : #include "linklist.h"
      27             : #include "vty.h"
      28             : 
      29             : #ifdef __cplusplus
      30             : extern "C" {
      31             : #endif
      32             : 
      33             : typedef uint32_t ns_id_t;
      34             : 
      35             : /* the default NS ID */
      36             : #define NS_UNKNOWN UINT32_MAX
      37             : 
      38             : /* Default netns directory (Linux) */
      39             : #define NS_RUN_DIR         "/var/run/netns"
      40             : 
      41             : #ifdef HAVE_NETNS
      42             : #define NS_DEFAULT_NAME    "/proc/self/ns/net"
      43             : #else  /* !HAVE_NETNS */
      44             : #define NS_DEFAULT_NAME    "default-netns"
      45             : #endif /* HAVE_NETNS */
      46             : 
      47             : struct ns {
      48             :         RB_ENTRY(ns) entry;
      49             : 
      50             :         /* Identifier, same as the vector index */
      51             :         ns_id_t ns_id;
      52             : 
      53             :         /* Identifier, mapped on the NSID value */
      54             :         ns_id_t internal_ns_id;
      55             : 
      56             :         /* Identifier, value of NSID of default netns,
      57             :          * relative value in that local netns
      58             :          */
      59             :         ns_id_t relative_default_ns;
      60             : 
      61             :         /* Name */
      62             :         char *name;
      63             : 
      64             :         /* File descriptor */
      65             :         int fd;
      66             : 
      67             :         /* Master list of interfaces belonging to this NS */
      68             :         struct list *iflist;
      69             : 
      70             :         /* Back Pointer to VRF */
      71             :         void *vrf_ctxt;
      72             : 
      73             :         /* User data */
      74             :         void *info;
      75             : };
      76             : RB_HEAD(ns_head, ns);
      77          80 : RB_PROTOTYPE(ns_head, ns, entry, ns_compare)
      78             : 
      79             : /*
      80             :  * API for managing NETNS. eg from zebra daemon
      81             :  * one want to manage the list of NETNS, etc...
      82             :  */
      83             : 
      84             : /*
      85             :  * NS hooks
      86             :  */
      87             : 
      88             : #define NS_NEW_HOOK        0   /* a new netns is just created */
      89             : #define NS_DELETE_HOOK     1   /* a netns is to be deleted */
      90             : #define NS_ENABLE_HOOK     2   /* a netns is ready to use */
      91             : #define NS_DISABLE_HOOK    3   /* a netns is to be unusable */
      92             : 
      93             : /*
      94             :  * Add a specific hook ns module.
      95             :  * @param1: hook type
      96             :  * @param2: the callback function
      97             :  *          - param 1: the NS ID
      98             :  *          - param 2: the address of the user data pointer (the user data
      99             :  *                     can be stored in or freed from there)
     100             :  */
     101             : extern void ns_add_hook(int type, int (*)(struct ns *));
     102             : 
     103             : 
     104             : /*
     105             :  * NS initializer/destructor
     106             :  */
     107             : 
     108             : extern void ns_terminate(void);
     109             : 
     110             : /* API to initialize NETNS managerment
     111             :  * parameter is the default ns_id
     112             :  */
     113             : extern void ns_init_management(ns_id_t ns_id, ns_id_t internal_ns_idx);
     114             : 
     115             : 
     116             : /*
     117             :  * NS utilities
     118             :  */
     119             : 
     120             : /* Create a socket serving for the given NS
     121             :  */
     122             : int ns_socket(int domain, int type, int protocol, ns_id_t ns_id);
     123             : 
     124             : /* return the path of the NETNS */
     125             : extern char *ns_netns_pathname(struct vty *vty, const char *name);
     126             : 
     127             : /* Parse and execute a function on all the NETNS */
     128             : #define NS_WALK_CONTINUE 0
     129             : #define NS_WALK_STOP 1
     130             : 
     131             : extern void ns_walk_func(int (*func)(struct ns *,
     132             :                                      void *,
     133             :                                      void **),
     134             :                          void *param_in,
     135             :                          void **param_out);
     136             : 
     137             : /* API to get the NETNS name, from the ns pointer */
     138             : extern const char *ns_get_name(struct ns *ns);
     139             : 
     140             : /* only called from vrf ( when removing netns from vrf)
     141             :  * or at VRF termination
     142             :  */
     143             : extern void ns_delete(struct ns *ns);
     144             : 
     145             : /* return > 0 if netns is available
     146             :  * called by VRF to check netns backend is available for VRF
     147             :  */
     148             : extern int ns_have_netns(void);
     149             : 
     150             : /* API to get context information of a NS */
     151             : extern void *ns_info_lookup(ns_id_t ns_id);
     152             : 
     153             : /* API to map internal ns id value with
     154             :  * user friendly ns id external value
     155             :  */
     156             : extern ns_id_t ns_map_nsid_with_external(ns_id_t ns_id, bool map);
     157             : 
     158             : /*
     159             :  * NS init routine
     160             :  * should be called from backendx
     161             :  */
     162             : extern void ns_init(void);
     163             : 
     164             : #define NS_DEFAULT 0
     165             : 
     166             : /* API that can be used to change from NS */
     167             : extern int ns_switchback_to_initial(void);
     168             : extern int ns_switch_to_netns(const char *netns_name);
     169             : 
     170             : /*
     171             :  * NS handling routines.
     172             :  * called by modules that use NS backend
     173             :  */
     174             : 
     175             : /* API to search for already present NETNS */
     176             : extern struct ns *ns_lookup(ns_id_t ns_id);
     177             : extern struct ns *ns_lookup_name(const char *name);
     178             : 
     179             : /* API to handle NS : creation, enable, disable
     180             :  * for enable, a callback function is passed as parameter
     181             :  * the callback belongs to the module that uses NS as backend
     182             :  * upon enabling the NETNS, the upper layer is informed
     183             :  */
     184             : extern int ns_enable(struct ns *ns, void (*func)(ns_id_t, void *));
     185             : extern struct ns *ns_get_created(struct ns *ns, char *name, ns_id_t ns_id);
     186             : extern ns_id_t ns_id_get_absolute(ns_id_t ns_id_reference, ns_id_t link_nsid);
     187             : extern void ns_disable(struct ns *ns);
     188             : extern struct ns *ns_get_default(void);
     189             : 
     190             : #ifdef __cplusplus
     191             : }
     192             : #endif
     193             : 
     194             : #endif /*_ZEBRA_NS_H*/

Generated by: LCOV version v1.16-topotato