/*

 * 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 "input.h"

#include "path.h"

#include "utils.h"

/* Copy buffer size. */

const int BUFSIZE = 4096;

/* Maximum number of arguments in scripts. */

const int MAX_ARGS = 32;

/* 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_resolve_by_path(fs, &target_remaining, &ino_target))

    {

        /* Only a non-existent file in an existing directory is permitted. */

        if (!image_isdir_by_inode(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_by_inode(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_by_inode(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_by_path(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_by_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 object: %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_resolve_by_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 objects from the filesystem image. */

int _remove(ext2_filsys fs, int argc, char *argv[], int dir_only)

{

    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_find_by_path(fs, path, &ino))

        {

            fprintf(stderr, "Not found: %s\n", path);

            return 1;

        }

        /* Insist on a directory if specified. */

        if (dir_only)

        {

            if (!image_isdir_by_inode(fs, ino))

            {

                fprintf(stderr, "Not a directory: %s\n", path);

                return 1;

            }

            /* Test for an empty directory. */

            if (image_dir_empty_by_inode(fs, ino))

            {

                fprintf(stderr, "Directory not empty: %s\n", path);

                return 1;

            }

        }

        /* Otherwise, insist on a non-directory. */

        else if (image_isdir_by_inode(fs, ino))

        {

            fprintf(stderr, "Cannot remove a directory: %s\n", path);

            return 1;

        }

        /* Unlink the object. */

        if (image_unlink_by_path(fs, path))

        {

            fprintf(stderr, "Could not unlink object: %s\n", path);

            return 1;

        }

        /* Remove the object. */

        if (image_remove_by_inode(fs, ino))

        {

            fprintf(stderr, "Could not remove object: %s\n", path);

            return 1;

        }

    }

    return 0;

}

/* Remove directories from the filesystem image. */

int remove_dirs(ext2_filsys fs, int argc, char *argv[])

{

    return _remove(fs, argc, argv, 1);

}

/* Remove non-directories from the filesystem image. */

int remove_non_dirs(ext2_filsys fs, int argc, char *argv[])

{

    return _remove(fs, argc, argv, 0);

}

/* Read operations from a script file. */

enum op_results

{

    OP_SUCCESS = 0,

    OP_FAILED = 1,

    OP_UNKNOWN = 2,

};

int handle_op_result(const char *operation, enum op_results op_result)

{

    if (op_result == OP_UNKNOWN)

    {

        fprintf(stderr, "Operation not recognised: %s\n", operation);

        return 1;

    }

    else if (op_result == OP_FAILED)

    {

        fprintf(stderr, "Operation failed: %s\n", operation);

        return 1;

    }

    else

        return 0;

}

enum op_results run_operation(ext2_filsys fs, const char *operation, int argc, char *argv[]);

int run_script(ext2_filsys fs, int argc, char *argv[])

{

    FILE *fp;

    char buffer[BUFSIZE];

    struct read_line_state state;

    enum op_results op_result;

    int num_args;

    char *args[MAX_ARGS];

    int i;

    for (i = 0; i < argc; i++)

    {

        fp = fopen(argv[i], "r");

        state.buffer = buffer;

        state.start = buffer;

        state.end = buffer;

        state.buffer_size = BUFSIZE;

        state.remaining = BUFSIZE - 1;

        while (read_line(fp, &state) != NULL)

        {

            parse_line(state.start, state.eolp, &num_args, args, MAX_ARGS);

            if (num_args > 1)

            {

                op_result = run_operation(fs, args[0], num_args - 1, &args[1]);

                if (handle_op_result(args[0], op_result))

                    return 1;

            }

            state.start = state.eolp + 1;

        }

        fclose(fp);

    }

    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\

Transfer 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\

\n\

Image operations:\n\

\n\

  ls            List files and directories within the image\n\

  mkdir         Make directories within the image\n\

  rm            Remove non-directory objects from the image\n\

  rmdir         Remove directories from the image\n\

\n\

Script operations:\n\

\n\

  script        Read operations from a script file\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},

    {"rm", remove_non_dirs},

    {"rmdir", remove_dirs},

    {"script", run_script},

    {NULL, NULL},

    };

/* Invocation of operations. */

enum op_results run_operation(ext2_filsys fs, const char *operation, int argc, char *argv[])

{

    struct operation *op;

    int exitcode;

    for (op = &operations[0]; op->name != NULL; op++)

    {

        if (!strcmp(operation, op->name))

        {

            exitcode = op->fn(fs, argc, argv);

            if (exitcode)

                return OP_FAILED;

            break;

        }

    }

    if (op->name == NULL)

        return OP_UNKNOWN;

    return OP_SUCCESS;

}

/* 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, *filename;

    int num_args;

    enum op_results op_result;

    /* 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;

    }