/*

 * Access a filesystem.

 *

 * Copyright (C) 2019 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"

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

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 %s not recognised.\n", argv[optind]);

            return -1;

        }

    }

    return 0;

}

/* Show directory entries when iterating. */

struct _list_dir_data

{

    ext2_filsys fs;

    char *filename;

};

static int _list_dir_proc(struct ext2_dir_entry *dirent, int offset,

                          int blocksize, char *buf, void *priv_data)

{

    struct _list_dir_data *data = (struct _list_dir_data *) priv_data;

    ext2_filsys fs = data->fs;

    struct ext2_inode inode;

    /* Select any indicated filename. */

    if ((data->filename != NULL) && (strcmp(dirent->name, data->filename)))

        return 0;

    /* Obtain the inode details for metadata. */

    if (ext2fs_read_inode(fs, dirent->inode, &inode))

        return DIRENT_ABORT;

    /* Output details in the style of "ls -l" showing directory, permissions,

       owner, group and size information. */

    printf("%s%s   %5d %5d      %6d ",

        _image_isdir(fs, dirent->inode) ? "d" : "-",

        get_permission_string(inode.i_mode),

        inode.i_uid,

        inode.i_gid,

        EXT2_I_SIZE(&inode));

    /* Output the name which is presumably not necessarily null-terminated. */

    fwrite(dirent->name, sizeof(char), ext2fs_dirent_name_len(dirent), stdout);

    fputc((int) '\n', stdout);

    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))

        {

            printf("Target %s not found.\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)

        {

            printf("Target %s can only be a file when copying a single file.\n", target);

            return 1;

        }

    }

    else if (!_image_isdir(fs, ino_target))

    {

        printf("Target %s is not a directory.\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)

            {

                printf("Target %s cannot be created since it already exists.\n", target);

                return 1;

            }

            /* Obtain the metadata. */

            if (lstat(argv[i], &st))

                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)

            {

                printf("Failed to create directory %s (%d).\n", argv[i], retval);

                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))

                    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)

                {

                    printf("Failed to create file %s (%d).\n", argv[i], retval);

                    return 1;

                }

                flags |= EXT2_FILE_CREATE;

            }

            /* NOTE: Overwrite/update metadata where appropriate. */

            if (copy_file_in(argv[i], fs, ino_file, flags))

            {

                printf("Failed to write to %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

        {

            printf("Target %s is not a directory.\n", target);

            return 1;

        }

        /* Only permit a target file when one source file is given. */

        if (argc > 2)

        {

            printf("Target %s can only be a file when copying a single file.\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]))

        {

            printf("Source %s is not a file.\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))

            return 1;

        if (copy_file_out(target, argv[i], target_is_file, fs, ino_file))

        {

            printf("Failed to read from %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;

    struct _list_dir_data data;

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

    {

        path = argv[i];

        /* Emit each object. */

        puts(path);

        /* List individual files or directories. */

        if (image_isfile(fs, path))

            data.filename = path_split(path);

        else

            data.filename = NULL;

        data.fs = fs;

        if (image_list_dir(fs, path, _list_dir_proc, &data))

            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];

        if (!*path)

            continue;

        /* Search for the remaining components. */

        if (!image_find_path(fs, &path, &ino))

            continue;

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

            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];

        if (!*path)

            continue;

        /* Ignore missing objects. */

        if (!image_exists(fs, path))

            continue;

        /* Insist on a directory. */

        if (!image_isdir(fs, path))

            return 1;

        /* Remove the directory. */

        if (image_remove_by_path(fs, path))

            return 1;

        /* Unlink the directory. */

        if (image_unlink_by_path(fs, 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)

    {

        printf(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)

    {

        printf("Could not open filesystem using %s\n", fsname);

        return 1;

    }

    //fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE;

    retval = ext2fs_read_bitmaps(fs);

    if (retval)

    {

        printf("Could not read bitmaps from %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);

            break;

        }

    }

    if (op->name == NULL)

    {

        printf("Operation %s is not recognised.\n", operation);

        exitcode = 1;

    }

    /* Close the filesystem image. */

    retval = ext2fs_flush(fs);

    if (retval)

    {

        printf("Error flushing filesystem in %s\n", fsname);

        exitcode = 1;

    }

    retval = ext2fs_close(fs);

    if (retval)

    {

        printf("Error closing filesystem in %s\n", fsname);

        exitcode = 1;

    }

    ext2fs_free(fs);

    return exitcode;

}

/* vim: tabstop=4 expandtab shiftwidth=4

*/