/*

 * A resource offering support for creating contexts and opening files.

 *

 * Copyright (C) 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 "opener_server.h"

#include "opener_resource.h"

#include "resource_server.h"

/* Support for providing access to files. */

OpenerResource::OpenerResource(FileObjectRegistry *registry)

: _registry(registry)

{

}

OpenerResource::~OpenerResource()

{

}

int OpenerResource::expected_items()

{

    return Opener_expected_items;

}

ipc_server_handler_type OpenerResource::handler()

{

    return (ipc_server_handler_type) handle_Opener;

}

/* Obtain the identifier for any active parent directory for a path. */

long OpenerResource::get_parent(const char *path, fileid_t *fileid)

{

    char *sep = strrchr(path, (int) '/');

    long err;

    /* For top-level paths, use the empty string to get the root directory.

       Otherwise, obtain the parent directory path to obtain the file

       identifier. */

    if (sep == NULL)

        err = get_fileid("", 0, fileid);

    else

    {

        char *parent = strndup(path, sep - path + 1);

        parent[sep - path] = '\0';

        err = get_fileid(parent, 0, fileid);

        free(parent);

    }

    return err;

}

/* Obtain any active parent directory for a path, notifying its subscribers of

   the file opening event. */

long OpenerResource::notify_parent(const char *path)

{

    DirectoryProvider *provider;

    fileid_t fileid;

    long err;

    err = get_parent(path, &fileid);

    if (err)

        return err;

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

    err = _registry->find_directory_provider(fileid, &provider);

    if (err)

        return err;

    /* With any active provider, send a notification.

       NOTE: This should also communicate which file was involved, probably

       NOTE: using the file identifier of the opened file. */

    provider->notify_all(NOTIFY_FILE_OPENED);

    return L4_EOK;

}

/* Return an object for the given path and flags. */

long OpenerResource::open(const char *path, flags_t flags, offset_t *size,

                          l4_cap_idx_t *cap, object_flags_t *object_flags)

{

    /* Obtain an identifier for the file, even for new files (subject to use of

       the appropriate flag). */

    fileid_t fileid;

    long err = get_fileid(path, flags, &fileid);

    if (err)

        return err;

    /* Notify listeners subscribed to the parent of the opened object. */

    notify_parent(path);

    /* Test for file and directory access. */

    if (accessing_directory(path, flags, fileid))

        return get_directory(path, flags, fileid, size, cap, object_flags);

    else if (accessing_file(path, flags, fileid))

        return get_file(path, flags, fileid, size, cap, object_flags);

    else

        return -L4_EIO;

}

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

long OpenerResource::get_directory(const char *path, flags_t flags,

                                   fileid_t fileid, offset_t *size,

                                   l4_cap_idx_t *cap,

                                   object_flags_t *object_flags)

{

    Resource *directory;

    long err = _registry->get_directory(this, path, flags, fileid, &directory);

    if (err)

        return err;

    /* Provide non-file values for certain outputs. */

    *size = 0;

    *object_flags = 0;

    return ResourceServer(directory).start_thread(cap);

}

/* Return a file pager. */

long OpenerResource::get_file(const char *path, flags_t flags, fileid_t fileid,

                              offset_t *size, l4_cap_idx_t *cap,

                              object_flags_t *object_flags)

{

    Pager *pager;

    long err = _registry->get_pager(this, path, flags, fileid, &pager);

    if (err)

        return err;

    /* Obtain the size details from the pager, also providing appropriate

       flags. */

    *size = pager->get_data_size();

    *object_flags = OBJECT_SUPPORTS_MMAP | OBJECT_HAS_SIZE;

    return ResourceServer(pager).start_thread(cap);

}

/* Opener interface methods. */

long OpenerResource::context(l4_cap_idx_t *context)

{

    OpenerContextResource *resource = new OpenerContextResource(this);

    /* Complete the initialisation and start a server in a new thread.

       If the thread does not start, the resource will be finalised. */

    return ResourceServer(resource).start_thread(context);

}

// vim: tabstop=4 expandtab shiftwidth=4