src/shared/nsflags.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2016 Lennart Poettering
   6 ***/
   7
   8 #include <sched.h>
   9
  10 #include "alloc-util.h"
  11 #include "extract-word.h"
  12 #include "nsflags.h"
  13 #include "string-util.h"
  14
  15 const struct namespace_flag_map namespace_flag_map[] = {
  16         { CLONE_NEWCGROUP, "cgroup" },
  17         { CLONE_NEWIPC,    "ipc"    },
  18         { CLONE_NEWNET,    "net"    },
  19         /* So, the mount namespace flag is called CLONE_NEWNS for historical reasons. Let's expose it here under a more
  20          * explanatory name: "mnt". This is in-line with how the kernel exposes namespaces in /proc/$PID/ns. */
  21         { CLONE_NEWNS,     "mnt"    },
  22         { CLONE_NEWPID,    "pid"    },
  23         { CLONE_NEWUSER,   "user"   },
  24         { CLONE_NEWUTS,    "uts"    },
  25         {}
  26 };
  27
  28 const char* namespace_flag_to_string(unsigned long flag) {
  29         unsigned i;
  30
  31         flag &= NAMESPACE_FLAGS_ALL;
  32
  33         for (i = 0; namespace_flag_map[i].name; i++)
  34                 if (flag == namespace_flag_map[i].flag)
  35                         return namespace_flag_map[i].name;
  36
  37         return NULL; /* either unknown namespace flag, or a combination of many. This call supports neither. */
  38 }
  39
  40 unsigned long namespace_flag_from_string(const char *name) {
  41         unsigned i;
  42
  43         if (isempty(name))
  44                 return 0;
  45
  46         for (i = 0; namespace_flag_map[i].name; i++)
  47                 if (streq(name, namespace_flag_map[i].name))
  48                         return namespace_flag_map[i].flag;
  49
  50         return 0;
  51 }
  52
  53 #if 0 /// UNNEEDED by elogind
  54 int namespace_flag_from_string_many(const char *name, unsigned long *ret) {
  55         unsigned long flags = 0;
  56         int r;
  57
  58         assert_se(ret);
  59
  60         for (;;) {
  61                 _cleanup_free_ char *word = NULL;
  62                 unsigned long f;
  63
  64                 r = extract_first_word(&name, &word, NULL, 0);
  65                 if (r < 0)
  66                         return r;
  67                 if (r == 0)
  68                         break;
  69
  70                 f = namespace_flag_from_string(word);
  71                 if (f == 0)
  72                         return -EINVAL;
  73
  74                 flags |= f;
  75         }
  76
  77         *ret = flags;
  78         return 0;
  79 }
  80 #endif // 0
  81
  82 int namespace_flag_to_string_many(unsigned long flags, char **ret) {
  83         _cleanup_free_ char *s = NULL;
  84         unsigned i;
  85
  86         for (i = 0; namespace_flag_map[i].name; i++) {
  87                 if ((flags & namespace_flag_map[i].flag) != namespace_flag_map[i].flag)
  88                         continue;
  89
  90                 if (!s) {
  91                         s = strdup(namespace_flag_map[i].name);
  92                         if (!s)
  93                                 return -ENOMEM;
  94                 } else {
  95                         if (!strextend(&s, " ", namespace_flag_map[i].name, NULL))
  96                                 return -ENOMEM;
  97                 }
  98         }
  99
 100         if (!s) {
 101                 s = strdup("");
 102                 if (!s)
 103                         return -ENOMEM;
 104         }
 105
 106         *ret = TAKE_PTR(s);
 107
 108         return 0;
 109 }