src/lxc/utils.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #ifndef __LXC_UTILS_H
   4 #define __LXC_UTILS_H
   5
   6 /* Properly support loop devices on 32bit systems. */
   7 #define _FILE_OFFSET_BITS 64
   8
   9 #ifndef MAX_GRBUF_SIZE
  10 #define MAX_GRBUF_SIZE 65536
  11 #endif
  12
  13 #include <errno.h>
  14 #include <linux/loop.h>
  15 #include <linux/types.h>
  16 #include <stdarg.h>
  17 #include <stdbool.h>
  18 #include <stdio.h>
  19 #include <sys/syscall.h>
  20 #include <sys/types.h>
  21 #include <sys/vfs.h>
  22 #include <unistd.h>
  23
  24 #include "file_utils.h"
  25 #include "initutils.h"
  26 #include "macro.h"
  27 #include "memory_utils.h"
  28 #include "raw_syscalls.h"
  29 #include "string_utils.h"
  30
  31 /* returns 1 on success, 0 if there were any failures */
  32 extern int lxc_rmdir_onedev(const char *path, const char *exclude);
  33 extern int get_u16(unsigned short *val, const char *arg, int base);
  34 extern int mkdir_p(const char *dir, mode_t mode);
  35 extern char *get_rundir(void);
  36
  37 /* Define getline() if missing from the C library */
  38 #ifndef HAVE_GETLINE
  39 #ifdef HAVE_FGETLN
  40 #include <../include/getline.h>
  41 #endif
  42 #endif
  43
  44 static inline int lxc_set_cloexec(int fd)
  45 {
  46         return fcntl(fd, F_SETFD, FD_CLOEXEC);
  47 }
  48
  49 /*
  50  * Struct to carry child pid from lxc_popen() to lxc_pclose(). Not an opaque
  51  * struct to allow direct access to the underlying FILE without additional
  52  * wrappers.
  53  */
  54 struct lxc_popen_FILE {
  55         int pipe;
  56         FILE *f;
  57         pid_t child_pid;
  58 };
  59
  60 /* popen(command, "re") replacement that restores default signal mask
  61  * via sigprocmask(2) (unblocks all signals) after fork(2) but prior to calling exec(3).
  62  * In short, popen(command, "re") does pipe() + fork()                 + exec()
  63  * while lxc_popen(command)       does pipe() + fork() + sigprocmask() + exec().
  64  * Returns pointer to struct lxc_popen_FILE, that should be freed with lxc_pclose().
  65  * On error returns NULL.
  66  */
  67 extern struct lxc_popen_FILE *lxc_popen(const char *command);
  68
  69 /* pclose() replacement to be used on struct lxc_popen_FILE *,
  70  * returned by lxc_popen().
  71  * Waits for associated process to terminate, returns its exit status and
  72  * frees resources, pointed to by struct lxc_popen_FILE *.
  73  */
  74 extern int lxc_pclose(struct lxc_popen_FILE *fp);
  75
  76 static inline void __auto_lxc_pclose__(struct lxc_popen_FILE **f)
  77 {
  78         if (*f)
  79                 lxc_pclose(*f);
  80 }
  81 #define __do_lxc_pclose __attribute__((__cleanup__(__auto_lxc_pclose__)))
  82
  83 /*
  84  * wait on a child we forked
  85  */
  86 extern int wait_for_pid(pid_t pid);
  87 extern int lxc_wait_for_pid_status(pid_t pid);
  88 extern int wait_for_pidfd(int pidfd);
  89
  90 #if HAVE_OPENSSL
  91 extern int sha1sum_file(char *fnam, unsigned char *md_value, unsigned int *md_len);
  92 #endif
  93
  94 /* initialize rand with urandom */
  95 extern int randseed(bool);
  96
  97 /* are we unprivileged with respect to our namespaces */
  98 inline static bool am_guest_unpriv(void) {
  99         return geteuid() != 0;
 100 }
 101
 102 /* are we unprivileged with respect to init_user_ns */
 103 inline static bool am_host_unpriv(void)
 104 {
 105         __do_fclose FILE *f = NULL;
 106         uid_t user, host, count;
 107         int ret;
 108
 109         if (geteuid() != 0)
 110                 return true;
 111
 112         /* Now: are we in a user namespace? Because then we're also
 113          * unprivileged.
 114          */
 115         f = fopen("/proc/self/uid_map", "re");
 116         if (!f)
 117                 return false;
 118
 119         ret = fscanf(f, "%u %u %u", &user, &host, &count);
 120         if (ret != 3)
 121                 return false;
 122
 123         return user != 0 || host != 0 || count != UINT32_MAX;
 124 }
 125
 126 /*
 127  * parse /proc/self/uid_map to find what @orig maps to
 128  */
 129 extern uid_t get_ns_uid(uid_t orig);
 130 /*
 131  * parse /proc/self/gid_map to find what @orig maps to
 132  */
 133 extern gid_t get_ns_gid(gid_t orig);
 134
 135 extern bool dir_exists(const char *path);
 136
 137 #define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
 138 extern uint64_t fnv_64a_buf(void *buf, size_t len, uint64_t hval);
 139
 140 extern bool is_shared_mountpoint(const char *path);
 141 extern int detect_shared_rootfs(void);
 142 extern bool detect_ramfs_rootfs(void);
 143 extern char *on_path(const char *cmd, const char *rootfs);
 144 extern bool cgns_supported(void);
 145 extern char *choose_init(const char *rootfs);
 146 extern bool switch_to_ns(pid_t pid, const char *ns);
 147 extern char *get_template_path(const char *t);
 148 extern int safe_mount(const char *src, const char *dest, const char *fstype,
 149                       unsigned long flags, const void *data,
 150                       const char *rootfs);
 151 extern int lxc_mount_proc_if_needed(const char *rootfs);
 152 extern int open_devnull(void);
 153 extern int set_stdfds(int fd);
 154 extern int null_stdfds(void);
 155 extern int lxc_preserve_ns(const int pid, const char *ns);
 156
 157 /* Check whether a signal is blocked by a process. */
 158 extern bool task_blocks_signal(pid_t pid, int signal);
 159
 160 /* Switch to a new uid and gid.
 161  * If LXC_INVALID_{G,U}ID is passed then the set{g,u}id() will not be called.
 162  */
 163 extern bool lxc_switch_uid_gid(uid_t uid, gid_t gid);
 164 extern bool lxc_setgroups(int size, gid_t list[]);
 165
 166 /* Find an unused loop device and associate it with source. */
 167 extern int lxc_prepare_loop_dev(const char *source, char *loop_dev, int flags);
 168
 169 /* Clear all mounts on a given node.
 170  * >= 0 successfully cleared. The number returned is the number of umounts
 171  *      performed.
 172  * < 0  error umounting. Return -errno.
 173  */
 174 extern int lxc_unstack_mountpoint(const char *path, bool lazy);
 175
 176 /*
 177  * run_command runs a command and collect it's std{err,out} output in buf.
 178  *
 179  * @param[out] buf     The buffer where the commands std{err,out] output will be
 180  *                     read into. If no output was produced, buf will be memset
 181  *                     to 0.
 182  * @param[in] buf_size The size of buf. This function will reserve one byte for
 183  *                     \0-termination.
 184  * @param[in] child_fn The function to be run in the child process. This
 185  *                     function must exec.
 186  * @param[in] args     Arguments to be passed to child_fn.
 187  */
 188 extern int run_command(char *buf, size_t buf_size, int (*child_fn)(void *),
 189                        void *args);
 190
 191 /*
 192  * run_command runs a command and collect it's std{err,out} output in buf, returns exit status.
 193  *
 194  * @param[out] buf     The buffer where the commands std{err,out] output will be
 195  *                     read into. If no output was produced, buf will be memset
 196  *                     to 0.
 197  * @param[in] buf_size The size of buf. This function will reserve one byte for
 198  *                     \0-termination.
 199  * @param[in] child_fn The function to be run in the child process. This
 200  *                     function must exec.
 201  * @param[in] args     Arguments to be passed to child_fn.
 202  */
 203 extern int run_command_status(char *buf, size_t buf_size, int (*child_fn)(void *),
 204                        void *args);
 205
 206 /* return copy of string @entry;  do not fail. */
 207 extern char *must_copy_string(const char *entry);
 208
 209 /* Re-allocate a pointer, do not fail */
 210 extern void *must_realloc(void *orig, size_t sz);
 211
 212 extern bool lxc_nic_exists(char *nic);
 213
 214 static inline uint64_t lxc_getpagesize(void)
 215 {
 216         int64_t pgsz;
 217
 218         pgsz = sysconf(_SC_PAGESIZE);
 219         if (pgsz <= 0)
 220                 pgsz = 1 << 12;
 221
 222         return pgsz;
 223 }
 224
 225 /* If n is not a power of 2 this function will return the next power of 2
 226  * greater than that number. Note that this function always returns the *next*
 227  * power of 2 *greater* that number not the *nearest*. For example, passing 1025
 228  * as argument this function will return 2048 although the closest power of 2
 229  * would be 1024.
 230  * If the caller passes in 0 they will receive 0 in return since this is invalid
 231  * input and 0 is not a power of 2.
 232  */
 233 extern uint64_t lxc_find_next_power2(uint64_t n);
 234
 235 /* Set a signal the child process will receive after the parent has died. */
 236 extern int lxc_set_death_signal(int signal, pid_t parent, int parent_status_fd);
 237 extern int fd_cloexec(int fd, bool cloexec);
 238 extern int lxc_rm_rf(const char *dirname);
 239 extern int lxc_setup_keyring(char *keyring_label);
 240 extern bool lxc_can_use_pidfd(int pidfd);
 241
 242 extern int fix_stdio_permissions(uid_t uid);
 243
 244 static inline bool uid_valid(uid_t uid)
 245 {
 246         return uid != LXC_INVALID_UID;
 247 }
 248
 249 static inline bool gid_valid(gid_t gid)
 250 {
 251         return gid != LXC_INVALID_GID;
 252 }
 253
 254 #endif /* __LXC_UTILS_H */