lib/netns_linux.c

   1 /*
   2  * NS 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 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 #include <zebra.h>
  23
  24 #ifdef HAVE_NETNS
  25 #undef _GNU_SOURCE
  26 #define _GNU_SOURCE
  27
  28 #include <sched.h>
  29 #endif
  30
  31 /* for basename */
  32 #include <libgen.h>
  33
  34 #include "if.h"
  35 #include "ns.h"
  36 #include "log.h"
  37 #include "memory.h"
  38 #include "command.h"
  39 #include "vty.h"
  40 #include "vrf.h"
  41 #include "lib_errors.h"
  42
  43 DEFINE_MTYPE_STATIC(LIB, NS, "NetNS Context")
  44 DEFINE_MTYPE_STATIC(LIB, NS_NAME, "NetNS Name")
  45
  46 /* default NS ID value used when VRF backend is not NETNS */
  47 #define NS_DEFAULT_INTERNAL 0
  48
  49 static inline int ns_compare(const struct ns *ns, const struct ns *ns2);
  50 static struct ns *ns_lookup_name_internal(const char *name);
  51
  52 RB_GENERATE(ns_head, ns, entry, ns_compare)
  53
  54 static struct ns_head ns_tree = RB_INITIALIZER(&ns_tree);
  55
  56 static struct ns *default_ns;
  57 static int ns_current_ns_fd;
  58 static int ns_default_ns_fd;
  59
  60 static int ns_debug;
  61
  62 struct ns_map_nsid {
  63         RB_ENTRY(ns_map_nsid) id_entry;
  64         ns_id_t ns_id_external;
  65         ns_id_t ns_id;
  66 };
  67
  68 static inline int ns_map_compare(const struct ns_map_nsid *a,
  69                                    const struct ns_map_nsid *b)
  70 {
  71         return (a->ns_id - b->ns_id);
  72 }
  73
  74 RB_HEAD(ns_map_nsid_head, ns_map_nsid);
  75 RB_PROTOTYPE(ns_map_nsid_head, ns_map_nsid, id_entry, ns_map_compare);
  76 RB_GENERATE(ns_map_nsid_head, ns_map_nsid, id_entry, ns_map_compare);
  77 static struct ns_map_nsid_head ns_map_nsid_list =
  78                 RB_INITIALIZER(&ns_map_nsid_list);
  79
  80 static ns_id_t ns_id_external_numbering;
  81
  82
  83 #ifndef CLONE_NEWNET
  84 #define CLONE_NEWNET 0x40000000
  85 /* New network namespace (lo, device, names sockets, etc) */
  86 #endif
  87
  88 #ifndef HAVE_SETNS
  89 static inline int setns(int fd, int nstype)
  90 {
  91 #ifdef __NR_setns
  92         return syscall(__NR_setns, fd, nstype);
  93 #else
  94         errno = EINVAL;
  95         return -1;
  96 #endif
  97 }
  98 #endif /* !HAVE_SETNS */
  99
 100 #ifdef HAVE_NETNS
 101 static int have_netns_enabled = -1;
 102 #endif /* HAVE_NETNS */
 103
 104 /* default NS ID value used when VRF backend is not NETNS */
 105 #define NS_DEFAULT_INTERNAL 0
 106
 107 static int have_netns(void)
 108 {
 109 #ifdef HAVE_NETNS
 110         if (have_netns_enabled < 0) {
 111                 int fd = open(NS_DEFAULT_NAME, O_RDONLY);
 112
 113                 if (fd < 0)
 114                         have_netns_enabled = 0;
 115                 else {
 116                         have_netns_enabled = 1;
 117                         close(fd);
 118                 }
 119         }
 120         return have_netns_enabled;
 121 #else
 122         return 0;
 123 #endif
 124 }
 125
 126 /* Holding NS hooks  */
 127 static struct ns_master {
 128         int (*ns_new_hook)(struct ns *ns);
 129         int (*ns_delete_hook)(struct ns *ns);
 130         int (*ns_enable_hook)(struct ns *ns);
 131         int (*ns_disable_hook)(struct ns *ns);
 132 } ns_master = {
 133         0,
 134 };
 135
 136 static int ns_is_enabled(struct ns *ns);
 137
 138 static inline int ns_compare(const struct ns *a, const struct ns *b)
 139 {
 140         return (a->ns_id - b->ns_id);
 141 }
 142
 143 /* Look up a NS by identifier. */
 144 static struct ns *ns_lookup_internal(ns_id_t ns_id)
 145 {
 146         struct ns ns;
 147
 148         ns.ns_id = ns_id;
 149         return RB_FIND(ns_head, &ns_tree, &ns);
 150 }
 151
 152 /* Look up a NS by name */
 153 static struct ns *ns_lookup_name_internal(const char *name)
 154 {
 155         struct ns *ns = NULL;
 156
 157         RB_FOREACH (ns, ns_head, &ns_tree) {
 158                 if (ns->name != NULL) {
 159                         if (strcmp(name, ns->name) == 0)
 160                                 return ns;
 161                 }
 162         }
 163         return NULL;
 164 }
 165
 166 static struct ns *ns_get_created_internal(struct ns *ns, char *name,
 167                                           ns_id_t ns_id)
 168 {
 169         int created = 0;
 170         /*
 171          * Initialize interfaces.
 172          */
 173         if (!ns && !name && ns_id != NS_UNKNOWN)
 174                 ns = ns_lookup_internal(ns_id);
 175         if (!ns && name)
 176                 ns = ns_lookup_name_internal(name);
 177         if (!ns) {
 178                 ns = XCALLOC(MTYPE_NS, sizeof(struct ns));
 179                 ns->ns_id = ns_id;
 180                 if (name)
 181                         ns->name = XSTRDUP(MTYPE_NS_NAME, name);
 182                 ns->fd = -1;
 183                 RB_INSERT(ns_head, &ns_tree, ns);
 184                 created = 1;
 185         }
 186         if (ns_id != ns->ns_id) {
 187                 RB_REMOVE(ns_head, &ns_tree, ns);
 188                 ns->ns_id = ns_id;
 189                 RB_INSERT(ns_head, &ns_tree, ns);
 190         }
 191         if (!created)
 192                 return ns;
 193         if (ns_debug) {
 194                 if (ns->ns_id != NS_UNKNOWN)
 195                         zlog_info("NS %u is created.", ns->ns_id);
 196                 else
 197                         zlog_info("NS %s is created.", ns->name);
 198         }
 199         if (ns_master.ns_new_hook)
 200                 (*ns_master.ns_new_hook)(ns);
 201         return ns;
 202 }
 203
 204 /*
 205  * Enable a NS - that is, let the NS be ready to use.
 206  * The NS_ENABLE_HOOK callback will be called to inform
 207  * that they can allocate resources in this NS.
 208  *
 209  * RETURN: 1 - enabled successfully; otherwise, 0.
 210  */
 211 static int ns_enable_internal(struct ns *ns, void (*func)(ns_id_t, void *))
 212 {
 213         if (!ns_is_enabled(ns)) {
 214                 if (have_netns()) {
 215                         ns->fd = open(ns->name, O_RDONLY);
 216                 } else {
 217                         ns->fd = -2;
 218                         /* Remember ns_enable_hook has been called */
 219                         errno = -ENOTSUP;
 220                 }
 221
 222                 if (!ns_is_enabled(ns)) {
 223                         flog_err_sys(EC_LIB_SYSTEM_CALL,
 224                                      "Can not enable NS %u: %s!", ns->ns_id,
 225                                      safe_strerror(errno));
 226                         return 0;
 227                 }
 228
 229                 /* Non default NS. leave */
 230                 if (ns->ns_id == NS_UNKNOWN) {
 231                         flog_err(EC_LIB_NS,
 232                                  "Can not enable NS %s %u: Invalid NSID",
 233                                  ns->name, ns->ns_id);
 234                         return 0;
 235                 }
 236                 if (func)
 237                         func(ns->ns_id, (void *)ns->vrf_ctxt);
 238                 if (ns_debug) {
 239                         if (have_netns())
 240                                 zlog_info("NS %u is associated with NETNS %s.",
 241                                           ns->ns_id, ns->name);
 242                         zlog_info("NS %u is enabled.", ns->ns_id);
 243                 }
 244                 /* zebra first receives NS enable event,
 245                  * then VRF enable event
 246                  */
 247                 if (ns_master.ns_enable_hook)
 248                         (*ns_master.ns_enable_hook)(ns);
 249         }
 250
 251         return 1;
 252 }
 253
 254 /*
 255  * Check whether the NS is enabled - that is, whether the NS
 256  * is ready to allocate resources. Currently there's only one
 257  * type of resource: socket.
 258  */
 259 static int ns_is_enabled(struct ns *ns)
 260 {
 261         if (have_netns())
 262                 return ns && ns->fd >= 0;
 263         else
 264                 return ns && ns->fd == -2 && ns->ns_id == NS_DEFAULT;
 265 }
 266
 267 /*
 268  * Disable a NS - that is, let the NS be unusable.
 269  * The NS_DELETE_HOOK callback will be called to inform
 270  * that they must release the resources in the NS.
 271  */
 272 static void ns_disable_internal(struct ns *ns)
 273 {
 274         if (ns_is_enabled(ns)) {
 275                 if (ns_debug)
 276                         zlog_info("NS %u is to be disabled.", ns->ns_id);
 277
 278                 if (ns_master.ns_disable_hook)
 279                         (*ns_master.ns_disable_hook)(ns);
 280
 281                 if (have_netns())
 282                         close(ns->fd);
 283
 284                 ns->fd = -1;
 285         }
 286 }
 287
 288 /* VRF list existance check by name. */
 289 static struct ns_map_nsid *ns_map_nsid_lookup_by_nsid(ns_id_t ns_id)
 290 {
 291         struct ns_map_nsid ns_map;
 292
 293         ns_map.ns_id = ns_id;
 294         return RB_FIND(ns_map_nsid_head, &ns_map_nsid_list, &ns_map);
 295 }
 296
 297 ns_id_t ns_map_nsid_with_external(ns_id_t ns_id, bool map)
 298 {
 299         struct ns_map_nsid *ns_map;
 300         vrf_id_t ns_id_external;
 301
 302         ns_map = ns_map_nsid_lookup_by_nsid(ns_id);
 303         if (ns_map && !map) {
 304                 ns_id_external = ns_map->ns_id_external;
 305                 RB_REMOVE(ns_map_nsid_head, &ns_map_nsid_list, ns_map);
 306                 return ns_id_external;
 307         }
 308         if (ns_map)
 309                 return ns_map->ns_id_external;
 310         ns_map = XCALLOC(MTYPE_NS, sizeof(struct ns_map_nsid));
 311         /* increase vrf_id
 312          * default vrf is the first one : 0
 313          */
 314         ns_map->ns_id_external = ns_id_external_numbering++;
 315         ns_map->ns_id = ns_id;
 316         RB_INSERT(ns_map_nsid_head, &ns_map_nsid_list, ns_map);
 317         return ns_map->ns_id_external;
 318 }
 319
 320 struct ns *ns_get_created(struct ns *ns, char *name, ns_id_t ns_id)
 321 {
 322         return ns_get_created_internal(ns, name, ns_id);
 323 }
 324
 325 int ns_have_netns(void)
 326 {
 327         return have_netns();
 328 }
 329
 330 /* Delete a NS. This is called in ns_terminate(). */
 331 void ns_delete(struct ns *ns)
 332 {
 333         if (ns_debug)
 334                 zlog_info("NS %u is to be deleted.", ns->ns_id);
 335
 336         ns_disable(ns);
 337
 338         if (ns_master.ns_delete_hook)
 339                 (*ns_master.ns_delete_hook)(ns);
 340
 341         /*
 342          * I'm not entirely sure if the vrf->iflist
 343          * needs to be moved into here or not.
 344          */
 345         // if_terminate (&ns->iflist);
 346
 347         RB_REMOVE(ns_head, &ns_tree, ns);
 348         XFREE(MTYPE_NS_NAME, ns->name);
 349
 350         XFREE(MTYPE_NS, ns);
 351 }
 352
 353 /* Look up the data pointer of the specified VRF. */
 354 void *ns_info_lookup(ns_id_t ns_id)
 355 {
 356         struct ns *ns = ns_lookup_internal(ns_id);
 357
 358         return ns ? ns->info : NULL;
 359 }
 360
 361 /* Look up a NS by name */
 362 struct ns *ns_lookup_name(const char *name)
 363 {
 364         return ns_lookup_name_internal(name);
 365 }
 366
 367 int ns_enable(struct ns *ns, void (*func)(ns_id_t, void *))
 368 {
 369         return ns_enable_internal(ns, func);
 370 }
 371
 372 void ns_disable(struct ns *ns)
 373 {
 374         return ns_disable_internal(ns);
 375 }
 376
 377 struct ns *ns_lookup(ns_id_t ns_id)
 378 {
 379         return ns_lookup_internal(ns_id);
 380 }
 381
 382 void ns_walk_func(int (*func)(struct ns *))
 383 {
 384         struct ns *ns = NULL;
 385
 386         RB_FOREACH (ns, ns_head, &ns_tree)
 387                 func(ns);
 388 }
 389
 390 const char *ns_get_name(struct ns *ns)
 391 {
 392         if (!ns)
 393                 return NULL;
 394         return ns->name;
 395 }
 396
 397 /* Add a NS hook. Please add hooks before calling ns_init(). */
 398 void ns_add_hook(int type, int (*func)(struct ns *))
 399 {
 400         switch (type) {
 401         case NS_NEW_HOOK:
 402                 ns_master.ns_new_hook = func;
 403                 break;
 404         case NS_DELETE_HOOK:
 405                 ns_master.ns_delete_hook = func;
 406                 break;
 407         case NS_ENABLE_HOOK:
 408                 ns_master.ns_enable_hook = func;
 409                 break;
 410         case NS_DISABLE_HOOK:
 411                 ns_master.ns_disable_hook = func;
 412                 break;
 413         default:
 414                 break;
 415         }
 416 }
 417
 418 /*
 419  * NS realization with NETNS
 420  */
 421
 422 char *ns_netns_pathname(struct vty *vty, const char *name)
 423 {
 424         static char pathname[PATH_MAX];
 425         char *result;
 426         char *check_base;
 427
 428         if (name[0] == '/') /* absolute pathname */
 429                 result = realpath(name, pathname);
 430         else {
 431                 /* relevant pathname */
 432                 char tmp_name[PATH_MAX];
 433
 434                 snprintf(tmp_name, PATH_MAX, "%s/%s", NS_RUN_DIR, name);
 435                 result = realpath(tmp_name, pathname);
 436         }
 437
 438         if (!result) {
 439                 if (vty)
 440                         vty_out(vty, "Invalid pathname for %s: %s\n",
 441                                 pathname,
 442                                 safe_strerror(errno));
 443                 else
 444                         flog_warn(EC_LIB_LINUX_NS,
 445                                   "Invalid pathname for %s: %s", pathname,
 446                                   safe_strerror(errno));
 447                 return NULL;
 448         }
 449         check_base = basename(pathname);
 450         if (check_base != NULL && strlen(check_base) + 1 > NS_NAMSIZ) {
 451                 if (vty)
 452                         vty_out(vty, "NS name (%s) invalid: too long (>%d)\n",
 453                                 check_base, NS_NAMSIZ - 1);
 454                 else
 455                         flog_warn(EC_LIB_LINUX_NS,
 456                                   "NS name (%s) invalid: too long (>%d)",
 457                                   check_base, NS_NAMSIZ - 1);
 458                 return NULL;
 459         }
 460         return pathname;
 461 }
 462
 463 void ns_init(void)
 464 {
 465         static int ns_initialised;
 466
 467         ns_debug = 0;
 468         /* silently return as initialisation done */
 469         if (ns_initialised == 1)
 470                 return;
 471         errno = 0;
 472         if (have_netns())
 473                 ns_default_ns_fd = open(NS_DEFAULT_NAME, O_RDONLY);
 474         else {
 475                 ns_default_ns_fd = -1;
 476                 default_ns = NULL;
 477         }
 478         ns_current_ns_fd = -1;
 479         ns_initialised = 1;
 480 }
 481
 482 /* Initialize NS module. */
 483 void ns_init_management(ns_id_t default_ns_id, ns_id_t internal_ns)
 484 {
 485         int fd;
 486
 487         ns_init();
 488         default_ns = ns_get_created_internal(NULL, NULL, default_ns_id);
 489         if (!default_ns) {
 490                 flog_err(EC_LIB_NS, "%s: failed to create the default NS!",
 491                          __func__);
 492                 exit(1);
 493         }
 494         if (have_netns()) {
 495                 fd = open(NS_DEFAULT_NAME, O_RDONLY);
 496                 default_ns->fd = fd;
 497         }
 498         default_ns->internal_ns_id = internal_ns;
 499
 500         /* Set the default NS name. */
 501         default_ns->name = XSTRDUP(MTYPE_NS_NAME, NS_DEFAULT_NAME);
 502         if (ns_debug)
 503                 zlog_info("%s: default NSID is %u", __func__,
 504                           default_ns->ns_id);
 505
 506         /* Enable the default NS. */
 507         if (!ns_enable(default_ns, NULL)) {
 508                 flog_err(EC_LIB_NS, "%s: failed to enable the default NS!",
 509                          __func__);
 510                 exit(1);
 511         }
 512 }
 513
 514 /* Terminate NS module. */
 515 void ns_terminate(void)
 516 {
 517         struct ns *ns;
 518
 519         while (!RB_EMPTY(ns_head, &ns_tree)) {
 520                 ns = RB_ROOT(ns_head, &ns_tree);
 521
 522                 ns_delete(ns);
 523         }
 524 }
 525
 526 int ns_switch_to_netns(const char *name)
 527 {
 528         int ret;
 529         int fd;
 530
 531         if (name == NULL)
 532                 return -1;
 533         if (ns_default_ns_fd == -1)
 534                 return -1;
 535         fd = open(name, O_RDONLY);
 536         if (fd == -1) {
 537                 errno = EINVAL;
 538                 return -1;
 539         }
 540         ret = setns(fd, CLONE_NEWNET);
 541         ns_current_ns_fd = fd;
 542         close(fd);
 543         return ret;
 544 }
 545
 546 /* returns 1 if switch() was not called before
 547  * return status of setns() otherwise
 548  */
 549 int ns_switchback_to_initial(void)
 550 {
 551         if (ns_current_ns_fd != -1 && ns_default_ns_fd != -1) {
 552                 int ret;
 553
 554                 ret = setns(ns_default_ns_fd, CLONE_NEWNET);
 555                 ns_current_ns_fd = -1;
 556                 return ret;
 557         }
 558         /* silently ignore if setns() is not called */
 559         return 1;
 560 }
 561
 562 /* Create a socket for the NS. */
 563 int ns_socket(int domain, int type, int protocol, ns_id_t ns_id)
 564 {
 565         struct ns *ns = ns_lookup(ns_id);
 566         int ret;
 567
 568         if (!ns || !ns_is_enabled(ns)) {
 569                 errno = EINVAL;
 570                 return -1;
 571         }
 572         if (have_netns()) {
 573                 ret = (ns_id != NS_DEFAULT) ? setns(ns->fd, CLONE_NEWNET) : 0;
 574                 if (ret >= 0) {
 575                         ret = socket(domain, type, protocol);
 576                         if (ns_id != NS_DEFAULT) {
 577                                 setns(ns_lookup(NS_DEFAULT)->fd, CLONE_NEWNET);
 578                                 ns_current_ns_fd = ns_id;
 579                         }
 580                 }
 581         } else
 582                 ret = socket(domain, type, protocol);
 583
 584         return ret;
 585 }
 586
 587 ns_id_t ns_get_default_id(void)
 588 {
 589         if (default_ns)
 590                 return default_ns->ns_id;
 591         return NS_DEFAULT_INTERNAL;
 592 }