contrib/android/e2fsdroid.c

   1 #define _GNU_SOURCE
   2
   3 #include <stdio.h>
   4 #include <getopt.h>
   5 #include <string.h>
   6 #include <unistd.h>
   7 #include <limits.h>
   8 #include <ext2fs/ext2fs.h>
   9
  10 #include "perms.h"
  11 #include "base_fs.h"
  12 #include "block_list.h"
  13 #include "basefs_allocator.h"
  14 #include "create_inode.h"
  15
  16 #ifndef UID_GID_MAP_MAX_EXTENTS
  17 /*
  18  * The value is defined in linux/user_namspace.h.
  19  * The value is (arbitrarily) 5 in 4.14 and earlier, or 340 in 4.15 and later.
  20  * Here, the bigger value is taken. See also man user_namespace(7).
  21  */
  22 #define UID_GID_MAP_MAX_EXTENTS 340
  23 #endif
  24
  25 static char *prog_name = "e2fsdroid";
  26 static char *in_file;
  27 static char *block_list;
  28 static char *basefs_out;
  29 static char *basefs_in;
  30 static char *mountpoint = "";
  31 static time_t fixed_time = -1;
  32 static char *fs_config_file;
  33 static struct selinux_opt seopt_file[8];
  34 static int max_nr_opt = (int)sizeof(seopt_file) / sizeof(seopt_file[0]);
  35 static char *product_out;
  36 static char *src_dir;
  37 static int android_configure;
  38 static int android_sparse_file = 1;
  39
  40 static void usage(int ret)
  41 {
  42         fprintf(stderr, "%s [-B block_list] [-D basefs_out] [-T timestamp]\n"
  43                         "\t[-C fs_config] [-S file_contexts] [-p product_out]\n"
  44                         "\t[-a mountpoint] [-d basefs_in] [-f src_dir] [-e] [-s]\n"
  45                         "\t[-u uid-mapping] [-g gid-mapping] image\n",
  46                 prog_name);
  47         exit(ret);
  48 }
  49
  50 static char *absolute_path(const char *file)
  51 {
  52         char *ret;
  53         char cwd[PATH_MAX];
  54
  55         if (file[0] != '/') {
  56                 if (getcwd(cwd, PATH_MAX) == NULL) {
  57                         fprintf(stderr, "Failed to getcwd\n");
  58                         exit(EXIT_FAILURE);
  59                 }
  60                 ret = malloc(strlen(cwd) + 1 + strlen(file) + 1);
  61                 if (ret)
  62                         sprintf(ret, "%s/%s", cwd, file);
  63         } else
  64                 ret = strdup(file);
  65         return ret;
  66 }
  67
  68 static int parse_ugid_map_entry(char* line, struct ugid_map_entry* result)
  69 {
  70         char *token, *token_saveptr;
  71         size_t num_tokens;
  72         unsigned int *parsed[] = {&result->child_id,
  73                                   &result->parent_id,
  74                                   &result->length};
  75         for (token = strtok_r(line, " ", &token_saveptr), num_tokens = 0;
  76              token && num_tokens < 3;
  77              token = strtok_r(NULL, " ", &token_saveptr), ++num_tokens) {
  78                 char* endptr = NULL;
  79                 unsigned long t = strtoul(token, &endptr, 10);
  80                 if ((t == ULONG_MAX && errno) || (t > UINT_MAX) || *endptr) {
  81                         fprintf(stderr, "Malformed u/gid mapping line\n");
  82                         return 0;
  83                 }
  84                 *parsed[num_tokens] = (unsigned int) t;
  85         }
  86         if (num_tokens < 3 || strtok_r(NULL, " ", &token_saveptr) != NULL) {
  87                 fprintf(stderr, "Malformed u/gid mapping line\n");
  88                 return 0;
  89         }
  90         if (result->child_id + result->length < result->child_id ||
  91             result->parent_id + result->length < result->parent_id) {
  92                 fprintf(stderr, "u/gid mapping overflow\n");
  93                 return 0;
  94         }
  95         return 1;
  96 }
  97
  98 /*
  99  * Returns 1 if [begin1, begin1+length1) and [begin2, begin2+length2) have
 100  * overlapping range. Otherwise 0.
 101  */
 102 static int is_overlapping(unsigned int begin1, unsigned int length1,
 103                           unsigned int begin2, unsigned int length2)
 104 {
 105         unsigned int end1 = begin1 + length1;
 106         unsigned int end2 = begin2 + length2;
 107         return !(end1 <= begin2 || end2 <= begin1);
 108 }
 109
 110 /*
 111  * Verifies if the given mapping works.
 112  * - Checks if the number of entries is less than or equals to
 113  *   UID_GID_MAP_MAX_EXTENTS.
 114  * - Checks if there is no overlapped ranges.
 115  * Returns 1 if valid, otherwise 0.
 116  */
 117 static int is_valid_ugid_map(const struct ugid_map* mapping)
 118 {
 119         size_t i, j;
 120
 121         if (mapping->size > UID_GID_MAP_MAX_EXTENTS) {
 122                 fprintf(stderr, "too many u/gid mapping entries\n");
 123                 return 0;
 124         }
 125
 126         for (i = 0; i < mapping->size; ++i) {
 127                 const struct ugid_map_entry *entry1 = &mapping->entries[i];
 128                 for (j = i + 1; j < mapping->size; ++j) {
 129                         const struct ugid_map_entry *entry2 =
 130                                 &mapping->entries[j];
 131                         if (is_overlapping(entry1->child_id, entry1->length,
 132                                            entry2->child_id, entry2->length)) {
 133                                 fprintf(stderr,
 134                                         "Overlapping child u/gid: [%d %d %d],"
 135                                         " [%d %d %d]\n",
 136                                         entry1->child_id, entry1->parent_id,
 137                                         entry1->length, entry2->child_id,
 138                                         entry2->parent_id, entry2->length);
 139                                 return 0;
 140                         }
 141                         if (is_overlapping(entry1->parent_id, entry1->length,
 142                                            entry2->parent_id, entry2->length)) {
 143                                 fprintf(stderr,
 144                                         "Overlapping parent u/gid: [%d %d %d],"
 145                                         " [%d %d %d]\n",
 146                                         entry1->child_id, entry1->parent_id,
 147                                         entry1->length, entry2->child_id,
 148                                         entry2->parent_id, entry2->length);
 149                                 return 0;
 150                         }
 151                 }
 152         }
 153         return 1;
 154 }
 155
 156 /*
 157  * Parses the UID/GID mapping argument. The argument could be a multi-line
 158  * string (separated by '\n', no trailing '\n' is allowed). Each line must
 159  * contain exact three integer tokens; the first token is |child_id|,
 160  * the second is |parent_id|, and the last is |length| of the mapping range.
 161  * See also user_namespace(7) man page.
 162  * On success, the parsed entries are stored in |result|, and it returns 1.
 163  * Otherwise, returns 0.
 164  */
 165 static int parse_ugid_map(char* arg, struct ugid_map* result)
 166 {
 167         int i;
 168         char *line, *line_saveptr;
 169         size_t current_index;
 170
 171         /* Count the number of lines. */
 172         result->size = 1;
 173         for (i = 0; arg[i]; ++i) {
 174                 if (arg[i] == '\n')
 175                         ++result->size;
 176         }
 177
 178         /* Allocate memory for entries. */
 179         result->entries = malloc(sizeof(struct ugid_map_entry) * result->size);
 180         if (!result->entries) {
 181                 result->size = 0;
 182                 return 0;
 183         }
 184
 185         /* Parse each line */
 186         for (line = strtok_r(arg, "\n", &line_saveptr), current_index = 0;
 187              line;
 188              line = strtok_r(NULL, "\n", &line_saveptr), ++current_index) {
 189                 if (!parse_ugid_map_entry(
 190                         line, &result->entries[current_index])) {
 191                         return 0;
 192                 }
 193         }
 194
 195         return is_valid_ugid_map(result);
 196 }
 197
 198 int main(int argc, char *argv[])
 199 {
 200         int c;
 201         char *p;
 202         int flags = EXT2_FLAG_RW;
 203         errcode_t retval;
 204         io_manager io_mgr;
 205         ext2_filsys fs = NULL;
 206         struct fs_ops_callbacks fs_callbacks = { NULL, NULL };
 207         char *token;
 208         int nr_opt = 0;
 209         ext2_ino_t inodes_count;
 210         ext2_ino_t free_inodes_count;
 211         blk64_t blocks_count;
 212         blk64_t free_blocks_count;
 213         struct ugid_map uid_map = { 0, NULL }, gid_map = { 0, NULL };
 214
 215         add_error_table(&et_ext2_error_table);
 216
 217         while ((c = getopt (argc, argv, "T:C:S:p:a:D:d:B:f:esu:g:")) != EOF) {
 218                 switch (c) {
 219                 case 'T':
 220                         fixed_time = strtoul(optarg, &p, 0);
 221                         android_configure = 1;
 222                         break;
 223                 case 'C':
 224                         fs_config_file = absolute_path(optarg);
 225                         android_configure = 1;
 226                         break;
 227                 case 'S':
 228                         token = strtok(optarg, ",");
 229                         while (token) {
 230                                 if (nr_opt == max_nr_opt) {
 231                                         fprintf(stderr, "Expected at most %d selinux opts\n",
 232                                                 max_nr_opt);
 233                                         exit(EXIT_FAILURE);
 234                                 }
 235                                 seopt_file[nr_opt].type = SELABEL_OPT_PATH;
 236                                 seopt_file[nr_opt].value = absolute_path(token);
 237                                 nr_opt++;
 238                                 token = strtok(NULL, ",");
 239                         }
 240                         android_configure = 1;
 241                         break;
 242                 case 'p':
 243                         product_out = absolute_path(optarg);
 244                         android_configure = 1;
 245                         break;
 246                 case 'a':
 247                         mountpoint = strdup(optarg);
 248                         break;
 249                 case 'D':
 250                         basefs_out = absolute_path(optarg);
 251                         break;
 252                 case 'd':
 253                         basefs_in = absolute_path(optarg);
 254                         break;
 255                 case 'B':
 256                         block_list = absolute_path(optarg);
 257                         break;
 258                 case 'f':
 259                         src_dir = absolute_path(optarg);
 260                         break;
 261                 case 'e':
 262                         android_sparse_file = 0;
 263                         break;
 264                 case 's':
 265                         flags |= EXT2_FLAG_SHARE_DUP;
 266                         break;
 267                 case 'u':
 268                         if (!parse_ugid_map(optarg, &uid_map))
 269                                 exit(EXIT_FAILURE);
 270                         android_configure = 1;
 271                         break;
 272                 case 'g':
 273                         if (!parse_ugid_map(optarg, &gid_map))
 274                                 exit(EXIT_FAILURE);
 275                         android_configure = 1;
 276                         break;
 277                 default:
 278                         usage(EXIT_FAILURE);
 279                 }
 280         }
 281         if (optind >= argc) {
 282                 fprintf(stderr, "Expected filename after options\n");
 283                 exit(EXIT_FAILURE);
 284         }
 285
 286         if (android_sparse_file) {
 287                 io_mgr = sparse_io_manager;
 288                 if (asprintf(&in_file, "(%s)", argv[optind]) == -1) {
 289                         fprintf(stderr, "Failed to allocate file name\n");
 290                         exit(EXIT_FAILURE);
 291                 }
 292         } else {
 293                 io_mgr = unix_io_manager;
 294                 in_file = strdup(argv[optind]);
 295         }
 296         retval = ext2fs_open(in_file, flags, 0, 0, io_mgr, &fs);
 297         if (retval) {
 298                 com_err(prog_name, retval, "while opening file %s\n", in_file);
 299                 return retval;
 300         }
 301
 302         if (src_dir) {
 303                 ext2fs_read_bitmaps(fs);
 304                 if (basefs_in) {
 305                         retval = base_fs_alloc_load(fs, basefs_in, mountpoint,
 306                                 src_dir);
 307                         if (retval) {
 308                                 com_err(prog_name, retval, "%s",
 309                                 "while reading base_fs file");
 310                             exit(1);
 311                         }
 312                         fs_callbacks.create_new_inode =
 313                                 base_fs_alloc_set_target;
 314                         fs_callbacks.end_create_new_inode =
 315                                 base_fs_alloc_unset_target;
 316                 }
 317                 retval = populate_fs2(fs, EXT2_ROOT_INO, src_dir,
 318                                       EXT2_ROOT_INO, &fs_callbacks);
 319                 if (retval) {
 320                         com_err(prog_name, retval, "%s",
 321                         "while populating file system");
 322                     exit(1);
 323                 }
 324                 if (basefs_in)
 325                         base_fs_alloc_cleanup(fs);
 326         }
 327
 328         if (android_configure) {
 329                 retval = android_configure_fs(
 330                         fs, src_dir, product_out, mountpoint, seopt_file,
 331                         nr_opt, fs_config_file, fixed_time, &uid_map, &gid_map);
 332                 if (retval) {
 333                         com_err(prog_name, retval, "%s",
 334                                 "while configuring the file system");
 335                         exit(1);
 336                 }
 337         }
 338
 339         if (block_list) {
 340                 retval = fsmap_iter_filsys(fs, &block_list_format, block_list,
 341                                            mountpoint);
 342                 if (retval) {
 343                         com_err(prog_name, retval, "%s",
 344                                 "while creating the block_list");
 345                         exit(1);
 346                 }
 347         }
 348
 349         if (basefs_out) {
 350                 retval = fsmap_iter_filsys(fs, &base_fs_format,
 351                                            basefs_out, mountpoint);
 352                 if (retval) {
 353                         com_err(prog_name, retval, "%s",
 354                                 "while creating the basefs file");
 355                         exit(1);
 356                 }
 357         }
 358
 359         inodes_count = fs->super->s_inodes_count;
 360         free_inodes_count = fs->super->s_free_inodes_count;
 361         blocks_count = ext2fs_blocks_count(fs->super);
 362         free_blocks_count = ext2fs_free_blocks_count(fs->super);
 363
 364         retval = ext2fs_close_free(&fs);
 365         if (retval) {
 366                 com_err(prog_name, retval, "%s",
 367                                 "while writing superblocks");
 368                 exit(1);
 369         }
 370
 371         printf("Created filesystem with %u/%u inodes and %llu/%llu blocks\n",
 372                         inodes_count - free_inodes_count, inodes_count,
 373                         blocks_count - free_blocks_count, blocks_count);
 374
 375         remove_error_table(&et_ext2_error_table);
 376         return 0;
 377 }