/*

 * Copy a file into 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 <sys/stat.h>

#include <ext2fs/ext2fs.h>

#include "file.h"

#include "image.h"

#include "path.h"

#include "session.h"

/* Copy buffer size. */

static int BUFSIZE = 4096;

/* Alternative metadata set by options. */

extern struct metadata md;

/* Copy a file into the filesystem image. */

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

    /* Truncate the file, if overwriting. */

    if (!(flags & EXT2_FILE_CREATE))

        ext2fs_file_set_size2(file, 0);

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

}

/* Make a new object using the given function. */

static int _make_object(ext2_filsys fs, const char *filename,

                        ext2_ino_t ino_parent, const char *basename,

                        ext2_ino_t *ino_target,

                        errcode_t (*fn)(ext2_filsys, ext2_ino_t, const char *,

                                        __u16, __u16, __u16, ext2_ino_t *))

{

    errcode_t retval;

    struct stat st;

    /* Obtain the metadata. */

    if (lstat(filename, &st))

    {

        fprintf(stderr, "Failed to read object metadata: %s\n", filename);

        return 1;

    }

    retval = fn(fs, ino_parent, basename, st.st_mode & ~md.mask,

                md.have_uid ? md.uid : st.st_uid,

                md.have_gid ? md.gid : st.st_gid,

                ino_target);

    if (retval)

    {

        fprintf(stderr, "Failed to create object: %s\n", filename);

        return 1;

    }

    return 0;

}

/* Copy a source file from the external environment into the filesystem. */

static int _copy_in(ext2_filsys fs, const char *filename, ext2_ino_t ino_target,

                    const char *basename)

{

    errcode_t retval;

    int flags;

    /* By default, treat the target as a new object. */

    ext2_ino_t ino_parent = ino_target;

    int target_is_new = 1;

    /* Source file details. */

    struct stat st;

    /* Without a basename, the target exists and is either a directory, into

       which the source file shall be copied, or it is a file that shall be

       overwritten (for which the basename is irrelevant). */

    if (basename == NULL)

    {

        basename = path_basename(filename);

        target_is_new = image_isdir_by_inode(fs, ino_target);

    }

    /* Directories are created with the same metadata. */

    if (isdir(filename))

    {

        if (!target_is_new)

        {

            fprintf(stderr, "Directory cannot be copied as it already exists: %s\n", filename);

            return 1;

        }

        if (_make_object(fs, filename, ino_parent, basename, &ino_target,

                         image_make_dir))

            return 1;

    }

    /* Files are copied. */

    else if (isfile(filename))

    {

        flags = EXT2_FILE_WRITE;

        /* Obtain the inode for the target file. */

        if (target_is_new)

        {

            if (_make_object(fs, filename, ino_parent, basename, &ino_target,

                             image_create_file))

                return 1;

            flags |= EXT2_FILE_CREATE;

        }

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

        if (_copy_file_in(filename, fs, ino_target, flags))

        {

            fprintf(stderr, "Failed to copy file: %s\n", filename);

            return 1;

        }

    }

}

/* Copy source files from the external environment into the filesystem image. */

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

{

    errcode_t retval;

    int i;

    /* Target filename details. */

    const char *target = argv[argc - 1];

    const char *target_remaining = target;

    const char *basename;

    /* Target file and directory details. */

    int target_is_file;

    ext2_ino_t ino_target;

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

        }

        /* Any absent target leaves the basename remaining.

           The resolved target is the parent directory. */

        target_is_file = 0;

        basename = target_remaining;

    }

    else

    {

        /* Any present target can be a file or directory.

           The resolved target is the actual target. */

        target_is_file = image_isfile_by_inode(fs, ino_target);

        basename = NULL;

    }

    /* 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 (_copy_in(fs, argv[i], ino_target, basename))

            return 1;

    return 0;

}

/* vim: tabstop=4 expandtab shiftwidth=4

*/