/*

 * A resource offering support for accessing directories.

 *

 * 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 <thread>

#include <fsclient/client.h>

#include <ipc/cap_alloc.h>

#include "directory_resource.h"

#include "directory_object_server.h"

DirectoryResource::DirectoryResource(fileid_t fileid,

                                     DirectoryProvider *provider)

: _provider(provider), fileid(fileid)

{

}

DirectoryResource::~DirectoryResource()

{

}

int DirectoryResource::expected_items()

{

    return DirectoryObject_expected_items;

}

ipc_server_handler_type DirectoryResource::handler()

{

    return (ipc_server_handler_type) handle_DirectoryObject;

}

/* Close the resource, removing the provider from the registry if

   appropriate. */

void DirectoryResource::close()

{   

    /* Detach the resource, potentially removing the file provider. */

    _provider->registry()->detach(fileid, _provider);

}

/* Thread payload for directory listing production. */

static void read_directory(DirectoryProvider *provider, fileid_t fileid,

                           file_t *writer)

{

    DirectoryAccessor *accessor = provider->accessor();

    /* Invoke the directory reading mechanism. */

    accessor->read_directory(writer);

    /* Close and detach from the registry. */

    client_close(writer);

    provider->registry()->detach(fileid, provider);

}

/* Open a directory to read the directory entries via a file-like object. */

long DirectoryResource::opendir(offset_t *size, l4_cap_idx_t *file,

                                object_flags_t *object_flags)

{

    file_t *reader, *writer;

    /* Mapping of the reader's memory region should be avoided because no use

       of the reader will be made here. */

    long err = client_pipe(&reader, &writer, 0);

    if (err)

        return err;

    *size = reader->size;

    *file = reader->ref;

    *object_flags = 0;      /* does not support mmap, has no fixed size */

    /* Discard the reader structure but preserve the capability. */

    reader->ref = L4_INVALID_CAP;

    file_close(reader);

    /* Attach to the provider to keep it available, even if the directory

       resource is released. */

    _provider->attach();

    /* Initiate the reading process. */

    std::thread(read_directory, _provider, fileid, writer).detach();

    /* Send the capability immediately, discarding it afterwards. */

    complete_Directory_opendir(*size, *file, *object_flags);

    ipc_cap_free_um(*file);

    return IPC_MESSAGE_SENT;

}

/* NOTE: These methods are effectively the same as the FilePager methods. */

/* Subscribe to notifications. */

long DirectoryResource::subscribe(l4_cap_idx_t endpoint, notify_flags_t flags)

{

    _endpoint = _provider->subscribe(endpoint, flags);

    return L4_EOK;

}

long DirectoryResource::unsubscribe(l4_cap_idx_t endpoint)

{

    _provider->unsubscribe(_endpoint, endpoint);

    return L4_EOK;

}

// vim: tabstop=4 expandtab shiftwidth=4