/*

 * Filesystem access functions.

 *

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

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

    int retry;

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

    /* Connect the inode to its parent. */

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

    {

        retval = ext2fs_link(fs, ino_target, basename, *ino_file,

                             EXT2_FT_REG_FILE);

        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;

    }

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

}

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

}

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

}

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

}

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

}

/* 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 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 types in the filesystem image. */

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

}