/*

 * Filesystem access functions.

 *

 * Copyright (C) 2019, 2021, 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 <string.h>

#include <ext2fs/ext2fs.h>

#include "image.h"

#include "path.h"

/* Link an inode within the given target directory having the given basename. */

static errcode_t _image_link(ext2_filsys fs, ext2_ino_t ino_target,

                             const char *basename, ext2_ino_t ino_file,

                             int flags)

{

    errcode_t retval;

    int retry;

    /* Connect the inode to its parent. */

    for (retry = 0; retry <= 1; retry++)

    {

        retval = ext2fs_link(fs, ino_target, basename, ino_file, flags);

        if (!retval)

            break;

        else if (retry)

            return retval;

        /* Expand the directory if necessary. */

        if (retval == EXT2_ET_DIR_NO_SPACE)

            retval = ext2fs_expand_dir(fs, ino_target);

        if (retval)

            return retval;

    }

    return 0;

}

/* Update the parent entry of a renamed directory. */

struct _image_parent_entry_state

{

    ext2_ino_t ino;

};

static int _image_update_parent_entry(struct ext2_dir_entry *dir_entry,

                                      int offset, int blocksize, char *buf,

                                      void *priv_data)

{

    struct _image_parent_entry_state *state = (struct _image_parent_entry_state *) priv_data;

    (void) offset; (void) blocksize; (void) buf;

    if (strcmp(dir_entry->name, "..") == 0)

    {

        dir_entry->inode = state->ino;

        return DIRENT_CHANGED | DIRENT_ABORT;

    }

    else

        return 0;

}

/* Create an inode for a file. */

errcode_t image_create_file(ext2_filsys fs, ext2_ino_t ino_target,

                            const char *basename, __u16 mode,

                            __u16 uid, __u16 gid, ext2_ino_t *ino_file)

{

    struct ext2_inode inode_file;

    errcode_t retval;

    /* Without an inode, create a new one. */

    retval = ext2fs_new_inode(fs, ino_target, LINUX_S_IFREG | mode, 0, ino_file);

    if (retval)

        return retval;

    _image_link(fs, ino_target, basename, *ino_file, EXT2_FT_REG_FILE);

    /* Make sure that subsequent files employ different inodes. */

    ext2fs_inode_alloc_stats2(fs, *ino_file, 1, 0);

    /* Populate the inode details. */

    image_set_metadata(&inode_file, 1, LINUX_S_IFREG | mode, uid, gid);

    inode_file.i_links_count++;

    return ext2fs_write_new_inode(fs, *ino_file, &inode_file);

}

/* Return the appropriate ext2 file type value for the given mode value. */

int image_file_type(int mode)

{

    switch (mode & LINUX_S_IFMT)

    {

        case LINUX_S_IFSOCK: return EXT2_FT_SOCK;

        case LINUX_S_IFLNK: return EXT2_FT_SYMLINK;

        case LINUX_S_IFREG: return EXT2_FT_REG_FILE;

        case LINUX_S_IFBLK: return EXT2_FT_BLKDEV;

        case LINUX_S_IFDIR: return EXT2_FT_DIR;

        case LINUX_S_IFCHR: return EXT2_FT_CHRDEV;

        case LINUX_S_IFIFO: return EXT2_FT_FIFO;

        /* NOTE: Perhaps signal an error. */

        default: return EXT2_FT_REG_FILE;

    }

}

/* Find an object in the given directory with the given name in the filesystem

   image, updating the name reference to refer to the next component. */

errcode_t image_find_next(ext2_filsys fs, ext2_ino_t ino_dir,

                          const char **basename, char *buf, ext2_ino_t *ino)

{

    const char *end = path_component_end(*basename);

    errcode_t retval;

    /* Find the basename in the directory. */

    retval = ext2fs_lookup(fs, ino_dir, *basename, end - *basename, buf, ino);

    /* Update the current component. */

    if (!retval)

        *basename = path_component_next(end);

    return retval;

}

/* Find an object with the given pathname in the filesystem image. */

errcode_t image_find_path(ext2_filsys fs, const char **pathname, ext2_ino_t *ino)

{

    char *buf;

    ext2_ino_t ino_dir;

    errcode_t retval;

    retval = ext2fs_get_mem(fs->blocksize, &buf);

    if (retval)

        return retval;

    /* Skip any leading root marker. */

    if (**pathname == '/')

        (*pathname)++;

    if (!**pathname)

        *ino = EXT2_ROOT_INO;

    /* Start at the root. */

    ino_dir = EXT2_ROOT_INO;

    /* With any remaining path, find the next component. */

    while (**pathname)

    {

        retval = image_find_next(fs, ino_dir, pathname, buf, ino);

        if (retval)

        {

            *ino = ino_dir;

            break;

        }

        /* Move into the found object for searching the next component. */

        ino_dir = *ino;

    }

    ext2fs_free_mem(&buf);

    return retval;

}

/* Find an object in the given directory with the given name in the filesystem

   image. */

errcode_t image_find_file(ext2_filsys fs, const char *dirname,

                          const char *basename, ext2_ino_t *ino)

{

    char pathname[strlen(dirname) + strlen(basename) + 2];

    const char *s = pathname;

    strcpy(pathname, dirname);

    strcat(pathname, "/");

    strcat(pathname, basename);

    return image_find_path(fs, &s, ino);

}

/* Obtain the inode for the object with the given pathname in the filesystem

   image. */

errcode_t image_inode(ext2_filsys fs, const char *pathname,

                      struct ext2_inode *inode)

{

    ext2_ino_t ino;

    errcode_t retval;

    retval = image_find_path(fs, &pathname, &ino);

    if (retval)

        return retval;

    return ext2fs_read_inode(fs, ino, inode);

}

/* List a directory in the filesystem image. */

errcode_t image_list_dir(ext2_filsys fs, const char *path,

                         int (*proc)(struct ext2_dir_entry *, int, int, char *,

                                     void *),

                         void *data)

{

    char *buf;

    ext2_ino_t ino;

    errcode_t retval;

    retval = ext2fs_get_mem(fs->blocksize, &buf);

    if (retval)

        return retval;

    /* Locate the object and test whether it is a directory. */

    retval = image_find_path(fs, &path, &ino);

    if (retval)

    {

        ext2fs_free_mem(&buf);

        return retval;

    }

    if (!_image_isdir(fs, ino))

        return 1;

    /* List the directory contents. */

    retval = ext2fs_dir_iterate(fs, ino, 0, buf, proc, data);

    if (retval)

    {

        ext2fs_free_mem(&buf);

        return retval;

    }

    ext2fs_free_mem(&buf);

    return 0;

}

/* Make a directory in the given directory in the filesystem image having the

   given name and metadata. */

errcode_t image_make_dir(ext2_filsys fs, ext2_ino_t ino_dir,

                         const char *basename, __u16 mode,

                         __u16 uid, __u16 gid, ext2_ino_t *ino)

{

    struct ext2_inode inode_dir;

    errcode_t retval = 0;

    /* Create an inode in the directory. */

    retval = ext2fs_new_inode(fs, ino_dir, LINUX_S_IFDIR | mode, 0, ino);

    if (retval)

        return retval;

    /* Make the directory and update the metadata (due to ext2fs_mkdir

       limitation). */

    retval = ext2fs_mkdir(fs, ino_dir, *ino, basename);

    if (retval)

        return retval;

    retval = ext2fs_read_inode(fs, *ino, &inode_dir);

    if (retval)

        return retval;

    image_set_metadata(&inode_dir, 0, LINUX_S_IFDIR | mode, uid, gid);

    return ext2fs_write_inode(fs, *ino, &inode_dir);

}

/* Make a directory in the given directory in the filesystem image, updating

   the name reference to refer to the next component. */

errcode_t image_make_next_dir(ext2_filsys fs, ext2_ino_t ino_dir,

                              const char **basename, __u16 mode, __u16 uid,

                              __u16 gid, ext2_ino_t *ino)

{

    char *end = (char *) path_component_end(*basename);

    char endchar = *end;

    errcode_t retval = 0;

    /* Delimit the basename and make a directory using the inode. */

    if (endchar)

        *end = '\0';

    /* Do not create directories for empty components. */

    if (**basename)

        retval = image_make_dir(fs, ino_dir, *basename, mode, uid, gid, ino);

    /* Restore the path separator and update the current component. */

    if (endchar)

        *end = '/';

    if (!retval)

        *basename = path_component_next(end);

    return retval;

}

/* Make directories descending to the given path in the filesystem image. */

errcode_t image_make_dirs(ext2_filsys fs, const char **pathname,

                          ext2_ino_t ino_dir, __u16 mode, __u16 uid, __u16 gid)

{

    ext2_ino_t ino;

    errcode_t retval;

    while (**pathname)

    {

        retval = image_make_next_dir(fs, ino_dir, pathname, mode, uid, gid, &ino);

        if (retval)

            return retval;

        /* Move into the created object for handling the next component. */

        ino_dir = ino;

    }

    return 0;

}

/* Remove an inode. */

errcode_t image_remove_by_inode(ext2_filsys fs, ext2_ino_t ino)

{

    struct ext2_inode_large inode;

    errcode_t err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *) &inode,

                                           sizeof(inode));

    /* Handle invalid inodes, ignore unreferenced inodes. */

    if (err)

        return err;

    if (!inode.i_links_count)

        return 0;

    /* Decrement the reference count. With no more references to the inode,

       remove its resources. */

    inode.i_links_count--;

    if (!inode.i_links_count)

    {

        err = ext2fs_free_ext_attr(fs, ino, &inode);

        if (!err)

        {

            /* Deallocate blocks, if appropriate. ~0ULL as the end represents

               truncation. */

            if (ext2fs_inode_has_valid_blocks2(fs, (struct ext2_inode *) &inode))

            {

                err = ext2fs_punch(fs, ino, (struct ext2_inode *) &inode, NULL,

                                   0, ~0ULL);

                /* Update allocation statistics. */

                if (!err)

                    ext2fs_inode_alloc_stats2(fs, ino, -1,

                                  LINUX_S_ISDIR(inode.i_mode));

            }

        }

    }

    return ext2fs_write_inode_full(fs, ino, (struct ext2_inode *) &inode,

                                   sizeof(inode));

}

/* Remove a directory entry using its full path. */

errcode_t image_remove_by_path(ext2_filsys fs, const char *path)

{

    const char *remaining = path;

    ext2_ino_t ino;

    errcode_t retval = image_find_path(fs, &remaining, &ino);

    if (retval)

        return retval;

    return image_remove_by_inode(fs, ino);

}

/* Rename a file. */

errcode_t image_rename(ext2_filsys fs, ext2_ino_t source,

                       ext2_ino_t source_parent, const char *source_basename,

                       ext2_ino_t target_parent, const char *target_basename)

{

    errcode_t retval;

    struct ext2_inode source_inode, source_parent_inode, target_parent_inode;

    struct _image_parent_entry_state state = {target_parent};

    /* NOTE: Should check for space. */

    /* Obtain the source object. */

    retval = ext2fs_read_inode(fs, source, &source_inode);

    if (retval)

        return retval;

    /* Link from the target parent. */

    retval = _image_link(fs, target_parent, target_basename, source,

                         image_file_type(source_inode.i_mode));

    if (retval)

        return retval;

    if (_image_isdir(fs, source))

    {

        /* Update the link count for the target. */

        retval = ext2fs_read_inode(fs, target_parent, &target_parent_inode);

        if (retval)

            return retval;

        target_parent_inode.i_links_count++;

        retval = ext2fs_write_inode(fs, target_parent, &target_parent_inode);

        if (retval)

            return retval;

        /* A directory needs its .. entry updating to refer to its new

           parent. */

        retval = ext2fs_dir_iterate(fs, source, 0, NULL,

                                    _image_update_parent_entry, &state);

        /* Update the link count for the source. */

        retval = ext2fs_read_inode(fs, source_parent, &source_parent_inode);

        if (retval)

            return retval;

        source_parent_inode.i_links_count--;

        retval = ext2fs_write_inode(fs, source_parent, &source_parent_inode);

        if (retval)

            return retval;

    }

    /* Unlink from the source parent, doing so by name because the file is now

       already linked from the target parent, and when the parents are the same,

       unlinking by inode could just cause the file to disappear from the

       catalogue. */

    retval = image_unlink_by_name(fs, source_parent, source_basename);

    if (retval)

        return retval;

    return ext2fs_flush2(fs, 0);

}

/* Set the mode, user and group metadata for a file. */

void image_set_metadata(struct ext2_inode *inode, int clean, __u16 mode,

                        __u16 uid, __u16 gid)

{

    if (clean)

        memset(inode, 0, sizeof(*inode));

    inode->i_mode = mode;

    inode->i_uid = uid;

    inode->i_gid = gid;

}

/* Copy file metadata into a stat structure. */

errcode_t image_stat_inode(ext2_filsys fs, ext2_ino_t ino, struct stat *st)

{

    struct ext2_inode inode;

    errcode_t retval = ext2fs_read_inode(fs, ino, &inode);

    if (retval)

        return retval;

    st->st_dev = 0;                       /* device identifier */

    st->st_ino = ino;

    st->st_mode = inode.i_mode;

    st->st_nlink = inode.i_links_count;

    st->st_uid = inode_uid(inode);

    st->st_gid = inode_gid(inode);

    st->st_rdev = 0;                      /* special file device identifier */

    st->st_size = EXT2_I_SIZE(&inode);

    st->st_blksize = fs->blocksize;

    st->st_blocks = 0;                    /* number of 512 byte blocks allocated */

    st->st_atim.tv_sec = inode.i_atime;

    st->st_atim.tv_nsec = 0;              /* nanosecond resolution */

    st->st_mtim.tv_sec = inode.i_mtime;

    st->st_mtim.tv_nsec = 0;

    st->st_ctim.tv_sec = inode.i_ctime;

    st->st_ctim.tv_nsec = 0;

    return 0;

}

/* Unlink a directory entry by name. */

errcode_t image_unlink_by_name(ext2_filsys fs, ext2_ino_t ino_parent,

                               const char *basename)

{

    return ext2fs_unlink(fs, ino_parent, basename, 0, 0);

}

/* Unlink a directory entry by full path. */

errcode_t image_unlink_by_path(ext2_filsys fs, const char *path)

{

    char _path[strlen(path) + 1];

    const char *remaining = _path;

    char *basename;

    ext2_ino_t ino_parent;

    errcode_t retval;

    strcpy(_path, path);

    basename = path_split(_path);

    retval = image_find_path(fs, &remaining, &ino_parent);

    if (retval)

        return retval;

    return ext2fs_unlink(fs, ino_parent, basename, 0, 0);

}

/* Unlink a directory entry by inode number. */

errcode_t image_unlink_by_inode(ext2_filsys fs, ext2_ino_t ino_parent,

                                ext2_ino_t ino)

{

    return ext2fs_unlink(fs, ino_parent, 0, ino, 0);

}

/* Test object presence and types in the filesystem image. */

int image_exists(ext2_filsys fs, const char *name)

{

    ext2_ino_t ino;

    return !image_find_path(fs, &name, &ino);

}

int _image_isdir(ext2_filsys fs, ext2_ino_t ino)

{

    struct ext2_inode inode;

    if (ext2fs_read_inode(fs, ino, &inode))

        return 0;

    return LINUX_S_ISDIR(inode.i_mode);

}

int image_isdir(ext2_filsys fs, const char *name)

{

    ext2_ino_t ino;

    if (image_find_path(fs, &name, &ino))

        return 0;

    return _image_isdir(fs, ino);

}

int _image_isfile(ext2_filsys fs, ext2_ino_t ino)

{

    struct ext2_inode inode;

    if (ext2fs_read_inode(fs, ino, &inode))

        return 0;

    return LINUX_S_ISREG(inode.i_mode);

}

int image_isfile(ext2_filsys fs, const char *name)

{

    ext2_ino_t ino;

    if (image_find_path(fs, &name, &ino))

        return 0;

    return _image_isfile(fs, ino);

}

/* vim: tabstop=4 expandtab shiftwidth=4

*/