/*

 * An opener for a file provided 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 <string.h>

#include <e2access/path.h>

#include <fsclient/client.h>

#include <resource/resource_server.h>

#include <systypes/fcntl.h>

#include <systypes/stat.h>

#include "ext2_directory_accessor.h"

#include "ext2_file_accessor.h"

#include "ext2_file_opener.h"

Ext2FileOpener::~Ext2FileOpener()

{

}

/* Test if a directory is being accessed. */

bool Ext2FileOpener::accessing_directory(flags_t flags, fileid_t fileid)

{

    (void) flags;

    return _ops->is_directory((ext2_ino_t) fileid);

}

/* Test if a file is being accessed. */

bool Ext2FileOpener::accessing_file(flags_t flags, fileid_t fileid)

{

    (void) flags;

    return _ops->is_file((ext2_ino_t) fileid);

}

/* Test if a directory is empty. */

bool Ext2FileOpener::directory_is_empty(fileid_t fileid)

{

    return _ops->directory_is_empty(fileid);

}

/* Return a file identifier for the given 'path'. */

long Ext2FileOpener::get_fileid(const char *path, flags_t flags, fileid_t *fileid)

{

    ext2_ino_t ino;

    const char *remaining;

    long err = _ops->find_file(path, &ino, &remaining);

    /* Return an existing file. */

    if (!err)

    {

        if (!_ops->can_access(_user, flags, ino))

            return -L4_EACCESS;

        *fileid = (fileid_t) ino;

        return L4_EOK;

    }

    *fileid = FILEID_INVALID;

    /* Create a missing file if possible. */

    if ((flags & O_CREAT) && (flags & ~O_DIRECTORY))

    {

        /* Determine whether only the leafname is left of the path, with

           the inode number referring to the parent directory. */

        if (path_is_leafname(remaining))

        {

            err = _ops->create_file(ino, remaining, _user, &ino);

            if (err)

                return err;

            *fileid = (fileid_t) ino;

            return L4_EOK;

        }

    }

    return -L4_ENOENT;

}

/* Return a new accessor for 'fileid'. */

long Ext2FileOpener::make_accessor(flags_t flags, fileid_t fileid,

                                   Accessor **accessor)

{

    (void) flags;

    ext2_file_t file;

    long err = _ops->open_file((ext2_ino_t) fileid, &file);

    if (err)

        return err;

    *accessor = new Ext2FileAccessor(_ops, file, fileid);

    return L4_EOK;

}

/* Return a directory object reference for the given file identifier. */

long Ext2FileOpener::make_directory_accessor(flags_t flags, fileid_t fileid,

                                             DirectoryAccessor **accessor)

{

    (void) flags;

    *accessor = new Ext2DirectoryAccessor(_ops, fileid);

    return L4_EOK;

}

/* Make a new directory. */

long Ext2FileOpener::make_directory_object(const char *path, sys_mode_t mode)

{

    fileid_t fileid, parent;

    long err;

    /* Test for an existing object. */

    err = get_fileid(path, 0, &fileid);

    if (!err)

        return -L4_EEXIST;

    if (err != -L4_ENOENT)

        return err;

    /* Obtain the parent of the new directory. */

    err = get_parent(path, &parent);

    if (err)

        return err;

    return _ops->mkdir((ext2_ino_t) parent, path_basename(path),

                       systypes_from_sys_mode(mode), _user);

}

/* Remove a filesystem object. */

long Ext2FileOpener::remove_object(fileid_t fileid)

{

    return _ops->remove((ext2_ino_t) fileid);

}

/* Rename a filesystem object, placing source inside the parent of target. */

long Ext2FileOpener::rename_object(const char *source, const char *target)

{

    fileid_t source_fileid, source_parent, target_parent;

    long err;

    err = get_fileid(source, 0, &source_fileid);

    if (err)

        return err;

    err = get_parent(source, &source_parent);

    if (err)

        return err;

    err = get_parent(target, &target_parent);

    if (err)

        return err;

    return _ops->rename((ext2_ino_t) source_fileid,

                        (ext2_ino_t) source_parent, path_basename(source),

                        (ext2_ino_t) target_parent, path_basename(target));

}

/* Populate a memory region with statistics metadata for a filesystem object. */

long Ext2FileOpener::stat_object(const char *path, void *base, offset_t size)

{

    struct stat st;

    fileid_t fileid;

    /* Find the object without access restrictions since the metadata is not

       sensitive. */

    ext2_ino_t ino;

    const char *remaining;

    long err = _ops->find_file(path, &ino, &remaining);

    if (err)

        return -L4_ENOENT;

    fileid = (fileid_t) ino;

    if (sizeof(struct stat) > size)

        return -L4_ENOMEM;

    err = _ops->stat_inode((ext2_ino_t) fileid, &st);

    if (err)

        return err;

    /* Use the systypes version of the structure to permit different library

       implementations on the client and server sides of an IPC invocation. */

    systypes_copy_to_sys_stat(&st, (sys_stat_t *) base);

    return L4_EOK;

}

/* Unlink a filesystem object. */

long Ext2FileOpener::unlink_object(fileid_t parent_fileid, fileid_t fileid)

{

    return _ops->unlink((ext2_ino_t) parent_fileid, (ext2_ino_t) fileid);

}

// vim: tabstop=4 expandtab shiftwidth=4