/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <errno.h>
#include <sys/mount.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sched.h>
#include <sys/syscall.h>
#include <limits.h>
#include <linux/fs.h>

#include "strv.h"
#include "util.h"
#include "path-util.h"
#include "namespace.h"
#include "missing.h"

typedef enum PathMode {
        /* This is ordered by priority! */
        INACCESSIBLE,
        READONLY,
        PRIVATE_TMP,
        PRIVATE_VAR_TMP,
        READWRITE
} PathMode;

typedef struct Path {
        const char *path;
        PathMode mode;
        bool done;
} Path;

static int append_paths(Path **p, char **strv, PathMode mode) {
        char **i;

        STRV_FOREACH(i, strv) {

                if (!path_is_absolute(*i))
                        return -EINVAL;

                (*p)->path = *i;
                (*p)->mode = mode;
                (*p)++;
        }

        return 0;
}

static int path_compare(const void *a, const void *b) {
        const Path *p = a, *q = b;

        if (path_equal(p->path, q->path)) {

                /* If the paths are equal, check the mode */
                if (p->mode < q->mode)
                        return -1;

                if (p->mode > q->mode)
                        return 1;

                return 0;
        }

        /* If the paths are not equal, then order prefixes first */
        if (path_startswith(p->path, q->path))
                return 1;

        if (path_startswith(q->path, p->path))
                return -1;

        return 0;
}

static void drop_duplicates(Path *p, unsigned *n, bool *need_inaccessible) {
        Path *f, *t, *previous;

        assert(p);
        assert(n);
        assert(need_inaccessible);

        for (f = p, t = p, previous = NULL; f < p+*n; f++) {

                /* The first one wins */
                if (previous && path_equal(f->path, previous->path))
                        continue;

                t->path = f->path;
                t->mode = f->mode;

                if (t->mode == INACCESSIBLE)
                        *need_inaccessible = true;

                previous = t;

                t++;
        }

        *n = t - p;
}

static int apply_mount(
                Path *p,
                const char *tmp_dir,
                const char *var_tmp_dir,
                const char *inaccessible_dir) {

        const char *what;
        int r;

        assert(p);

        switch (p->mode) {

        case INACCESSIBLE:
                what = inaccessible_dir;
                break;

        case READONLY:
        case READWRITE:
                what = p->path;
                break;

        case PRIVATE_TMP:
                what = tmp_dir;
                break;

        case PRIVATE_VAR_TMP:
                what = var_tmp_dir;
                break;

        default:
                assert_not_reached("Unknown mode");
        }

        assert(what);

        r = mount(what, p->path, NULL, MS_BIND, NULL);
        if (r >= 0)
                log_debug("Successfully mounted %s to %s", what, p->path);

        return r;
}

static int make_read_only(Path *p) {
        int r;

        assert(p);

        if (p->mode != INACCESSIBLE && p->mode != READONLY)
                return 0;

        r = mount(NULL, p->path, NULL, MS_BIND|MS_REMOUNT|MS_RDONLY, NULL);
        if (r < 0)
                return -errno;

        return 0;
}

int setup_namespace(
                char **writable,
                char **readable,
                char **inaccessible,
                bool private_tmp,
                unsigned long flags) {

        char
                tmp_dir[] = "/tmp/systemd-private-XXXXXX",
                var_tmp_dir[] = "/var/tmp/systemd-private-XXXXXX",
                inaccessible_dir[] = "/tmp/systemd-inaccessible-XXXXXX";

        Path *paths, *p;
        unsigned n;
        bool need_inaccessible = false;
        bool remove_tmp = false, remove_var_tmp = false, remove_inaccessible = false;
        int r;

        if (!flags)
                flags = MS_SHARED;

        n =
                strv_length(writable) +
                strv_length(readable) +
                strv_length(inaccessible) +
                (private_tmp ? 2 : 0);

        p = paths = alloca(sizeof(Path) * n);
        if ((r = append_paths(&p, writable, READWRITE)) < 0 ||
            (r = append_paths(&p, readable, READONLY)) < 0 ||
            (r = append_paths(&p, inaccessible, INACCESSIBLE)) < 0)
                goto fail;

        if (private_tmp) {
                p->path = "/tmp";
                p->mode = PRIVATE_TMP;
                p++;

                p->path = "/var/tmp";
                p->mode = PRIVATE_VAR_TMP;
                p++;
        }

        assert(paths + n == p);

        qsort(paths, n, sizeof(Path), path_compare);
        drop_duplicates(paths, &n, &need_inaccessible);

        if (need_inaccessible) {
                mode_t u;
                char *d;

                u = umask(0777);
                d = mkdtemp(inaccessible_dir);
                umask(u);

                if (!d) {
                        r = -errno;
                        goto fail;
                }

                remove_inaccessible = true;
        }

        if (private_tmp) {
                mode_t u;
                char *d;

                u = umask(0000);
                d = mkdtemp(tmp_dir);
                umask(u);

                if (!d) {
                        r = -errno;
                        goto fail;
                }

                remove_tmp = true;

                u = umask(0000);
                d = mkdtemp(var_tmp_dir);
                umask(u);

                if (!d) {
                        r = -errno;
                        goto fail;
                }

                remove_var_tmp = true;

                if (chmod(tmp_dir, 0777 + S_ISVTX) < 0) {
                        r = -errno;
                        goto fail;
                }

                if (chmod(var_tmp_dir, 0777 + S_ISVTX) < 0) {
                        r = -errno;
                        goto fail;
                }
        }

        if (unshare(CLONE_NEWNS) < 0) {
                r = -errno;
                goto fail;
        }

        /* Remount / as SLAVE so that nothing now mounted in the namespace
           shows up in the parent */
        if (mount(NULL, "/", NULL, MS_SLAVE|MS_REC, NULL) < 0) {
                r = -errno;
                goto fail;
        }

        for (p = paths; p < paths + n; p++) {
                r = apply_mount(p, tmp_dir, var_tmp_dir, inaccessible_dir);
                if (r < 0)
                        goto undo_mounts;
        }

        for (p = paths; p < paths + n; p++) {
                r = make_read_only(p);
                if (r < 0)
                        goto undo_mounts;
        }

        /* Remount / as the desired mode */
        if (mount(NULL, "/", NULL, flags|MS_REC, NULL) < 0) {
                r = -errno;
                goto undo_mounts;
        }

        return 0;

undo_mounts:
        for (p = paths; p < paths + n; p++)
                if (p->done)
                        umount2(p->path, MNT_DETACH);

fail:
        if (remove_inaccessible)
                rmdir(inaccessible_dir);

        if (remove_tmp)
                rmdir(tmp_dir);

        if (remove_var_tmp)
                rmdir(var_tmp_dir);

        return r;
}