/*

 * File operations performed by an Ext2-compatible filesystem.

 *

 * Copyright (C) 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 <e2access/access.h>

#include <e2access/image.h>

#include <e2access/path.h>

#include <systypes/fcntl.h>

#include "ext2_file_operations.h"

/* Access and object type tests. */

bool Ext2FileOperations::can_access(user_t user, flags_t flags, ext2_ino_t ino)

{

    struct ext2_inode inode;

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

    if (retval)

        return false;

    if ((flags & O_RDWR) || (flags & O_WRONLY))

        return access_can_write(user, &inode);

    else

        return access_can_read(user, &inode);

}

/* Assert that a directory is empty. */

bool Ext2FileOperations::directory_is_empty(ext2_ino_t ino)

{

    std::lock_guard<std::mutex> guard(_lock);

    return !image_dir_empty_by_inode(_fs, ino);

}

/* Test for a directory. */

bool Ext2FileOperations::is_directory(ext2_ino_t ino_file)

{

    std::lock_guard<std::mutex> guard(_lock);

    return image_isdir_by_inode(_fs, ino_file);

}

/* Test for a file. */

bool Ext2FileOperations::is_file(ext2_ino_t ino_file)

{

    std::lock_guard<std::mutex> guard(_lock);

    return image_isfile_by_inode(_fs, ino_file);

}

/* Perform closing operations on a file. */

void Ext2FileOperations::close_file(ext2_file_t file)

{

    std::lock_guard<std::mutex> guard(_lock);

    /* ext2fs_file_flush is called within the close function. */

    ext2fs_file_close(file);

}

/* Create a file in the directory indicated by the given inode number with the

   given filename. The file is created with the given user permissions. */

long Ext2FileOperations::create_file(ext2_ino_t ino_parent, const char *filename,

                                     user_t user, ext2_ino_t *ino)

{

    if (!path_is_leafname(filename))

        return -L4_EINVAL;

    std::lock_guard<std::mutex> guard(_lock);

    struct ext2_inode inode_parent;

    errcode_t retval = ext2fs_read_inode(_fs, ino_parent, &inode_parent);

    if (retval)

        return -L4_EIO;

    if (!access_can_write(user, &inode_parent))

        return -L4_EACCESS;

    if (image_create_file(_fs, ino_parent, filename, 0666 & ~user.umask,

                          user.uid, user.gid, ino))

        return -L4_EIO;

    return L4_EOK;

}

/* For the given 'path', return an inode number or indicate the 'remaining'

   part of the path that cannot be resolved. */

long Ext2FileOperations::find_file(const char *path, ext2_ino_t *ino,

                                   const char **remaining)

{

    std::lock_guard<std::mutex> guard(_lock);

    *remaining = path;

    errcode_t retval = image_resolve_by_path(_fs, remaining, ino);

    // NOTE: Map error conditions.

    if (retval)

        return -L4_EIO;

    return L4_EOK;

}

/* Make a new directory. */

long Ext2FileOperations::mkdir(ext2_ino_t ino_parent, const char *basename,

                               sys_mode_t mode, user_t user)

{

    std::lock_guard<std::mutex> guard(_lock);

    ext2_ino_t ino;

    errcode_t retval;

    /* Test for permission to create the directory. */

    if (!can_access(user, O_WRONLY, ino_parent))

        return -L4_EACCESS;

    /* Make the directory. */

    retval = image_make_dir(_fs, ino_parent, basename, mode, user.uid, user.gid,

                            &ino);

    // NOTE: Map error conditions.

    if (retval)

        return -L4_EIO;

    return L4_EOK;

}

/* Open the file associated with the indicated inode. */

long Ext2FileOperations::open_file(ext2_ino_t ino, ext2_file_t *file)

{

    std::lock_guard<std::mutex> guard(_lock);

    errcode_t retval = ext2fs_file_open(_fs, ino, EXT2_FILE_WRITE, file);

    // NOTE: Map error conditions.

    if (retval)

        return -L4_EIO;

    return L4_EOK;

}

/* Remove an object from a directory. */

long Ext2FileOperations::remove(ext2_ino_t ino)

{

    std::lock_guard<std::mutex> guard(_lock);

    errcode_t retval = image_remove_by_inode(_fs, ino);

    // NOTE: Map error conditions.

    if (retval)

        return -L4_EIO;

    return L4_EOK;

}

/* Rename an object. */

long Ext2FileOperations::rename(ext2_ino_t source,

                                ext2_ino_t source_parent, const char *source_basename,

                                ext2_ino_t target_parent, const char *target_basename)

{

    std::lock_guard<std::mutex> guard(_lock);

    errcode_t retval = image_rename(_fs, source, source_parent, source_basename,

                                    target_parent, target_basename);

    // NOTE: Map error conditions.

    if (retval)

        return -L4_EIO;

    return L4_EOK;

}

/* Unlink an object from a directory. */

long Ext2FileOperations::unlink(ext2_ino_t ino_parent, ext2_ino_t ino)

{

    std::lock_guard<std::mutex> guard(_lock);

    errcode_t retval = image_unlink_by_inode(_fs, ino_parent, ino);

    // NOTE: Map error conditions.

    if (retval)

        return -L4_EIO;

    return L4_EOK;

}

/* Obtain the size of a file. */

offset_t Ext2FileOperations::get_size(ext2_file_t file)

{

    std::lock_guard<std::mutex> guard(_lock);

    return ext2fs_file_get_size(file);

}

/* Update the size of a file. */

void Ext2FileOperations::set_size(ext2_file_t file, offset_t size)

{

    std::lock_guard<std::mutex> guard(_lock);

    ext2fs_file_set_size(file, size);

}

/* Populate the given memory region with file content. */

offset_t Ext2FileOperations::read_file(ext2_file_t file, offset_t filepos, void *addr, offset_t size)

{

    std::lock_guard<std::mutex> guard(_lock);

    unsigned int nread;

    ext2fs_file_llseek(file, filepos, SEEK_SET, NULL);

    ext2fs_file_read(file, (void *) addr, size, &nread);

    return (offset_t) nread;

}

/* Transfer content from the given memory region to a file. */

void Ext2FileOperations::write_file(ext2_file_t file, offset_t filepos, const void *addr, offset_t size)

{

    std::lock_guard<std::mutex> guard(_lock);

    ext2fs_file_llseek(file, filepos, SEEK_SET, NULL);

    ext2fs_file_write(file, addr, size, NULL);

}

/* Obtain information for the given inode. */

long Ext2FileOperations::read_inode(ext2_ino_t ino, struct ext2_inode *inode)

{

    std::lock_guard<std::mutex> guard(_lock);

    if (ext2fs_read_inode(_fs, ino, inode))

        return -L4_EIO;

    return L4_EOK;

}

/* Obtain stat-based information for the given inode. */

long Ext2FileOperations::stat_inode(ext2_ino_t ino, struct stat *st)

{

    std::lock_guard<std::mutex> guard(_lock);

    if (image_stat_inode(_fs, ino, st))

        return -L4_EIO;

    return L4_EOK;

}

/* Directory iteration support. */

/* Callback function invoking the callback method. */

static int _directory_iterate_fn(struct ext2_dir_entry *dir_entry,

                                 int offset, int blocksize, char *buf,

                                 void *priv_data)

{

    struct Ext2DirectoryIteration *data = reinterpret_cast<struct Ext2DirectoryIteration *>(priv_data);

    return data->ops->directory_iterate_fn(dir_entry, offset, blocksize, buf, data);

}

/* Callback method invoking the actual callback, with control over locking. */

int Ext2FileOperations::directory_iterate_fn(struct ext2_dir_entry *dir_entry,

                                             int offset, int blocksize,

                                             char *buf, struct Ext2DirectoryIteration *priv_data)

{

    /* Release the lock to allow other operations to proceed. */

    _lock.unlock();

    /* Invoke the actual callback function. */

    struct Ext2DirectoryIteration *data = reinterpret_cast<struct Ext2DirectoryIteration *>(priv_data);

    int result = data->func(dir_entry, offset, blocksize, buf, data->priv_data);

    /* Acquire the lock and continue iteration. */

    _lock.lock();

    return result;

}

/* Initiate iteration over a directory, with the given 'func' being called

   with directory entry details for each entry. */

long Ext2FileOperations::directory_iterate(ext2_ino_t dir,

                                           int func(struct ext2_dir_entry *, int, int,

                                                    char *, void *),

                                           void *priv_data)

{

    /* NOTE: Iteration should probably be interrupted if it appears that the

             directory has been modified and the structure of the data has

             been changed. This condition might then cause iteration to begin

             again, skipping ahead to the entry after the last visited entry. */

    /* Acquire the lock for iteration to proceed safely. */

    _lock.lock();

    /* Begin iteration using the given callback function to invoke a callback

       method in this object that will wrap the actual callback with locking

       operations. */

    struct Ext2DirectoryIteration data = {this, func, priv_data};

    int result = ext2fs_dir_iterate(_fs, dir, 0, 0, _directory_iterate_fn, &data);

    /* Release the lock upon finishing iteration. */

    _lock.unlock();

    if (result)

        return -L4_EIO;

    else

        return L4_EOK;

}

// vim: tabstop=4 expandtab shiftwidth=4