/*  * Access a filesystem.  *  * Copyright (C) 2019, 2022 Paul Boddie <paul@boddie.org.uk>  *  * This program is free software; you can redistribute it and/or  * modify it under the terms of the GNU General Public License as  * published by the Free Software Foundation; either version 2 of  * the License, or (at your option) any later version.  *  * This program 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 General Public License for more details.  *  * You should have received a copy of the GNU General Public License  * along with this program; if not, write to the Free Software  * Foundation, Inc., 51 Franklin Street, Fifth Floor,  * Boston, MA  02110-1301, USA  */  #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h>  #include <sys/types.h> #include <sys/stat.h>  #include <ext2fs/ext2fs.h>  #include "file.h" #include "format.h" #include "image.h" #include "path.h" #include "utils.h"    /* Copy buffer size. */  const int BUFSIZE = 4096;    /* Alternative metadata set by options. */  struct metadata {     uid_t uid;     gid_t gid;     mode_t mask;     int have_uid, have_gid; };  struct metadata md;  /* Parse program options. */  static int parse_options(int argc, char *argv[]) {     int opt;      md.have_uid = 0;     md.have_gid = 0;     md.mask = 0000;      while ((opt = getopt(argc, argv, "g:m:u:")) != -1)     {         switch (opt)         {             case 'g':             md.gid = atoi(optarg);             md.have_gid = 1;             break;              case 'm':             md.mask = strtol(optarg, NULL, 0);             break;              case 'u':             md.uid = atoi(optarg);             md.have_uid = 1;             break;              default:             fprintf(stderr, "Option not recognised: %s\n", argv[optind]);             return -1;         }     }      return 0; }    /* Copy a file into the filesystem image. */  int copy_file_in(const char *filename, ext2_filsys fs, ext2_ino_t ino_file, int flags) {     int retval = 0;     ext2_file_t file;      /* Copying details. */      FILE *fp;     char buf[BUFSIZE];     size_t got;     unsigned int written;      /* Open a file in the target directory. */      if (ext2fs_file_open(fs, ino_file, flags, &file))         return 1;      /* Open the file in the source directory. */      fp = fopen(filename, "r");      /* Copy the file content. */      if (fp != NULL)     {         while (got = fread(buf, sizeof(char), BUFSIZE, fp))         {             while (got)             {                 if (ext2fs_file_write(file, buf, got, &written))                 {                     retval = 1;                     goto close_files;                 }                 got -= written;             }         }     }  close_files:     fclose(fp);     ext2fs_file_flush(file);     ext2fs_file_close(file);      return retval; }  /* Copy a file out of the filesystem image. */  int copy_file_out(const char *target, const char *filename, int target_is_file,                   ext2_filsys fs, ext2_ino_t ino_file) {     int retval = 0;     ext2_file_t file;      /* Copying details. */      FILE *fp;     char buf[BUFSIZE];     unsigned int got;     size_t written;      /* Open the file in the source directory. */      if (ext2fs_file_open(fs, ino_file, 0, &file))         return 1;      /* Open a file in the target directory. */      if (target_is_file)         fp = fopen(target, "w");     else         fp = open_file_in_dir(target, path_basename(filename), "w");      /* Copy the file content. */      if (fp != NULL)     {         do         {             if (ext2fs_file_read(file, buf, BUFSIZE, &got))             {                 retval = 1;                 goto close_files;             }              while (got)             {                 written = fwrite(buf, sizeof(char), got, fp);                 got -= written;             }          } while (got);     }  close_files:     fclose(fp);     ext2fs_file_close(file);      return retval; }    /* Copy source files from the external environment into the filesystem image. */  int copy_in(ext2_filsys fs, int argc, char *argv[]) {     errcode_t retval;      /* Target filename details. */      const char *target = argv[argc - 1];     const char *target_remaining = argv[argc - 1];     const char *basename;     int target_is_file;      /* Target file and directory details. */      int target_is_new;     ext2_ino_t ino_file, ino_target;     int flags;      /* Source file details. */      struct stat st;     int i;      /* Locate the target and test whether it is a file or a directory. */      if (image_find_path(fs, &target_remaining, &ino_target))     {         /* Only a non-existent file in an existing directory is permitted. */          if (!_image_isdir(fs, ino_target) || !path_is_leafname(target_remaining))         {             fprintf(stderr, "Target not found: %s\n", target);             return 1;         }          target_is_file = 1;         target_is_new = 1;     }     else     {         target_is_file = _image_isfile(fs, ino_target);         target_is_new = 0;     }      /* Only permit a target file when one source file is given. */      if (target_is_file)     {         if (argc > 2)         {             fprintf(stderr, "Target can only be a file when copying a single file: %s\n", target);             return 1;         }     }     else if (!_image_isdir(fs, ino_target))     {         fprintf(stderr, "Target is not a directory: %s\n", target);         return 1;     }      /* Copy each source object to the target directory. */      for (i = 0; i < argc - 1; i++)     {         if (target_is_file)             basename = target_remaining;         else         {             basename = path_basename(argv[i]);             target_is_new = image_find_file(fs, target, basename, &ino_file);         }          /* Directories are created with the same metadata. */          if (isdir(argv[i]))         {             if (!target_is_new)             {                 fprintf(stderr, "Target cannot be created since it already exists: %s\n", target);                 return 1;             }              /* Obtain the metadata. */              if (lstat(argv[i], &st))             {                 fprintf(stderr, "Failed to read object metadata: %s\n", argv[i]);                 return 1;             }              retval = image_make_dir(fs, ino_target, basename,                                     st.st_mode & ~md.mask,                                     md.have_uid ? md.uid : st.st_uid,                                     md.have_gid ? md.gid : st.st_gid,                                     &ino_file);              if (retval)             {                 fprintf(stderr, "Failed to create directory: %s\n", argv[i]);                 return 1;             }         }          /* Files are copied. */          else if (isfile(argv[i]))         {             flags = EXT2_FILE_WRITE;              /* Obtain the inode for the target file. */              if (target_is_new)             {                 /* Populate the inode details. */                  if (lstat(argv[i], &st))                 {                     fprintf(stderr, "Failed to read object metadata: %s\n", argv[i]);                     return 1;                 }                  retval = image_create_file(fs, ino_target, basename,                                            st.st_mode & ~md.mask,                                            md.have_uid ? md.uid : st.st_uid,                                            md.have_gid ? md.gid : st.st_gid,                                            &ino_file);                 if (retval)                 {                     fprintf(stderr, "Failed to create file: %s\n", argv[i]);                     return 1;                 }                  flags |= EXT2_FILE_CREATE;             }              /* NOTE: Overwrite/update metadata where appropriate. */              if (copy_file_in(argv[i], fs, ino_file, flags))             {                 fprintf(stderr, "Failed to write to file: %s\n", argv[i]);                 return 1;             }         }     }      return 0; }  /* Copy source files out of the filesystem image into the external environment. */  int copy_out(ext2_filsys fs, int argc, char *argv[]) {     /* Target filename details. */      char *target = argv[argc - 1];     int target_is_file;      /* Target file and directory details. */      ext2_file_t file;     ext2_ino_t ino_file;      /* Source file details. */      const char *path;     int i;      /* Locate the target and test whether it is a directory. */      if (!isdir(target))     {         /* Only a new or existing file in an existing directory is permitted. */          if (isfile(target) || isdir_dirname(target))             target_is_file = 1;         else         {             fprintf(stderr, "Target is not a directory: %s\n", target);             return 1;         }          /* Only permit a target file when one source file is given. */          if (argc > 2)         {             fprintf(stderr, "Target can only be a file when copying a single file: %s\n", target);             return 1;         }     }     else         target_is_file = 0;      /* For each source filename, test whether it references a file. */      for (i = 0; i < argc - 1; i++)     {         if (!image_isfile(fs, argv[i]))         {             fprintf(stderr, "Source is not a file: %s\n", argv[i]);             return 1;         }     }      /* Copy each source file to the target directory. */      for (i = 0; i < argc - 1; i++)     {         path = argv[i];          if (image_find_path(fs, &path, &ino_file))         {             fprintf(stderr, "Failed to find file: %s\n", argv[i]);             return 1;         }          if (copy_file_out(target, argv[i], target_is_file, fs, ino_file))         {             fprintf(stderr, "Failed to read from file: %s\n", argv[i]);             return 1;         }          /* NOTE: Overwrite/update metadata where appropriate. */     }      return 0; }  /* List objects in the filesystem image. */  int list(ext2_filsys fs, int argc, char *argv[]) {     int i;     char *path;      for (i = 0; i < argc; i++)     {         path = argv[i];          /* Emit each object. */          puts(path);          /* List individual files or directories. */          if (utils_list_dir(fs, path))         {             fprintf(stderr, "Failed to list directory: %s\n", path);             return 1;         }     }      return 0; }  /* Make directories in the filesystem image. */  int make_dirs(ext2_filsys fs, int argc, char *argv[]) {     int i;     const char *path;     ext2_ino_t ino;      /* Make each directory component in the given pathname. */      for (i = 0; i < argc; i++)     {         path = argv[i];          /* Search for the remaining components. */          if ((!*path) || !image_find_path(fs, &path, &ino))         {             fprintf(stderr, "Path exists: %s\n", argv[i]);             return 1;         }          /* From the first unrecognised component, make the remaining            directories. */          if (image_make_dirs(fs, &path, ino,                             0777 & ~md.mask,                             md.have_uid ? md.uid : 0,                             md.have_gid ? md.gid : 0))         {             fprintf(stderr, "Failed to make directory: %s\n", argv[i]);             return 1;         }     }      return 0; }  /* Remove directories from the filesystem image. */  int remove_dirs(ext2_filsys fs, int argc, char *argv[]) {     int i;     const char *path;     ext2_ino_t ino;      /* Remove each directory with the given pathname. */      for (i = 0; i < argc; i++)     {         path = argv[i];          /* Detect missing objects. */          if ((!*path) || !image_exists(fs, path))         {             fprintf(stderr, "Not found: %s\n", path);             return 1;         }          /* Insist on a directory. */          if (!image_isdir(fs, path))         {             fprintf(stderr, "Not a directory: %s\n", path);             return 1;         }          /* Test for an empty directory. */          if (image_dir_empty_by_path(fs, path, &ino))         {             fprintf(stderr, "Directory not empty: %s\n", path);             return 1;         }          /* Unlink the directory. */          if (image_unlink_by_path(fs, path))         {             fprintf(stderr, "Could not unlink directory: %s\n", path);             return 1;         }          /* Remove the directory. */          if (image_remove_by_inode(fs, ino))         {             fprintf(stderr, "Could not remove directory: %s\n", path);             return 1;         }     }      return 0; }    /* Help message. */  char help_text[] = "\ Usage: %s [ <options> ] <image file> <operation> <filename>...\n\ \n\ File ownership options:\n\ \n\   -g GID        Set group identifier for new files\n\   -u UID        Set user identifier for new files\n\ \n\ File permission options:\n\ \n\   -m MASK       Set mode/permissions mask for new directories\n\ \n\ Operations:\n\ \n\   copy-in       Copy files into a directory within the image\n\   copy-out      Copy files from the image into a directory\n\   ls            List files and directories within the image\n\   mkdir         Make directories within the image\n\   rmdir         Remove directories from the image\n\ ";  /* Operations exposed by the program. */  struct operation {     const char *name;     int (*fn)(ext2_filsys, int, char *[]); };  static struct operation operations[] = {     {"copy-in", copy_in},     {"copy-out", copy_out},     {"ls", list},     {"mkdir", make_dirs},     {"rmdir", remove_dirs},     {NULL, NULL},     };  /* Main program. */  int main(int argc, char *argv[]) {     int flags = EXT2_FLAG_RW; // | EXT2_FLAG_SOFTSUPP_FEATURES | EXT2_FLAG_64BITS;     ext2_filsys fs = NULL;     errcode_t retval;     int exitcode = 0;      /* Program argument details. */      char **args;     char *fsname, *operation, *filename;     int num_args;     struct operation *op;      /* Parse program options and initialise the argument details. */      if (parse_options(argc, argv))         return 1;      args = &argv[optind];     num_args = argc - optind;      if (num_args < 3)     {         fprintf(stderr, help_text, argv[0]);         return 1;     }      /* Open the filesystem image using the POSIX file access mechanism. */      fsname = args[0];      retval = ext2fs_open(fsname, flags, 0, 0, unix_io_manager, &fs);     if (retval)     {         fprintf(stderr, "Could not open filesystem: %s\n", fsname);         return 1;     }      //fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE;      retval = ext2fs_read_bitmaps(fs);     if (retval)     {         fprintf(stderr, "Could not read bitmaps: %s\n", fsname);         return 1;     }      /* Perform the requested operation. */      operation = args[1];     args = &args[2];     num_args -= 2;      for (op = &operations[0]; op->name != NULL; op++)     {         if (!strcmp(operation, op->name))         {             exitcode = op->fn(fs, num_args, args);             if (exitcode)                 fprintf(stderr, "Operation failed: %s\n", operation);             break;         }     }      if (op->name == NULL)     {         fprintf(stderr, "Operation not recognised: %s\n", operation);         exitcode = 1;     }      /* Close the filesystem image. */      retval = ext2fs_flush(fs);     if (retval)     {         fprintf(stderr, "Error flushing filesystem: %s\n", fsname);         exitcode = 1;     }      retval = ext2fs_close(fs);     if (retval)     {         fprintf(stderr, "Error closing filesystem: %s\n", fsname);         exitcode = 1;     }      ext2fs_free(fs);     return exitcode; }  /* vim: tabstop=4 expandtab shiftwidth=4 */