src/lxc/utils.c

   1 /*
   2  * lxc: linux Container library
   3  *
   4  * (C) Copyright IBM Corp. 2007, 2008
   5  *
   6  * Authors:
   7  * Daniel Lezcano <daniel.lezcano at free.fr>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include "config.h"
  25
  26 #define __STDC_FORMAT_MACROS /* Required for PRIu64 to work. */
  27 #include <ctype.h>
  28 #include <dirent.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <grp.h>
  32 #include <inttypes.h>
  33 #include <libgen.h>
  34 #include <stddef.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39 #include <sys/mman.h>
  40 #include <sys/mount.h>
  41 #include <sys/param.h>
  42 #include <sys/prctl.h>
  43 #include <sys/stat.h>
  44 #include <sys/types.h>
  45 #include <sys/wait.h>
  46
  47 #include "log.h"
  48 #include "lxclock.h"
  49 #include "namespace.h"
  50 #include "parse.h"
  51 #include "utils.h"
  52
  53 #ifndef O_PATH
  54 #define O_PATH      010000000
  55 #endif
  56
  57 #ifndef O_NOFOLLOW
  58 #define O_NOFOLLOW  00400000
  59 #endif
  60
  61 lxc_log_define(lxc_utils, lxc);
  62
  63 /*
  64  * if path is btrfs, tries to remove it and any subvolumes beneath it
  65  */
  66 extern bool btrfs_try_remove_subvol(const char *path);
  67
  68 static int _recursive_rmdir(const char *dirname, dev_t pdev,
  69                             const char *exclude, int level, bool onedev)
  70 {
  71         struct dirent *direntp;
  72         DIR *dir;
  73         int ret, failed=0;
  74         char pathname[MAXPATHLEN];
  75         bool hadexclude = false;
  76
  77         dir = opendir(dirname);
  78         if (!dir) {
  79                 ERROR("failed to open %s", dirname);
  80                 return -1;
  81         }
  82
  83         while ((direntp = readdir(dir))) {
  84                 struct stat mystat;
  85                 int rc;
  86
  87                 if (!direntp)
  88                         break;
  89
  90                 if (!strcmp(direntp->d_name, ".") ||
  91                     !strcmp(direntp->d_name, ".."))
  92                         continue;
  93
  94                 rc = snprintf(pathname, MAXPATHLEN, "%s/%s", dirname, direntp->d_name);
  95                 if (rc < 0 || rc >= MAXPATHLEN) {
  96                         ERROR("pathname too long");
  97                         failed=1;
  98                         continue;
  99                 }
 100
 101                 if (!level && exclude && !strcmp(direntp->d_name, exclude)) {
 102                         ret = rmdir(pathname);
 103                         if (ret < 0) {
 104                                 switch(errno) {
 105                                 case ENOTEMPTY:
 106                                         INFO("Not deleting snapshot %s", pathname);
 107                                         hadexclude = true;
 108                                         break;
 109                                 case ENOTDIR:
 110                                         ret = unlink(pathname);
 111                                         if (ret)
 112                                                 INFO("Failed to remove %s", pathname);
 113                                         break;
 114                                 default:
 115                                         SYSERROR("Failed to rmdir %s", pathname);
 116                                         failed = 1;
 117                                         break;
 118                                 }
 119                         }
 120                         continue;
 121                 }
 122
 123                 ret = lstat(pathname, &mystat);
 124                 if (ret) {
 125                         ERROR("Failed to stat %s", pathname);
 126                         failed = 1;
 127                         continue;
 128                 }
 129                 if (onedev && mystat.st_dev != pdev) {
 130                         /* TODO should we be checking /proc/self/mountinfo for
 131                          * pathname and not doing this if found? */
 132                         if (btrfs_try_remove_subvol(pathname))
 133                                 INFO("Removed btrfs subvolume at %s\n", pathname);
 134                         continue;
 135                 }
 136                 if (S_ISDIR(mystat.st_mode)) {
 137                         if (_recursive_rmdir(pathname, pdev, exclude, level+1, onedev) < 0)
 138                                 failed=1;
 139                 } else {
 140                         if (unlink(pathname) < 0) {
 141                                 SYSERROR("Failed to delete %s", pathname);
 142                                 failed=1;
 143                         }
 144                 }
 145         }
 146
 147         if (rmdir(dirname) < 0 && !btrfs_try_remove_subvol(dirname) && !hadexclude) {
 148                 ERROR("Failed to delete %s", dirname);
 149                 failed=1;
 150         }
 151
 152         ret = closedir(dir);
 153         if (ret) {
 154                 ERROR("Failed to close directory %s", dirname);
 155                 failed=1;
 156         }
 157
 158         return failed ? -1 : 0;
 159 }
 160
 161 /* We have two different magic values for overlayfs, yay. */
 162 #ifndef OVERLAYFS_SUPER_MAGIC
 163 #define OVERLAYFS_SUPER_MAGIC 0x794c764f
 164 #endif
 165
 166 #ifndef OVERLAY_SUPER_MAGIC
 167 #define OVERLAY_SUPER_MAGIC 0x794c7630
 168 #endif
 169
 170 /* In overlayfs, st_dev is unreliable. So on overlayfs we don't do the
 171  * lxc_rmdir_onedev()
 172  */
 173 static bool is_native_overlayfs(const char *path)
 174 {
 175         if (has_fs_type(path, OVERLAY_SUPER_MAGIC) ||
 176             has_fs_type(path, OVERLAYFS_SUPER_MAGIC))
 177                 return true;
 178
 179         return false;
 180 }
 181
 182 /* returns 0 on success, -1 if there were any failures */
 183 extern int lxc_rmdir_onedev(const char *path, const char *exclude)
 184 {
 185         struct stat mystat;
 186         bool onedev = true;
 187
 188         if (is_native_overlayfs(path))
 189                 onedev = false;
 190
 191         if (lstat(path, &mystat) < 0) {
 192                 if (errno == ENOENT)
 193                         return 0;
 194
 195                 ERROR("Failed to stat %s", path);
 196                 return -1;
 197         }
 198
 199         return _recursive_rmdir(path, mystat.st_dev, exclude, 0, onedev);
 200 }
 201
 202 /* borrowed from iproute2 */
 203 extern int get_u16(unsigned short *val, const char *arg, int base)
 204 {
 205         unsigned long res;
 206         char *ptr;
 207
 208         if (!arg || !*arg)
 209                 return -1;
 210
 211         errno = 0;
 212         res = strtoul(arg, &ptr, base);
 213         if (!ptr || ptr == arg || *ptr || res > 0xFFFF || errno != 0)
 214                 return -1;
 215
 216         *val = res;
 217
 218         return 0;
 219 }
 220
 221 extern int mkdir_p(const char *dir, mode_t mode)
 222 {
 223         const char *tmp = dir;
 224         const char *orig = dir;
 225         char *makeme;
 226
 227         do {
 228                 dir = tmp + strspn(tmp, "/");
 229                 tmp = dir + strcspn(dir, "/");
 230                 makeme = strndup(orig, dir - orig);
 231                 if (*makeme) {
 232                         if (mkdir(makeme, mode) && errno != EEXIST) {
 233                                 SYSERROR("failed to create directory '%s'", makeme);
 234                                 free(makeme);
 235                                 return -1;
 236                         }
 237                 }
 238                 free(makeme);
 239         } while(tmp != dir);
 240
 241         return 0;
 242 }
 243
 244 char *get_rundir()
 245 {
 246         char *rundir;
 247         const char *homedir;
 248         struct stat sb;
 249
 250         if (stat(RUNTIME_PATH, &sb) < 0) {
 251                 return NULL;
 252         }
 253
 254         if (geteuid() == sb.st_uid || getegid() == sb.st_gid) {
 255                 rundir = strdup(RUNTIME_PATH);
 256                 return rundir;
 257         }
 258
 259         rundir = getenv("XDG_RUNTIME_DIR");
 260         if (rundir) {
 261                 rundir = strdup(rundir);
 262                 return rundir;
 263         }
 264
 265         INFO("XDG_RUNTIME_DIR isn't set in the environment.");
 266         homedir = getenv("HOME");
 267         if (!homedir) {
 268                 ERROR("HOME isn't set in the environment.");
 269                 return NULL;
 270         }
 271
 272         rundir = malloc(sizeof(char) * (17 + strlen(homedir)));
 273         sprintf(rundir, "%s/.cache/lxc/run/", homedir);
 274
 275         return rundir;
 276 }
 277
 278 int wait_for_pid(pid_t pid)
 279 {
 280         int status, ret;
 281
 282 again:
 283         ret = waitpid(pid, &status, 0);
 284         if (ret == -1) {
 285                 if (errno == EINTR)
 286                         goto again;
 287                 return -1;
 288         }
 289         if (ret != pid)
 290                 goto again;
 291         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
 292                 return -1;
 293         return 0;
 294 }
 295
 296 int lxc_wait_for_pid_status(pid_t pid)
 297 {
 298         int status, ret;
 299
 300 again:
 301         ret = waitpid(pid, &status, 0);
 302         if (ret == -1) {
 303                 if (errno == EINTR)
 304                         goto again;
 305                 return -1;
 306         }
 307         if (ret != pid)
 308                 goto again;
 309         return status;
 310 }
 311
 312 ssize_t lxc_write_nointr(int fd, const void* buf, size_t count)
 313 {
 314         ssize_t ret;
 315 again:
 316         ret = write(fd, buf, count);
 317         if (ret < 0 && errno == EINTR)
 318                 goto again;
 319         return ret;
 320 }
 321
 322 ssize_t lxc_read_nointr(int fd, void* buf, size_t count)
 323 {
 324         ssize_t ret;
 325 again:
 326         ret = read(fd, buf, count);
 327         if (ret < 0 && errno == EINTR)
 328                 goto again;
 329         return ret;
 330 }
 331
 332 ssize_t lxc_read_nointr_expect(int fd, void* buf, size_t count, const void* expected_buf)
 333 {
 334         ssize_t ret;
 335         ret = lxc_read_nointr(fd, buf, count);
 336         if (ret <= 0)
 337                 return ret;
 338         if ((size_t)ret != count)
 339                 return -1;
 340         if (expected_buf && memcmp(buf, expected_buf, count) != 0) {
 341                 errno = EINVAL;
 342                 return -1;
 343         }
 344         return ret;
 345 }
 346
 347 #if HAVE_LIBGNUTLS
 348 #include <gnutls/gnutls.h>
 349 #include <gnutls/crypto.h>
 350
 351 __attribute__((constructor))
 352 static void gnutls_lxc_init(void)
 353 {
 354         gnutls_global_init();
 355 }
 356
 357 int sha1sum_file(char *fnam, unsigned char *digest)
 358 {
 359         char *buf;
 360         int ret;
 361         FILE *f;
 362         long flen;
 363
 364         if (!fnam)
 365                 return -1;
 366         f = fopen_cloexec(fnam, "r");
 367         if (!f) {
 368                 SYSERROR("Error opening template");
 369                 return -1;
 370         }
 371         if (fseek(f, 0, SEEK_END) < 0) {
 372                 SYSERROR("Error seeking to end of template");
 373                 fclose(f);
 374                 return -1;
 375         }
 376         if ((flen = ftell(f)) < 0) {
 377                 SYSERROR("Error telling size of template");
 378                 fclose(f);
 379                 return -1;
 380         }
 381         if (fseek(f, 0, SEEK_SET) < 0) {
 382                 SYSERROR("Error seeking to start of template");
 383                 fclose(f);
 384                 return -1;
 385         }
 386         if ((buf = malloc(flen+1)) == NULL) {
 387                 SYSERROR("Out of memory");
 388                 fclose(f);
 389                 return -1;
 390         }
 391         if (fread(buf, 1, flen, f) != flen) {
 392                 SYSERROR("Failure reading template");
 393                 free(buf);
 394                 fclose(f);
 395                 return -1;
 396         }
 397         if (fclose(f) < 0) {
 398                 SYSERROR("Failre closing template");
 399                 free(buf);
 400                 return -1;
 401         }
 402         buf[flen] = '\0';
 403         ret = gnutls_hash_fast(GNUTLS_DIG_SHA1, buf, flen, (void *)digest);
 404         free(buf);
 405         return ret;
 406 }
 407 #endif
 408
 409 char** lxc_va_arg_list_to_argv(va_list ap, size_t skip, int do_strdup)
 410 {
 411         va_list ap2;
 412         size_t count = 1 + skip;
 413         char **result;
 414
 415         /* first determine size of argument list, we don't want to reallocate
 416          * constantly...
 417          */
 418         va_copy(ap2, ap);
 419         while (1) {
 420                 char* arg = va_arg(ap2, char*);
 421                 if (!arg)
 422                         break;
 423                 count++;
 424         }
 425         va_end(ap2);
 426
 427         result = calloc(count, sizeof(char*));
 428         if (!result)
 429                 return NULL;
 430         count = skip;
 431         while (1) {
 432                 char* arg = va_arg(ap, char*);
 433                 if (!arg)
 434                         break;
 435                 arg = do_strdup ? strdup(arg) : arg;
 436                 if (!arg)
 437                         goto oom;
 438                 result[count++] = arg;
 439         }
 440
 441         /* calloc has already set last element to NULL*/
 442         return result;
 443
 444 oom:
 445         free(result);
 446         return NULL;
 447 }
 448
 449 const char** lxc_va_arg_list_to_argv_const(va_list ap, size_t skip)
 450 {
 451         return (const char**)lxc_va_arg_list_to_argv(ap, skip, 0);
 452 }
 453
 454 struct lxc_popen_FILE *lxc_popen(const char *command)
 455 {
 456         int ret;
 457         int pipe_fds[2];
 458         pid_t child_pid;
 459         struct lxc_popen_FILE *fp = NULL;
 460
 461         ret = pipe2(pipe_fds, O_CLOEXEC);
 462         if (ret < 0)
 463                 return NULL;
 464
 465         child_pid = fork();
 466         if (child_pid < 0)
 467                 goto on_error;
 468
 469         if (!child_pid) {
 470                 sigset_t mask;
 471
 472                 close(pipe_fds[0]);
 473
 474                 /* duplicate stdout */
 475                 if (pipe_fds[1] != STDOUT_FILENO)
 476                         ret = dup2(pipe_fds[1], STDOUT_FILENO);
 477                 else
 478                         ret = fcntl(pipe_fds[1], F_SETFD, 0);
 479                 if (ret < 0) {
 480                         close(pipe_fds[1]);
 481                         _exit(EXIT_FAILURE);
 482                 }
 483
 484                 /* duplicate stderr */
 485                 if (pipe_fds[1] != STDERR_FILENO)
 486                         ret = dup2(pipe_fds[1], STDERR_FILENO);
 487                 else
 488                         ret = fcntl(pipe_fds[1], F_SETFD, 0);
 489                 close(pipe_fds[1]);
 490                 if (ret < 0)
 491                         _exit(EXIT_FAILURE);
 492
 493                 /* unblock all signals */
 494                 ret = sigfillset(&mask);
 495                 if (ret < 0)
 496                         _exit(EXIT_FAILURE);
 497
 498                 ret = sigprocmask(SIG_UNBLOCK, &mask, NULL);
 499                 if (ret < 0)
 500                         _exit(EXIT_FAILURE);
 501
 502                 execl("/bin/sh", "sh", "-c", command, (char *)NULL);
 503                 _exit(127);
 504         }
 505
 506         close(pipe_fds[1]);
 507         pipe_fds[1] = -1;
 508
 509         fp = malloc(sizeof(*fp));
 510         if (!fp)
 511                 goto on_error;
 512         memset(fp, 0, sizeof(*fp));
 513
 514         fp->child_pid = child_pid;
 515         fp->pipe = pipe_fds[0];
 516
 517         /* From now on, closing fp->f will also close fp->pipe. So only ever
 518          * call fclose(fp->f).
 519          */
 520         fp->f = fdopen(pipe_fds[0], "r");
 521         if (!fp->f)
 522                 goto on_error;
 523
 524         return fp;
 525
 526 on_error:
 527         /* We can only close pipe_fds[0] if fdopen() didn't succeed or wasn't
 528          * called yet. Otherwise the fd belongs to the file opened by fdopen()
 529          * since it isn't dup()ed.
 530          */
 531         if (fp && !fp->f && pipe_fds[0] >= 0)
 532                 close(pipe_fds[0]);
 533
 534         if (pipe_fds[1] >= 0)
 535                 close(pipe_fds[1]);
 536
 537         if (fp && fp->f)
 538                 fclose(fp->f);
 539
 540         if (fp)
 541                 free(fp);
 542
 543         return NULL;
 544 }
 545
 546 int lxc_pclose(struct lxc_popen_FILE *fp)
 547 {
 548         pid_t wait_pid;
 549         int wstatus = 0;
 550
 551         if (!fp)
 552                 return -1;
 553
 554         do {
 555                 wait_pid = waitpid(fp->child_pid, &wstatus, 0);
 556         } while (wait_pid < 0 && errno == EINTR);
 557
 558         fclose(fp->f);
 559         free(fp);
 560
 561         if (wait_pid < 0)
 562                 return -1;
 563
 564         return wstatus;
 565 }
 566
 567 char *lxc_string_replace(const char *needle, const char *replacement, const char *haystack)
 568 {
 569         ssize_t len = -1, saved_len = -1;
 570         char *result = NULL;
 571         size_t replacement_len = strlen(replacement);
 572         size_t needle_len = strlen(needle);
 573
 574         /* should be executed exactly twice */
 575         while (len == -1 || result == NULL) {
 576                 char *p;
 577                 char *last_p;
 578                 ssize_t part_len;
 579
 580                 if (len != -1) {
 581                         result = calloc(1, len + 1);
 582                         if (!result)
 583                                 return NULL;
 584                         saved_len = len;
 585                 }
 586
 587                 len = 0;
 588
 589                 for (last_p = (char *)haystack, p = strstr(last_p, needle); p; last_p = p, p = strstr(last_p, needle)) {
 590                         part_len = (ssize_t)(p - last_p);
 591                         if (result && part_len > 0)
 592                                 memcpy(&result[len], last_p, part_len);
 593                         len += part_len;
 594                         if (result && replacement_len > 0)
 595                                 memcpy(&result[len], replacement, replacement_len);
 596                         len += replacement_len;
 597                         p += needle_len;
 598                 }
 599                 part_len = strlen(last_p);
 600                 if (result && part_len > 0)
 601                         memcpy(&result[len], last_p, part_len);
 602                 len += part_len;
 603         }
 604
 605         /* make sure we did the same thing twice,
 606          * once for calculating length, the other
 607          * time for copying data */
 608         if (saved_len != len) {
 609                 free(result);
 610                 return NULL;
 611         }
 612         /* make sure we didn't overwrite any buffer,
 613          * due to calloc the string should be 0-terminated */
 614         if (result[len] != '\0') {
 615                 free(result);
 616                 return NULL;
 617         }
 618
 619         return result;
 620 }
 621
 622 bool lxc_string_in_array(const char *needle, const char **haystack)
 623 {
 624         for (; haystack && *haystack; haystack++)
 625                 if (!strcmp(needle, *haystack))
 626                         return true;
 627         return false;
 628 }
 629
 630 char *lxc_string_join(const char *sep, const char **parts, bool use_as_prefix)
 631 {
 632         char *result;
 633         char **p;
 634         size_t sep_len = strlen(sep);
 635         size_t result_len = use_as_prefix * sep_len;
 636
 637         /* calculate new string length */
 638         for (p = (char **)parts; *p; p++)
 639                 result_len += (p > (char **)parts) * sep_len + strlen(*p);
 640
 641         result = calloc(result_len + 1, 1);
 642         if (!result)
 643                 return NULL;
 644
 645         if (use_as_prefix)
 646                 strcpy(result, sep);
 647         for (p = (char **)parts; *p; p++) {
 648                 if (p > (char **)parts)
 649                         strcat(result, sep);
 650                 strcat(result, *p);
 651         }
 652
 653         return result;
 654 }
 655
 656 char **lxc_normalize_path(const char *path)
 657 {
 658         char **components;
 659         char **p;
 660         size_t components_len = 0;
 661         size_t pos = 0;
 662
 663         components = lxc_string_split(path, '/');
 664         if (!components)
 665                 return NULL;
 666         for (p = components; *p; p++)
 667                 components_len++;
 668
 669         /* resolve '.' and '..' */
 670         for (pos = 0; pos < components_len; ) {
 671                 if (!strcmp(components[pos], ".") || (!strcmp(components[pos], "..") && pos == 0)) {
 672                         /* eat this element */
 673                         free(components[pos]);
 674                         memmove(&components[pos], &components[pos+1], sizeof(char *) * (components_len - pos));
 675                         components_len--;
 676                 } else if (!strcmp(components[pos], "..")) {
 677                         /* eat this and the previous element */
 678                         free(components[pos - 1]);
 679                         free(components[pos]);
 680                         memmove(&components[pos-1], &components[pos+1], sizeof(char *) * (components_len - pos));
 681                         components_len -= 2;
 682                         pos--;
 683                 } else {
 684                         pos++;
 685                 }
 686         }
 687
 688         return components;
 689 }
 690
 691 char *lxc_deslashify(const char *path)
 692 {
 693         char *dup, *p;
 694         char **parts = NULL;
 695         size_t n, len;
 696
 697         dup = strdup(path);
 698         if (!dup)
 699                 return NULL;
 700
 701         parts = lxc_normalize_path(dup);
 702         if (!parts) {
 703                 free(dup);
 704                 return NULL;
 705         }
 706
 707         /* We'll end up here if path == "///" or path == "". */
 708         if (!*parts) {
 709                 len = strlen(dup);
 710                 if (!len) {
 711                         lxc_free_array((void **)parts, free);
 712                         return dup;
 713                 }
 714                 n = strcspn(dup, "/");
 715                 if (n == len) {
 716                         free(dup);
 717                         lxc_free_array((void **)parts, free);
 718
 719                         p = strdup("/");
 720                         if (!p)
 721                                 return NULL;
 722
 723                         return p;
 724                 }
 725         }
 726
 727         p = lxc_string_join("/", (const char **)parts, *dup == '/');
 728         free(dup);
 729         lxc_free_array((void **)parts, free);
 730         return p;
 731 }
 732
 733 char *lxc_append_paths(const char *first, const char *second)
 734 {
 735         int ret;
 736         size_t len;
 737         char *result = NULL;
 738         const char *pattern = "%s%s";
 739
 740         len = strlen(first) + strlen(second) + 1;
 741         if (second[0] != '/') {
 742                 len += 1;
 743                 pattern = "%s/%s";
 744         }
 745
 746         result = calloc(1, len);
 747         if (!result)
 748                 return NULL;
 749
 750         ret = snprintf(result, len, pattern, first, second);
 751         if (ret < 0 || (size_t)ret >= len) {
 752                 free(result);
 753                 return NULL;
 754         }
 755
 756         return result;
 757 }
 758
 759 bool lxc_string_in_list(const char *needle, const char *haystack, char _sep)
 760 {
 761         char *token, *str, *saveptr = NULL;
 762         char sep[2] = { _sep, '\0' };
 763
 764         if (!haystack || !needle)
 765                 return 0;
 766
 767         str = alloca(strlen(haystack)+1);
 768         strcpy(str, haystack);
 769         for (; (token = strtok_r(str, sep, &saveptr)); str = NULL) {
 770                 if (strcmp(needle, token) == 0)
 771                         return 1;
 772         }
 773
 774         return 0;
 775 }
 776
 777 char **lxc_string_split(const char *string, char _sep)
 778 {
 779         char *token, *str, *saveptr = NULL;
 780         char sep[2] = {_sep, '\0'};
 781         char **tmp = NULL, **result = NULL;
 782         size_t result_capacity = 0;
 783         size_t result_count = 0;
 784         int r, saved_errno;
 785
 786         if (!string)
 787                 return calloc(1, sizeof(char *));
 788
 789         str = alloca(strlen(string) + 1);
 790         strcpy(str, string);
 791         for (; (token = strtok_r(str, sep, &saveptr)); str = NULL) {
 792                 r = lxc_grow_array((void ***)&result, &result_capacity, result_count + 1, 16);
 793                 if (r < 0)
 794                         goto error_out;
 795                 result[result_count] = strdup(token);
 796                 if (!result[result_count])
 797                         goto error_out;
 798                 result_count++;
 799         }
 800
 801         /* if we allocated too much, reduce it */
 802         tmp = realloc(result, (result_count + 1) * sizeof(char *));
 803         if (!tmp)
 804                 goto error_out;
 805         result = tmp;
 806         /* Make sure we don't return uninitialized memory. */
 807         if (result_count == 0)
 808                 *result = NULL;
 809         return result;
 810 error_out:
 811         saved_errno = errno;
 812         lxc_free_array((void **)result, free);
 813         errno = saved_errno;
 814         return NULL;
 815 }
 816
 817 static bool complete_word(char ***result, char *start, char *end, size_t *cap, size_t *cnt)
 818 {
 819         int r;
 820
 821         r = lxc_grow_array((void ***)result, cap, 2 + *cnt, 16);
 822         if (r < 0)
 823                 return false;
 824         (*result)[*cnt] = strndup(start, end - start);
 825         if (!(*result)[*cnt])
 826                 return false;
 827         (*cnt)++;
 828
 829         return true;
 830 }
 831
 832 /*
 833  * Given a a string 'one two "three four"', split into three words,
 834  * one, two, and "three four"
 835  */
 836 char **lxc_string_split_quoted(char *string)
 837 {
 838         char *nextword = string, *p, state;
 839         char **result = NULL;
 840         size_t result_capacity = 0;
 841         size_t result_count = 0;
 842
 843         if (!string || !*string)
 844                 return calloc(1, sizeof(char *));
 845
 846         // TODO I'm *not* handling escaped quote
 847         state = ' ';
 848         for (p = string; *p; p++) {
 849                 switch(state) {
 850                 case ' ':
 851                         if (isspace(*p))
 852                                 continue;
 853                         else if (*p == '"' || *p == '\'') {
 854                                 nextword = p;
 855                                 state = *p;
 856                                 continue;
 857                         }
 858                         nextword = p;
 859                         state = 'a';
 860                         continue;
 861                 case 'a':
 862                         if (isspace(*p)) {
 863                                 complete_word(&result, nextword, p, &result_capacity, &result_count);
 864                                 state = ' ';
 865                                 continue;
 866                         }
 867                         continue;
 868                 case '"':
 869                 case '\'':
 870                         if (*p == state) {
 871                                 complete_word(&result, nextword+1, p, &result_capacity, &result_count);
 872                                 state = ' ';
 873                                 continue;
 874                         }
 875                         continue;
 876                 }
 877         }
 878
 879         if (state == 'a')
 880                 complete_word(&result, nextword, p, &result_capacity, &result_count);
 881
 882         return realloc(result, (result_count + 1) * sizeof(char *));
 883 }
 884
 885 char **lxc_string_split_and_trim(const char *string, char _sep)
 886 {
 887         char *token, *str, *saveptr = NULL;
 888         char sep[2] = { _sep, '\0' };
 889         char **result = NULL;
 890         size_t result_capacity = 0;
 891         size_t result_count = 0;
 892         int r, saved_errno;
 893         size_t i = 0;
 894
 895         if (!string)
 896                 return calloc(1, sizeof(char *));
 897
 898         str = alloca(strlen(string)+1);
 899         strcpy(str, string);
 900         for (; (token = strtok_r(str, sep, &saveptr)); str = NULL) {
 901                 while (token[0] == ' ' || token[0] == '\t')
 902                         token++;
 903                 i = strlen(token);
 904                 while (i > 0 && (token[i - 1] == ' ' || token[i - 1] == '\t')) {
 905                         token[i - 1] = '\0';
 906                         i--;
 907                 }
 908                 r = lxc_grow_array((void ***)&result, &result_capacity, result_count + 1, 16);
 909                 if (r < 0)
 910                         goto error_out;
 911                 result[result_count] = strdup(token);
 912                 if (!result[result_count])
 913                         goto error_out;
 914                 result_count++;
 915         }
 916
 917         /* if we allocated too much, reduce it */
 918         return realloc(result, (result_count + 1) * sizeof(char *));
 919 error_out:
 920         saved_errno = errno;
 921         lxc_free_array((void **)result, free);
 922         errno = saved_errno;
 923         return NULL;
 924 }
 925
 926 void lxc_free_array(void **array, lxc_free_fn element_free_fn)
 927 {
 928         void **p;
 929         for (p = array; p && *p; p++)
 930                 element_free_fn(*p);
 931         free((void*)array);
 932 }
 933
 934 int lxc_grow_array(void ***array, size_t* capacity, size_t new_size, size_t capacity_increment)
 935 {
 936         size_t new_capacity;
 937         void **new_array;
 938
 939         /* first time around, catch some trivial mistakes of the user
 940          * only initializing one of these */
 941         if (!*array || !*capacity) {
 942                 *array = NULL;
 943                 *capacity = 0;
 944         }
 945
 946         new_capacity = *capacity;
 947         while (new_size + 1 > new_capacity)
 948                 new_capacity += capacity_increment;
 949         if (new_capacity != *capacity) {
 950                 /* we have to reallocate */
 951                 new_array = realloc(*array, new_capacity * sizeof(void *));
 952                 if (!new_array)
 953                         return -1;
 954                 memset(&new_array[*capacity], 0, (new_capacity - (*capacity)) * sizeof(void *));
 955                 *array = new_array;
 956                 *capacity = new_capacity;
 957         }
 958
 959         /* array has sufficient elements */
 960         return 0;
 961 }
 962
 963 size_t lxc_array_len(void **array)
 964 {
 965         void **p;
 966         size_t result = 0;
 967
 968         for (p = array; p && *p; p++)
 969                 result++;
 970
 971         return result;
 972 }
 973
 974 int lxc_write_to_file(const char *filename, const void *buf, size_t count,
 975                       bool add_newline, mode_t mode)
 976 {
 977         int fd, saved_errno;
 978         ssize_t ret;
 979
 980         fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT | O_CLOEXEC, mode);
 981         if (fd < 0)
 982                 return -1;
 983         ret = lxc_write_nointr(fd, buf, count);
 984         if (ret < 0)
 985                 goto out_error;
 986         if ((size_t)ret != count)
 987                 goto out_error;
 988         if (add_newline) {
 989                 ret = lxc_write_nointr(fd, "\n", 1);
 990                 if (ret != 1)
 991                         goto out_error;
 992         }
 993         close(fd);
 994         return 0;
 995
 996 out_error:
 997         saved_errno = errno;
 998         close(fd);
 999         errno = saved_errno;
1000         return -1;
1001 }
1002
1003 int lxc_read_from_file(const char *filename, void* buf, size_t count)
1004 {
1005         int fd = -1, saved_errno;
1006         ssize_t ret;
1007
1008         fd = open(filename, O_RDONLY | O_CLOEXEC);
1009         if (fd < 0)
1010                 return -1;
1011
1012         if (!buf || !count) {
1013                 char buf2[100];
1014                 size_t count2 = 0;
1015                 while ((ret = read(fd, buf2, 100)) > 0)
1016                         count2 += ret;
1017                 if (ret >= 0)
1018                         ret = count2;
1019         } else {
1020                 memset(buf, 0, count);
1021                 ret = read(fd, buf, count);
1022         }
1023
1024         if (ret < 0)
1025                 ERROR("read %s: %s", filename, strerror(errno));
1026
1027         saved_errno = errno;
1028         close(fd);
1029         errno = saved_errno;
1030         return ret;
1031 }
1032
1033 void **lxc_append_null_to_array(void **array, size_t count)
1034 {
1035         void **temp;
1036
1037         /* Append NULL to the array */
1038         if (count) {
1039                 temp = realloc(array, (count + 1) * sizeof(*array));
1040                 if (!temp) {
1041                         size_t i;
1042                         for (i = 0; i < count; i++)
1043                                 free(array[i]);
1044                         free(array);
1045                         return NULL;
1046                 }
1047                 array = temp;
1048                 array[count] = NULL;
1049         }
1050         return array;
1051 }
1052
1053 int randseed(bool srand_it)
1054 {
1055         /*
1056            srand pre-seed function based on /dev/urandom
1057            */
1058         unsigned int seed = time(NULL) + getpid();
1059
1060         FILE *f;
1061         f = fopen("/dev/urandom", "r");
1062         if (f) {
1063                 int ret = fread(&seed, sizeof(seed), 1, f);
1064                 if (ret != 1)
1065                         DEBUG("unable to fread /dev/urandom, %s, fallback to time+pid rand seed", strerror(errno));
1066                 fclose(f);
1067         }
1068
1069         if (srand_it)
1070                 srand(seed);
1071
1072         return seed;
1073 }
1074
1075 uid_t get_ns_uid(uid_t orig)
1076 {
1077         char *line = NULL;
1078         size_t sz = 0;
1079         uid_t nsid, hostid, range;
1080         FILE *f = fopen("/proc/self/uid_map", "r");
1081         if (!f)
1082                 return 0;
1083
1084         while (getline(&line, &sz, f) != -1) {
1085                 if (sscanf(line, "%u %u %u", &nsid, &hostid, &range) != 3)
1086                         continue;
1087                 if (hostid <= orig && hostid + range > orig) {
1088                         nsid += orig - hostid;
1089                         goto found;
1090                 }
1091         }
1092
1093         nsid = 0;
1094 found:
1095         fclose(f);
1096         free(line);
1097         return nsid;
1098 }
1099
1100 bool dir_exists(const char *path)
1101 {
1102         struct stat sb;
1103         int ret;
1104
1105         ret = stat(path, &sb);
1106         if (ret < 0)
1107                 /* Could be something other than eexist, just say "no". */
1108                 return false;
1109         return S_ISDIR(sb.st_mode);
1110 }
1111
1112 /* Note we don't use SHA-1 here as we don't want to depend on HAVE_GNUTLS.
1113  * FNV has good anti collision properties and we're not worried
1114  * about pre-image resistance or one-way-ness, we're just trying to make
1115  * the name unique in the 108 bytes of space we have.
1116  */
1117 uint64_t fnv_64a_buf(void *buf, size_t len, uint64_t hval)
1118 {
1119         unsigned char *bp;
1120
1121         for(bp = buf; bp < (unsigned char *)buf + len; bp++)
1122         {
1123                 /* xor the bottom with the current octet */
1124                 hval ^= (uint64_t)*bp;
1125
1126                 /* gcc optimised:
1127                  * multiply by the 64 bit FNV magic prime mod 2^64
1128                  */
1129                 hval += (hval << 1) + (hval << 4) + (hval << 5) +
1130                         (hval << 7) + (hval << 8) + (hval << 40);
1131         }
1132
1133         return hval;
1134 }
1135
1136 /*
1137  * Detect whether / is mounted MS_SHARED.  The only way I know of to
1138  * check that is through /proc/self/mountinfo.
1139  * I'm only checking for /.  If the container rootfs or mount location
1140  * is MS_SHARED, but not '/', then you're out of luck - figuring that
1141  * out would be too much work to be worth it.
1142  */
1143 int detect_shared_rootfs(void)
1144 {
1145         char buf[LXC_LINELEN], *p;
1146         FILE *f;
1147         int i;
1148         char *p2;
1149
1150         f = fopen("/proc/self/mountinfo", "r");
1151         if (!f)
1152                 return 0;
1153         while (fgets(buf, LXC_LINELEN, f)) {
1154                 for (p = buf, i = 0; p && i < 4; i++)
1155                         p = strchr(p + 1, ' ');
1156                 if (!p)
1157                         continue;
1158                 p2 = strchr(p + 1, ' ');
1159                 if (!p2)
1160                         continue;
1161                 *p2 = '\0';
1162                 if (strcmp(p + 1, "/") == 0) {
1163                         /* This is '/'. Is it shared? */
1164                         p = strchr(p2 + 1, ' ');
1165                         if (p && strstr(p, "shared:")) {
1166                                 fclose(f);
1167                                 return 1;
1168                         }
1169                 }
1170         }
1171         fclose(f);
1172         return 0;
1173 }
1174
1175 bool switch_to_ns(pid_t pid, const char *ns) {
1176         int fd, ret;
1177         char nspath[MAXPATHLEN];
1178
1179         /* Switch to new ns */
1180         ret = snprintf(nspath, MAXPATHLEN, "/proc/%d/ns/%s", pid, ns);
1181         if (ret < 0 || ret >= MAXPATHLEN)
1182                 return false;
1183
1184         fd = open(nspath, O_RDONLY);
1185         if (fd < 0) {
1186                 SYSERROR("failed to open %s", nspath);
1187                 return false;
1188         }
1189
1190         ret = setns(fd, 0);
1191         if (ret) {
1192                 SYSERROR("failed to set process %d to %s of %d.", pid, ns, fd);
1193                 close(fd);
1194                 return false;
1195         }
1196         close(fd);
1197         return true;
1198 }
1199
1200 /*
1201  * looking at fs/proc_namespace.c, it appears we can
1202  * actually expect the rootfs entry to very specifically contain
1203  * " - rootfs rootfs "
1204  * IIUC, so long as we've chrooted so that rootfs is not our root,
1205  * the rootfs entry should always be skipped in mountinfo contents.
1206  */
1207 bool detect_ramfs_rootfs(void)
1208 {
1209         FILE *f;
1210         char *p, *p2;
1211         char *line = NULL;
1212         size_t len = 0;
1213         int i;
1214
1215         f = fopen("/proc/self/mountinfo", "r");
1216         if (!f)
1217                 return false;
1218
1219         while (getline(&line, &len, f) != -1) {
1220                 for (p = line, i = 0; p && i < 4; i++)
1221                         p = strchr(p + 1, ' ');
1222                 if (!p)
1223                         continue;
1224                 p2 = strchr(p + 1, ' ');
1225                 if (!p2)
1226                         continue;
1227                 *p2 = '\0';
1228                 if (strcmp(p + 1, "/") == 0) {
1229                         /* This is '/'. Is it the ramfs? */
1230                         p = strchr(p2 + 1, '-');
1231                         if (p && strncmp(p, "- rootfs rootfs ", 16) == 0) {
1232                                 free(line);
1233                                 fclose(f);
1234                                 return true;
1235                         }
1236                 }
1237         }
1238         free(line);
1239         fclose(f);
1240         return false;
1241 }
1242
1243 char *on_path(const char *cmd, const char *rootfs) {
1244         char *path = NULL;
1245         char *entry = NULL;
1246         char *saveptr = NULL;
1247         char cmdpath[MAXPATHLEN];
1248         int ret;
1249
1250         path = getenv("PATH");
1251         if (!path)
1252                 return NULL;
1253
1254         path = strdup(path);
1255         if (!path)
1256                 return NULL;
1257
1258         entry = strtok_r(path, ":", &saveptr);
1259         while (entry) {
1260                 if (rootfs)
1261                         ret = snprintf(cmdpath, MAXPATHLEN, "%s/%s/%s", rootfs, entry, cmd);
1262                 else
1263                         ret = snprintf(cmdpath, MAXPATHLEN, "%s/%s", entry, cmd);
1264
1265                 if (ret < 0 || ret >= MAXPATHLEN)
1266                         goto next_loop;
1267
1268                 if (access(cmdpath, X_OK) == 0) {
1269                         free(path);
1270                         return strdup(cmdpath);
1271                 }
1272
1273 next_loop:
1274                 entry = strtok_r(NULL, ":", &saveptr);
1275         }
1276
1277         free(path);
1278         return NULL;
1279 }
1280
1281 bool file_exists(const char *f)
1282 {
1283         struct stat statbuf;
1284
1285         return stat(f, &statbuf) == 0;
1286 }
1287
1288 bool cgns_supported(void)
1289 {
1290         return file_exists("/proc/self/ns/cgroup");
1291 }
1292
1293 /* historically lxc-init has been under /usr/lib/lxc and under
1294  * /usr/lib/$ARCH/lxc.  It now lives as $prefix/sbin/init.lxc.
1295  */
1296 char *choose_init(const char *rootfs)
1297 {
1298         char *retv = NULL;
1299         const char *empty = "",
1300                    *tmp;
1301         int ret, env_set = 0;
1302
1303         if (!getenv("PATH")) {
1304                 if (setenv("PATH", "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", 0))
1305                         SYSERROR("Failed to setenv");
1306                 env_set = 1;
1307         }
1308
1309         retv = on_path("init.lxc", rootfs);
1310
1311         if (env_set) {
1312                 if (unsetenv("PATH"))
1313                         SYSERROR("Failed to unsetenv");
1314         }
1315
1316         if (retv)
1317                 return retv;
1318
1319         retv = malloc(PATH_MAX);
1320         if (!retv)
1321                 return NULL;
1322
1323         if (rootfs)
1324                 tmp = rootfs;
1325         else
1326                 tmp = empty;
1327
1328         ret = snprintf(retv, PATH_MAX, "%s/%s/%s", tmp, SBINDIR, "/init.lxc");
1329         if (ret < 0 || ret >= PATH_MAX) {
1330                 ERROR("pathname too long");
1331                 goto out1;
1332         }
1333         if (access(retv, X_OK) == 0)
1334                 return retv;
1335
1336         ret = snprintf(retv, PATH_MAX, "%s/%s/%s", tmp, LXCINITDIR, "/lxc/lxc-init");
1337         if (ret < 0 || ret >= PATH_MAX) {
1338                 ERROR("pathname too long");
1339                 goto out1;
1340         }
1341         if (access(retv, X_OK) == 0)
1342                 return retv;
1343
1344         ret = snprintf(retv, PATH_MAX, "%s/usr/lib/lxc/lxc-init", tmp);
1345         if (ret < 0 || ret >= PATH_MAX) {
1346                 ERROR("pathname too long");
1347                 goto out1;
1348         }
1349         if (access(retv, X_OK) == 0)
1350                 return retv;
1351
1352         ret = snprintf(retv, PATH_MAX, "%s/sbin/lxc-init", tmp);
1353         if (ret < 0 || ret >= PATH_MAX) {
1354                 ERROR("pathname too long");
1355                 goto out1;
1356         }
1357         if (access(retv, X_OK) == 0)
1358                 return retv;
1359
1360         /*
1361          * Last resort, look for the statically compiled init.lxc which we
1362          * hopefully bind-mounted in.
1363          * If we are called during container setup, and we get to this point,
1364          * then the init.lxc.static from the host will need to be bind-mounted
1365          * in.  So we return NULL here to indicate that.
1366          */
1367         if (rootfs)
1368                 goto out1;
1369
1370         ret = snprintf(retv, PATH_MAX, "/init.lxc.static");
1371         if (ret < 0 || ret >= PATH_MAX) {
1372                 WARN("Nonsense - name /lxc.init.static too long");
1373                 goto out1;
1374         }
1375         if (access(retv, X_OK) == 0)
1376                 return retv;
1377
1378 out1:
1379         free(retv);
1380         return NULL;
1381 }
1382
1383 int print_to_file(const char *file, const char *content)
1384 {
1385         FILE *f;
1386         int ret = 0;
1387
1388         f = fopen(file, "w");
1389         if (!f)
1390                 return -1;
1391         if (fprintf(f, "%s", content) != strlen(content))
1392                 ret = -1;
1393         fclose(f);
1394         return ret;
1395 }
1396
1397 int is_dir(const char *path)
1398 {
1399         struct stat statbuf;
1400         int ret = stat(path, &statbuf);
1401         if (ret == 0 && S_ISDIR(statbuf.st_mode))
1402                 return 1;
1403         return 0;
1404 }
1405
1406 /*
1407  * Given the '-t' template option to lxc-create, figure out what to
1408  * do.  If the template is a full executable path, use that.  If it
1409  * is something like 'sshd', then return $templatepath/lxc-sshd.
1410  * On success return the template, on error return NULL.
1411  */
1412 char *get_template_path(const char *t)
1413 {
1414         int ret, len;
1415         char *tpath;
1416
1417         if (t[0] == '/' && access(t, X_OK) == 0) {
1418                 tpath = strdup(t);
1419                 return tpath;
1420         }
1421
1422         len = strlen(LXCTEMPLATEDIR) + strlen(t) + strlen("/lxc-") + 1;
1423         tpath = malloc(len);
1424         if (!tpath)
1425                 return NULL;
1426         ret = snprintf(tpath, len, "%s/lxc-%s", LXCTEMPLATEDIR, t);
1427         if (ret < 0 || ret >= len) {
1428                 free(tpath);
1429                 return NULL;
1430         }
1431         if (access(tpath, X_OK) < 0) {
1432                 SYSERROR("bad template: %s", t);
1433                 free(tpath);
1434                 return NULL;
1435         }
1436
1437         return tpath;
1438 }
1439
1440 /*
1441  * @path:    a pathname where / replaced with '\0'.
1442  * @offsetp: pointer to int showing which path segment was last seen.
1443  *           Updated on return to reflect the next segment.
1444  * @fulllen: full original path length.
1445  * Returns a pointer to the next path segment, or NULL if done.
1446  */
1447 static char *get_nextpath(char *path, int *offsetp, int fulllen)
1448 {
1449         int offset = *offsetp;
1450
1451         if (offset >= fulllen)
1452                 return NULL;
1453
1454         while (path[offset] != '\0' && offset < fulllen)
1455                 offset++;
1456         while (path[offset] == '\0' && offset < fulllen)
1457                 offset++;
1458
1459         *offsetp = offset;
1460         return (offset < fulllen) ? &path[offset] : NULL;
1461 }
1462
1463 /*
1464  * Check that @subdir is a subdir of @dir.  @len is the length of
1465  * @dir (to avoid having to recalculate it).
1466  */
1467 static bool is_subdir(const char *subdir, const char *dir, size_t len)
1468 {
1469         size_t subdirlen = strlen(subdir);
1470
1471         if (subdirlen < len)
1472                 return false;
1473         if (strncmp(subdir, dir, len) != 0)
1474                 return false;
1475         if (dir[len-1] == '/')
1476                 return true;
1477         if (subdir[len] == '/' || subdirlen == len)
1478                 return true;
1479         return false;
1480 }
1481
1482 /*
1483  * Check if the open fd is a symlink.  Return -ELOOP if it is.  Return
1484  * -ENOENT if we couldn't fstat.  Return 0 if the fd is ok.
1485  */
1486 static int check_symlink(int fd)
1487 {
1488         struct stat sb;
1489         int ret = fstat(fd, &sb);
1490         if (ret < 0)
1491                 return -ENOENT;
1492         if (S_ISLNK(sb.st_mode))
1493                 return -ELOOP;
1494         return 0;
1495 }
1496
1497 /*
1498  * Open a file or directory, provided that it contains no symlinks.
1499  *
1500  * CAVEAT: This function must not be used for other purposes than container
1501  * setup before executing the container's init
1502  */
1503 static int open_if_safe(int dirfd, const char *nextpath)
1504 {
1505         int newfd = openat(dirfd, nextpath, O_RDONLY | O_NOFOLLOW);
1506         if (newfd >= 0) /* Was not a symlink, all good. */
1507                 return newfd;
1508
1509         if (errno == ELOOP)
1510                 return newfd;
1511
1512         if (errno == EPERM || errno == EACCES) {
1513                 /* We're not root (cause we got EPERM) so try opening with
1514                  * O_PATH.
1515                  */
1516                 newfd = openat(dirfd, nextpath, O_PATH | O_NOFOLLOW);
1517                 if (newfd >= 0) {
1518                         /* O_PATH will return an fd for symlinks. We know
1519                          * nextpath wasn't a symlink at last openat, so if fd is
1520                          * now a link, then something * fishy is going on.
1521                          */
1522                         int ret = check_symlink(newfd);
1523                         if (ret < 0) {
1524                                 close(newfd);
1525                                 newfd = ret;
1526                         }
1527                 }
1528         }
1529
1530         return newfd;
1531 }
1532
1533 /*
1534  * Open a path intending for mounting, ensuring that the final path
1535  * is inside the container's rootfs.
1536  *
1537  * CAVEAT: This function must not be used for other purposes than container
1538  * setup before executing the container's init
1539  *
1540  * @target: path to be opened
1541  * @prefix_skip: a part of @target in which to ignore symbolic links.  This
1542  * would be the container's rootfs.
1543  *
1544  * Return an open fd for the path, or <0 on error.
1545  */
1546 static int open_without_symlink(const char *target, const char *prefix_skip)
1547 {
1548         int curlen = 0, dirfd, fulllen, i;
1549         char *dup = NULL;
1550
1551         fulllen = strlen(target);
1552
1553         /* make sure prefix-skip makes sense */
1554         if (prefix_skip && strlen(prefix_skip) > 0) {
1555                 curlen = strlen(prefix_skip);
1556                 if (!is_subdir(target, prefix_skip, curlen)) {
1557                         ERROR("WHOA there - target '%s' didn't start with prefix '%s'",
1558                                 target, prefix_skip);
1559                         return -EINVAL;
1560                 }
1561                 /*
1562                  * get_nextpath() expects the curlen argument to be
1563                  * on a  (turned into \0) / or before it, so decrement
1564                  * curlen to make sure that happens
1565                  */
1566                 if (curlen)
1567                         curlen--;
1568         } else {
1569                 prefix_skip = "/";
1570                 curlen = 0;
1571         }
1572
1573         /* Make a copy of target which we can hack up, and tokenize it */
1574         if ((dup = strdup(target)) == NULL) {
1575                 SYSERROR("Out of memory checking for symbolic link");
1576                 return -ENOMEM;
1577         }
1578         for (i = 0; i < fulllen; i++) {
1579                 if (dup[i] == '/')
1580                         dup[i] = '\0';
1581         }
1582
1583         dirfd = open(prefix_skip, O_RDONLY);
1584         if (dirfd < 0)
1585                 goto out;
1586         while (1) {
1587                 int newfd, saved_errno;
1588                 char *nextpath;
1589
1590                 if ((nextpath = get_nextpath(dup, &curlen, fulllen)) == NULL)
1591                         goto out;
1592                 newfd = open_if_safe(dirfd, nextpath);
1593                 saved_errno = errno;
1594                 close(dirfd);
1595                 dirfd = newfd;
1596                 if (newfd < 0) {
1597                         errno = saved_errno;
1598                         if (errno == ELOOP)
1599                                 SYSERROR("%s in %s was a symbolic link!", nextpath, target);
1600                         goto out;
1601                 }
1602         }
1603
1604 out:
1605         free(dup);
1606         return dirfd;
1607 }
1608
1609 /*
1610  * Safely mount a path into a container, ensuring that the mount target
1611  * is under the container's @rootfs.  (If @rootfs is NULL, then the container
1612  * uses the host's /)
1613  *
1614  * CAVEAT: This function must not be used for other purposes than container
1615  * setup before executing the container's init
1616  */
1617 int safe_mount(const char *src, const char *dest, const char *fstype,
1618                 unsigned long flags, const void *data, const char *rootfs)
1619 {
1620         int destfd, ret, saved_errno;
1621         /* Only needs enough for /proc/self/fd/<fd>. */
1622         char srcbuf[50], destbuf[50];
1623         int srcfd = -1;
1624         const char *mntsrc = src;
1625
1626         if (!rootfs)
1627                 rootfs = "";
1628
1629         /* todo - allow symlinks for relative paths if 'allowsymlinks' option is passed */
1630         if (flags & MS_BIND && src && src[0] != '/') {
1631                 INFO("this is a relative bind mount");
1632                 srcfd = open_without_symlink(src, NULL);
1633                 if (srcfd < 0)
1634                         return srcfd;
1635                 ret = snprintf(srcbuf, 50, "/proc/self/fd/%d", srcfd);
1636                 if (ret < 0 || ret > 50) {
1637                         close(srcfd);
1638                         ERROR("Out of memory");
1639                         return -EINVAL;
1640                 }
1641                 mntsrc = srcbuf;
1642         }
1643
1644         destfd = open_without_symlink(dest, rootfs);
1645         if (destfd < 0) {
1646                 if (srcfd != -1) {
1647                         saved_errno = errno;
1648                         close(srcfd);
1649                         errno = saved_errno;
1650                 }
1651                 return destfd;
1652         }
1653
1654         ret = snprintf(destbuf, 50, "/proc/self/fd/%d", destfd);
1655         if (ret < 0 || ret > 50) {
1656                 if (srcfd != -1)
1657                         close(srcfd);
1658                 close(destfd);
1659                 ERROR("Out of memory");
1660                 return -EINVAL;
1661         }
1662
1663         ret = mount(mntsrc, destbuf, fstype, flags, data);
1664         saved_errno = errno;
1665         if (srcfd != -1)
1666                 close(srcfd);
1667         close(destfd);
1668         if (ret < 0) {
1669                 errno = saved_errno;
1670                 SYSERROR("Failed to mount %s onto %s", src ? src : "(null)", dest);
1671                 return ret;
1672         }
1673
1674         return 0;
1675 }
1676
1677 /*
1678  * Mount a proc under @rootfs if proc self points to a pid other than
1679  * my own.  This is needed to have a known-good proc mount for setting
1680  * up LSMs both at container startup and attach.
1681  *
1682  * @rootfs : the rootfs where proc should be mounted
1683  *
1684  * Returns < 0 on failure, 0 if the correct proc was already mounted
1685  * and 1 if a new proc was mounted.
1686  *
1687  * NOTE: not to be called from inside the container namespace!
1688  */
1689 int lxc_mount_proc_if_needed(const char *rootfs)
1690 {
1691         char path[MAXPATHLEN];
1692         int link_to_pid, linklen, mypid, ret;
1693         char link[LXC_NUMSTRLEN64] = {0};
1694
1695         ret = snprintf(path, MAXPATHLEN, "%s/proc/self", rootfs);
1696         if (ret < 0 || ret >= MAXPATHLEN) {
1697                 SYSERROR("proc path name too long");
1698                 return -1;
1699         }
1700
1701         linklen = readlink(path, link, LXC_NUMSTRLEN64);
1702
1703         ret = snprintf(path, MAXPATHLEN, "%s/proc", rootfs);
1704         if (ret < 0 || ret >= MAXPATHLEN) {
1705                 SYSERROR("proc path name too long");
1706                 return -1;
1707         }
1708
1709         /* /proc not mounted */
1710         if (linklen < 0) {
1711                 if (mkdir(path, 0755) && errno != EEXIST)
1712                         return -1;
1713                 goto domount;
1714         } else if (linklen >= LXC_NUMSTRLEN64) {
1715                 link[linklen - 1] = '\0';
1716                 ERROR("readlink returned truncated content: \"%s\"", link);
1717                 return -1;
1718         }
1719
1720         mypid = lxc_raw_getpid();
1721         INFO("I am %d, /proc/self points to \"%s\"", mypid, link);
1722
1723         if (lxc_safe_int(link, &link_to_pid) < 0)
1724                 return -1;
1725
1726         /* correct procfs is already mounted */
1727         if (link_to_pid == mypid)
1728                 return 0;
1729
1730         ret = umount2(path, MNT_DETACH);
1731         if (ret < 0)
1732                 WARN("failed to umount \"%s\" with MNT_DETACH", path);
1733
1734 domount:
1735         /* rootfs is NULL */
1736         if (!strcmp(rootfs, ""))
1737                 ret = mount("proc", path, "proc", 0, NULL);
1738         else
1739                 ret = safe_mount("proc", path, "proc", 0, NULL, rootfs);
1740         if (ret < 0)
1741                 return -1;
1742
1743         INFO("mounted /proc in container for security transition");
1744         return 1;
1745 }
1746
1747 int open_devnull(void)
1748 {
1749         int fd = open("/dev/null", O_RDWR);
1750
1751         if (fd < 0)
1752                 SYSERROR("Can't open /dev/null");
1753
1754         return fd;
1755 }
1756
1757 int set_stdfds(int fd)
1758 {
1759         int ret;
1760
1761         if (fd < 0)
1762                 return -1;
1763
1764         ret = dup2(fd, STDIN_FILENO);
1765         if (ret < 0)
1766                 return -1;
1767
1768         ret = dup2(fd, STDOUT_FILENO);
1769         if (ret < 0)
1770                 return -1;
1771
1772         ret = dup2(fd, STDERR_FILENO);
1773         if (ret < 0)
1774                 return -1;
1775
1776         return 0;
1777 }
1778
1779 int null_stdfds(void)
1780 {
1781         int ret = -1;
1782         int fd = open_devnull();
1783
1784         if (fd >= 0) {
1785                 ret = set_stdfds(fd);
1786                 close(fd);
1787         }
1788
1789         return ret;
1790 }
1791
1792 /*
1793  * Return the number of lines in file @fn, or -1 on error
1794  */
1795 int lxc_count_file_lines(const char *fn)
1796 {
1797         FILE *f;
1798         char *line = NULL;
1799         size_t sz = 0;
1800         int n = 0;
1801
1802         f = fopen_cloexec(fn, "r");
1803         if (!f)
1804                 return -1;
1805
1806         while (getline(&line, &sz, f) != -1) {
1807                 n++;
1808         }
1809         free(line);
1810         fclose(f);
1811         return n;
1812 }
1813
1814 /* Check whether a signal is blocked by a process. */
1815 /* /proc/pid-to-str/status\0 = (5 + 21 + 7 + 1) */
1816 #define __PROC_STATUS_LEN (5 + (LXC_NUMSTRLEN64) + 7 + 1)
1817 bool task_blocking_signal(pid_t pid, int signal)
1818 {
1819         bool bret = false;
1820         char *line = NULL;
1821         long unsigned int sigblk = 0;
1822         size_t n = 0;
1823         int ret;
1824         FILE *f;
1825
1826         char status[__PROC_STATUS_LEN];
1827
1828         ret = snprintf(status, __PROC_STATUS_LEN, "/proc/%d/status", pid);
1829         if (ret < 0 || ret >= __PROC_STATUS_LEN)
1830                 return bret;
1831
1832         f = fopen(status, "r");
1833         if (!f)
1834                 return bret;
1835
1836         while (getline(&line, &n, f) != -1) {
1837                 if (strncmp(line, "SigBlk:\t", 8))
1838                         continue;
1839
1840                 if (sscanf(line + 8, "%lx", &sigblk) != 1)
1841                         goto out;
1842         }
1843
1844         if (sigblk & (1LU << (signal - 1)))
1845                 bret = true;
1846
1847 out:
1848         free(line);
1849         fclose(f);
1850         return bret;
1851 }
1852
1853 static int lxc_append_null_to_list(void ***list)
1854 {
1855         int newentry = 0;
1856         void **tmp;
1857
1858         if (*list)
1859                 for (; (*list)[newentry]; newentry++) {
1860                         ;
1861                 }
1862
1863         tmp = realloc(*list, (newentry + 2) * sizeof(void **));
1864         if (!tmp)
1865                 return -1;
1866
1867         *list = tmp;
1868         (*list)[newentry + 1] = NULL;
1869
1870         return newentry;
1871 }
1872
1873 int lxc_append_string(char ***list, char *entry)
1874 {
1875         char *copy;
1876         int newentry;
1877
1878         newentry = lxc_append_null_to_list((void ***)list);
1879         if (newentry < 0)
1880                 return -1;
1881
1882         copy = strdup(entry);
1883         if (!copy)
1884                 return -1;
1885
1886         (*list)[newentry] = copy;
1887
1888         return 0;
1889 }
1890
1891 int lxc_preserve_ns(const int pid, const char *ns)
1892 {
1893         int ret;
1894 /* 5 /proc + 21 /int_as_str + 3 /ns + 20 /NS_NAME + 1 \0 */
1895 #define __NS_PATH_LEN 50
1896         char path[__NS_PATH_LEN];
1897
1898         /* This way we can use this function to also check whether namespaces
1899          * are supported by the kernel by passing in the NULL or the empty
1900          * string.
1901          */
1902         ret = snprintf(path, __NS_PATH_LEN, "/proc/%d/ns%s%s", pid,
1903                        !ns || strcmp(ns, "") == 0 ? "" : "/",
1904                        !ns || strcmp(ns, "") == 0 ? "" : ns);
1905         errno = EFBIG;
1906         if (ret < 0 || (size_t)ret >= __NS_PATH_LEN)
1907                 return -EFBIG;
1908
1909         return open(path, O_RDONLY | O_CLOEXEC);
1910 }
1911
1912 int lxc_safe_uint(const char *numstr, unsigned int *converted)
1913 {
1914         char *err = NULL;
1915         unsigned long int uli;
1916
1917         while (isspace(*numstr))
1918                 numstr++;
1919
1920         if (*numstr == '-')
1921                 return -EINVAL;
1922
1923         errno = 0;
1924         uli = strtoul(numstr, &err, 0);
1925         if (errno == ERANGE && uli == ULONG_MAX)
1926                 return -ERANGE;
1927
1928         if (err == numstr || *err != '\0')
1929                 return -EINVAL;
1930
1931         if (uli > UINT_MAX)
1932                 return -ERANGE;
1933
1934         *converted = (unsigned int)uli;
1935         return 0;
1936 }
1937
1938 int lxc_safe_ulong(const char *numstr, unsigned long *converted)
1939 {
1940         char *err = NULL;
1941         unsigned long int uli;
1942
1943         while (isspace(*numstr))
1944                 numstr++;
1945
1946         if (*numstr == '-')
1947                 return -EINVAL;
1948
1949         errno = 0;
1950         uli = strtoul(numstr, &err, 0);
1951         if (errno == ERANGE && uli == ULONG_MAX)
1952                 return -ERANGE;
1953
1954         if (err == numstr || *err != '\0')
1955                 return -EINVAL;
1956
1957         *converted = uli;
1958         return 0;
1959 }
1960
1961 int lxc_safe_int(const char *numstr, int *converted)
1962 {
1963         char *err = NULL;
1964         signed long int sli;
1965
1966         errno = 0;
1967         sli = strtol(numstr, &err, 0);
1968         if (errno == ERANGE && (sli == LONG_MAX || sli == LONG_MIN))
1969                 return -ERANGE;
1970
1971         if (errno != 0 && sli == 0)
1972                 return -EINVAL;
1973
1974         if (err == numstr || *err != '\0')
1975                 return -EINVAL;
1976
1977         if (sli > INT_MAX || sli < INT_MIN)
1978                 return -ERANGE;
1979
1980         *converted = (int)sli;
1981         return 0;
1982 }
1983
1984 int lxc_safe_long(const char *numstr, long int *converted)
1985 {
1986         char *err = NULL;
1987         signed long int sli;
1988
1989         errno = 0;
1990         sli = strtol(numstr, &err, 0);
1991         if (errno == ERANGE && (sli == LONG_MAX || sli == LONG_MIN))
1992                 return -ERANGE;
1993
1994         if (errno != 0 && sli == 0)
1995                 return -EINVAL;
1996
1997         if (err == numstr || *err != '\0')
1998                 return -EINVAL;
1999
2000         *converted = sli;
2001         return 0;
2002 }
2003
2004 int lxc_safe_long_long(const char *numstr, long long int *converted)
2005 {
2006         char *err = NULL;
2007         signed long long int sli;
2008
2009         errno = 0;
2010         sli = strtoll(numstr, &err, 0);
2011         if (errno == ERANGE && (sli == LLONG_MAX || sli == LLONG_MIN))
2012                 return -ERANGE;
2013
2014         if (errno != 0 && sli == 0)
2015                 return -EINVAL;
2016
2017         if (err == numstr || *err != '\0')
2018                 return -EINVAL;
2019
2020         *converted = sli;
2021         return 0;
2022 }
2023
2024 int lxc_switch_uid_gid(uid_t uid, gid_t gid)
2025 {
2026         if (setgid(gid) < 0) {
2027                 SYSERROR("Failed to switch to gid %d.", gid);
2028                 return -errno;
2029         }
2030         NOTICE("Switched to gid %d.", gid);
2031
2032         if (setuid(uid) < 0) {
2033                 SYSERROR("Failed to switch to uid %d.", uid);
2034                 return -errno;
2035         }
2036         NOTICE("Switched to uid %d.", uid);
2037
2038         return 0;
2039 }
2040
2041 /* Simple covenience function which enables uniform logging. */
2042 int lxc_setgroups(int size, gid_t list[])
2043 {
2044         if (setgroups(size, list) < 0) {
2045                 SYSERROR("Failed to setgroups().");
2046                 return -errno;
2047         }
2048         NOTICE("Dropped additional groups.");
2049
2050         return 0;
2051 }
2052
2053 static int lxc_get_unused_loop_dev_legacy(char *loop_name)
2054 {
2055         struct dirent *dp;
2056         struct loop_info64 lo64;
2057         DIR *dir;
2058         int dfd = -1, fd = -1, ret = -1;
2059
2060         dir = opendir("/dev");
2061         if (!dir)
2062                 return -1;
2063
2064         while ((dp = readdir(dir))) {
2065                 if (!dp)
2066                         break;
2067
2068                 if (strncmp(dp->d_name, "loop", 4) != 0)
2069                         continue;
2070
2071                 dfd = dirfd(dir);
2072                 if (dfd < 0)
2073                         continue;
2074
2075                 fd = openat(dfd, dp->d_name, O_RDWR);
2076                 if (fd < 0)
2077                         continue;
2078
2079                 ret = ioctl(fd, LOOP_GET_STATUS64, &lo64);
2080                 if (ret < 0) {
2081                         if (ioctl(fd, LOOP_GET_STATUS64, &lo64) == 0 ||
2082                             errno != ENXIO) {
2083                                 close(fd);
2084                                 fd = -1;
2085                                 continue;
2086                         }
2087                 }
2088
2089                 ret = snprintf(loop_name, LO_NAME_SIZE, "/dev/%s", dp->d_name);
2090                 if (ret < 0 || ret >= LO_NAME_SIZE) {
2091                         close(fd);
2092                         fd = -1;
2093                         continue;
2094                 }
2095
2096                 break;
2097         }
2098
2099         closedir(dir);
2100
2101         if (fd < 0)
2102                 return -1;
2103
2104         return fd;
2105 }
2106
2107 static int lxc_get_unused_loop_dev(char *name_loop)
2108 {
2109         int loop_nr, ret;
2110         int fd_ctl = -1, fd_tmp = -1;
2111
2112         fd_ctl = open("/dev/loop-control", O_RDWR | O_CLOEXEC);
2113         if (fd_ctl < 0)
2114                 return -ENODEV;
2115
2116         loop_nr = ioctl(fd_ctl, LOOP_CTL_GET_FREE);
2117         if (loop_nr < 0)
2118                 goto on_error;
2119
2120         ret = snprintf(name_loop, LO_NAME_SIZE, "/dev/loop%d", loop_nr);
2121         if (ret < 0 || ret >= LO_NAME_SIZE)
2122                 goto on_error;
2123
2124         fd_tmp = open(name_loop, O_RDWR | O_CLOEXEC);
2125         if (fd_tmp < 0)
2126                 goto on_error;
2127
2128 on_error:
2129         close(fd_ctl);
2130         return fd_tmp;
2131 }
2132
2133 int lxc_prepare_loop_dev(const char *source, char *loop_dev, int flags)
2134 {
2135         int ret;
2136         struct loop_info64 lo64;
2137         int fd_img = -1, fret = -1, fd_loop = -1;
2138
2139         fd_loop = lxc_get_unused_loop_dev(loop_dev);
2140         if (fd_loop < 0) {
2141                 if (fd_loop == -ENODEV)
2142                         fd_loop = lxc_get_unused_loop_dev_legacy(loop_dev);
2143                 else
2144                         goto on_error;
2145         }
2146
2147         fd_img = open(source, O_RDWR | O_CLOEXEC);
2148         if (fd_img < 0)
2149                 goto on_error;
2150
2151         ret = ioctl(fd_loop, LOOP_SET_FD, fd_img);
2152         if (ret < 0)
2153                 goto on_error;
2154
2155         memset(&lo64, 0, sizeof(lo64));
2156         lo64.lo_flags = flags;
2157
2158         ret = ioctl(fd_loop, LOOP_SET_STATUS64, &lo64);
2159         if (ret < 0)
2160                 goto on_error;
2161
2162         fret = 0;
2163
2164 on_error:
2165         if (fd_img >= 0)
2166                 close(fd_img);
2167
2168         if (fret < 0 && fd_loop >= 0) {
2169                 close(fd_loop);
2170                 fd_loop = -1;
2171         }
2172
2173         return fd_loop;
2174 }
2175
2176 int lxc_unstack_mountpoint(const char *path, bool lazy)
2177 {
2178         int ret;
2179         int umounts = 0;
2180
2181 pop_stack:
2182         ret = umount2(path, lazy ? MNT_DETACH : 0);
2183         if (ret < 0) {
2184                 /* We consider anything else than EINVAL deadly to prevent going
2185                  * into an infinite loop. (The other alternative is constantly
2186                  * parsing /proc/self/mountinfo which is yucky and probably
2187                  * racy.)
2188                  */
2189                 if (errno != EINVAL)
2190                         return -errno;
2191         } else {
2192                 /* Just stop counting when this happens. That'd just be so
2193                  * stupid that we won't even bother trying to report back the
2194                  * correct value anymore.
2195                  */
2196                 if (umounts != INT_MAX)
2197                         umounts++;
2198                 /* We succeeded in umounting. Make sure that there's no other
2199                  * mountpoint stacked underneath.
2200                  */
2201                 goto pop_stack;
2202         }
2203
2204         return umounts;
2205 }
2206
2207 int run_command(char *buf, size_t buf_size, int (*child_fn)(void *), void *args)
2208 {
2209         pid_t child;
2210         int ret, fret, pipefd[2];
2211         ssize_t bytes;
2212
2213         /* Make sure our callers do not receive unitialized memory. */
2214         if (buf_size > 0 && buf)
2215                 buf[0] = '\0';
2216
2217         if (pipe(pipefd) < 0) {
2218                 SYSERROR("failed to create pipe");
2219                 return -1;
2220         }
2221
2222         child = lxc_raw_clone(0);
2223         if (child < 0) {
2224                 close(pipefd[0]);
2225                 close(pipefd[1]);
2226                 SYSERROR("failed to create new process");
2227                 return -1;
2228         }
2229
2230         if (child == 0) {
2231                 /* Close the read-end of the pipe. */
2232                 close(pipefd[0]);
2233
2234                 /* Redirect std{err,out} to write-end of the
2235                  * pipe.
2236                  */
2237                 ret = dup2(pipefd[1], STDOUT_FILENO);
2238                 if (ret >= 0)
2239                         ret = dup2(pipefd[1], STDERR_FILENO);
2240
2241                 /* Close the write-end of the pipe. */
2242                 close(pipefd[1]);
2243
2244                 if (ret < 0) {
2245                         SYSERROR("failed to duplicate std{err,out} file descriptor");
2246                         _exit(EXIT_FAILURE);
2247                 }
2248
2249                 /* Does not return. */
2250                 child_fn(args);
2251                 ERROR("failed to exec command");
2252                 _exit(EXIT_FAILURE);
2253         }
2254
2255         /* close the write-end of the pipe */
2256         close(pipefd[1]);
2257
2258         if (buf && buf_size > 0) {
2259                 bytes = read(pipefd[0], buf, buf_size - 1);
2260                 if (bytes > 0)
2261                         buf[bytes - 1] = '\0';
2262         }
2263
2264         fret = wait_for_pid(child);
2265         /* close the read-end of the pipe */
2266         close(pipefd[0]);
2267
2268         return fret;
2269 }
2270
2271 char *must_make_path(const char *first, ...)
2272 {
2273         va_list args;
2274         char *cur, *dest;
2275         size_t full_len = strlen(first);
2276
2277         dest = must_copy_string(first);
2278
2279         va_start(args, first);
2280         while ((cur = va_arg(args, char *)) != NULL) {
2281                 full_len += strlen(cur);
2282                 if (cur[0] != '/')
2283                         full_len++;
2284                 dest = must_realloc(dest, full_len + 1);
2285                 if (cur[0] != '/')
2286                         strcat(dest, "/");
2287                 strcat(dest, cur);
2288         }
2289         va_end(args);
2290
2291         return dest;
2292 }
2293
2294 char *must_append_path(char *first, ...)
2295 {
2296         char *cur;
2297         size_t full_len;
2298         va_list args;
2299         char *dest = first;
2300
2301         full_len = strlen(first);
2302         va_start(args, first);
2303         while ((cur = va_arg(args, char *)) != NULL) {
2304                 full_len += strlen(cur);
2305
2306                 if (cur[0] != '/')
2307                         full_len++;
2308
2309                 dest = must_realloc(dest, full_len + 1);
2310
2311                 if (cur[0] != '/')
2312                         strcat(dest, "/");
2313
2314                 strcat(dest, cur);
2315         }
2316         va_end(args);
2317
2318         return dest;
2319 }
2320
2321 char *must_copy_string(const char *entry)
2322 {
2323         char *ret;
2324
2325         if (!entry)
2326                 return NULL;
2327         do {
2328                 ret = strdup(entry);
2329         } while (!ret);
2330
2331         return ret;
2332 }
2333
2334 void *must_realloc(void *orig, size_t sz)
2335 {
2336         void *ret;
2337
2338         do {
2339                 ret = realloc(orig, sz);
2340         } while (!ret);
2341
2342         return ret;
2343 }
2344
2345 bool is_fs_type(const struct statfs *fs, fs_type_magic magic_val)
2346 {
2347         return (fs->f_type == (fs_type_magic)magic_val);
2348 }
2349
2350 bool has_fs_type(const char *path, fs_type_magic magic_val)
2351 {
2352         bool has_type;
2353         int ret;
2354         struct statfs sb;
2355
2356         ret = statfs(path, &sb);
2357         if (ret < 0)
2358                 return false;
2359
2360         has_type = is_fs_type(&sb, magic_val);
2361         if (!has_type && magic_val == RAMFS_MAGIC)
2362                 WARN("When the ramfs it a tmpfs statfs() might report tmpfs");
2363
2364         return has_type;
2365 }
2366
2367 bool lxc_nic_exists(char *nic)
2368 {
2369 #define __LXC_SYS_CLASS_NET_LEN 15 + IFNAMSIZ + 1
2370         char path[__LXC_SYS_CLASS_NET_LEN];
2371         int ret;
2372         struct stat sb;
2373
2374         if (!strcmp(nic, "none"))
2375                 return true;
2376
2377         ret = snprintf(path, __LXC_SYS_CLASS_NET_LEN, "/sys/class/net/%s", nic);
2378         if (ret < 0 || (size_t)ret >= __LXC_SYS_CLASS_NET_LEN)
2379                 return false;
2380
2381         ret = stat(path, &sb);
2382         if (ret < 0)
2383                 return false;
2384
2385         return true;
2386 }
2387
2388 int lxc_make_tmpfile(char *template, bool rm)
2389 {
2390         int fd, ret;
2391
2392         fd = mkstemp(template);
2393         if (fd < 0)
2394                 return -1;
2395
2396         if (!rm)
2397                 return fd;
2398
2399         ret = unlink(template);
2400         if (ret < 0) {
2401                 close(fd);
2402                 return -1;
2403         }
2404
2405         return fd;
2406 }
2407
2408 int parse_byte_size_string(const char *s, int64_t *converted)
2409 {
2410         int ret, suffix_len;
2411         long long int conv;
2412         int64_t mltpl, overflow;
2413         char *end;
2414         char dup[LXC_NUMSTRLEN64 + 2];
2415         char suffix[3] = {0};
2416
2417         if (!s || !strcmp(s, ""))
2418                 return -EINVAL;
2419
2420         end = stpncpy(dup, s, sizeof(dup));
2421         if (*end != '\0')
2422                 return -EINVAL;
2423
2424         if (isdigit(*(end - 1)))
2425                 suffix_len = 0;
2426         else if (isalpha(*(end - 1)))
2427                 suffix_len = 1;
2428         else
2429                 return -EINVAL;
2430
2431         if (suffix_len > 0 && (end - 2) == dup && !isdigit(*(end - 2)))
2432                 return -EINVAL;
2433
2434         if (suffix_len > 0 && isalpha(*(end - 2)))
2435                 suffix_len++;
2436
2437         if (suffix_len > 0) {
2438                 memcpy(suffix, end - suffix_len, suffix_len);
2439                 *(suffix + suffix_len) = '\0';
2440                 *(end - suffix_len) = '\0';
2441         }
2442         dup[lxc_char_right_gc(dup, strlen(dup))] = '\0';
2443
2444         ret = lxc_safe_long_long(dup, &conv);
2445         if (ret < 0)
2446                 return -ret;
2447
2448         if (suffix_len != 2) {
2449                 *converted = conv;
2450                 return 0;
2451         }
2452
2453         if (!strcmp(suffix, "kB"))
2454                 mltpl = 1024;
2455         else if (!strcmp(suffix, "MB"))
2456                 mltpl = 1024 * 1024;
2457         else if (!strcmp(suffix, "GB"))
2458                 mltpl = 1024 * 1024 * 1024;
2459         else
2460                 return -EINVAL;
2461
2462         overflow = conv * mltpl;
2463         if (conv != 0 && (overflow / conv) != mltpl)
2464                 return -ERANGE;
2465
2466         *converted = overflow;
2467         return 0;
2468 }
2469
2470 uint64_t lxc_find_next_power2(uint64_t n)
2471 {
2472         /* 0 is not valid input. We return 0 to the caller since 0 is not a
2473          * valid power of two.
2474          */
2475         if (n == 0)
2476                 return 0;
2477
2478         if (!(n & (n - 1)))
2479                 return n;
2480
2481         while (n & (n - 1))
2482                 n = n & (n - 1);
2483
2484         n = n << 1;
2485         return n;
2486 }
2487
2488 int lxc_set_death_signal(int signal)
2489 {
2490         int ret;
2491         pid_t ppid;
2492
2493         ret = prctl(PR_SET_PDEATHSIG, signal, 0, 0, 0);
2494
2495         /* Check whether we have been orphaned. */
2496         ppid = (pid_t)syscall(SYS_getppid);
2497         if (ppid == 1) {
2498                 pid_t self;
2499
2500                 self = lxc_raw_getpid();
2501                 ret = kill(self, SIGKILL);
2502                 if (ret < 0)
2503                         return -1;
2504         }
2505
2506         if (ret < 0) {
2507                 SYSERROR("Failed to set PR_SET_PDEATHSIG to %d", signal);
2508                 return -1;
2509         }
2510
2511         return 0;
2512 }