jail/fs.c

   1 /*
   2  * Copyright (C) 2015 John Crispin <blogic@openwrt.org>
   3  * Copyright (C) 2015 Etienne Champetier <champetier.etienne@gmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU Lesser General Public License version 2.1
   7  * as published by the Free Software Foundation
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #define _GNU_SOURCE
  16
  17 #include <assert.h>
  18 #include <elf.h>
  19 #include <errno.h>
  20 #include <fcntl.h>
  21 #include <linux/limits.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/stat.h>
  25 #include <sys/mman.h>
  26 #include <unistd.h>
  27
  28 #include <libubox/avl.h>
  29 #include <libubox/avl-cmp.h>
  30
  31 #include "elf.h"
  32 #include "fs.h"
  33 #include "jail.h"
  34 #include "log.h"
  35
  36 struct mount {
  37         struct avl_node avl;
  38         const char *path;
  39         int readonly;
  40         int error;
  41 };
  42
  43 struct avl_tree mounts;
  44
  45 int add_mount(const char *path, int readonly, int error)
  46 {
  47         assert(path != NULL);
  48
  49         if (avl_find(&mounts, path))
  50                 return 1;
  51
  52         struct mount *m;
  53         m = calloc(1, sizeof(struct mount));
  54         assert(m != NULL);
  55         m->avl.key = m->path = strdup(path);
  56         m->readonly = readonly;
  57         m->error = error;
  58
  59         avl_insert(&mounts, &m->avl);
  60         DEBUG("adding mount %s ro(%d) err(%d)\n", m->path, m->readonly, m->error != 0);
  61         return 0;
  62 }
  63
  64 int mount_all(const char *jailroot) {
  65         struct library *l;
  66         struct mount *m;
  67
  68         avl_for_each_element(&libraries, l, avl)
  69                 add_mount(l->path, 1, -1);
  70
  71         avl_for_each_element(&mounts, m, avl)
  72                 if (mount_bind(jailroot, m->path, m->readonly, m->error))
  73                         return -1;
  74
  75         return 0;
  76 }
  77
  78 void mount_list_init(void) {
  79         avl_init(&mounts, avl_strcmp, false, NULL);
  80 }
  81
  82 static int add_script_interp(const char *path, const char *map, int size)
  83 {
  84         int start = 2;
  85         while (start < size && map[start] != '/') {
  86                 start++;
  87         }
  88         if (start >= size) {
  89                 ERROR("bad script interp (%s)\n", path);
  90                 return -1;
  91         }
  92         int stop = start + 1;
  93         while (stop < size && map[stop] > 0x20 && map[stop] <= 0x7e) {
  94                 stop++;
  95         }
  96         if (stop >= size || (stop-start) > PATH_MAX) {
  97                 ERROR("bad script interp (%s)\n", path);
  98                 return -1;
  99         }
 100         char buf[PATH_MAX];
 101         strncpy(buf, map+start, stop-start);
 102         return add_path_and_deps(buf, 1, -1, 0);
 103 }
 104
 105 int add_path_and_deps(const char *path, int readonly, int error, int lib)
 106 {
 107         assert(path != NULL);
 108
 109         if (lib == 0 && path[0] != '/') {
 110                 ERROR("%s is not an absolute path\n", path);
 111                 return error;
 112         }
 113
 114         char *map = NULL;
 115         int fd, ret = -1;
 116         if (path[0] == '/') {
 117                 if (avl_find(&mounts, path))
 118                         return 0;
 119                 fd = open(path, O_RDONLY|O_CLOEXEC);
 120                 if (fd == -1)
 121                         return error;
 122                 add_mount(path, readonly, error);
 123         } else {
 124                 if (avl_find(&libraries, path))
 125                         return 0;
 126                 char *fullpath;
 127                 fd = lib_open(&fullpath, path);
 128                 if (fd == -1)
 129                         return error;
 130                 if (fullpath) {
 131                         alloc_library(fullpath, path);
 132                         free(fullpath);
 133                 }
 134         }
 135
 136         struct stat s;
 137         if (fstat(fd, &s) == -1) {
 138                 ERROR("fstat(%s) failed: %s\n", path, strerror(errno));
 139                 ret = error;
 140                 goto out;
 141         }
 142
 143         if (!S_ISREG(s.st_mode)) {
 144                 ret = 0;
 145                 goto out;
 146         }
 147
 148         /* too small to be an ELF or a script -> "normal" file */
 149         if (s.st_size < 4) {
 150                 ret = 0;
 151                 goto out;
 152         }
 153
 154         map = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 155         if (map == MAP_FAILED) {
 156                 ERROR("failed to mmap %s\n", path);
 157                 ret = -1;
 158                 goto out;
 159         }
 160
 161         if (map[0] == '#' && map[1] == '!') {
 162                 ret = add_script_interp(path, map, s.st_size);
 163                 goto out;
 164         }
 165
 166         if (map[0] == ELFMAG0 && map[1] == ELFMAG1 && map[2] == ELFMAG2 && map[3] == ELFMAG3) {
 167                 ret = elf_load_deps(path, map);
 168                 goto out;
 169         }
 170
 171         ret = 0;
 172
 173 out:
 174         if (fd >= 0)
 175                 close(fd);
 176         if (map)
 177                 munmap(map, s.st_size);
 178
 179         return ret;
 180 }