/*

 * An object for a directory 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 <dirent.h>

#include <string.h>

#include <fsclient/client.h>

#include "ext2_directory_accessor.h"

/* Common definitions. */

#define DIRENT_CORE_SIZE (sizeof(struct dirent) - sizeof(((struct dirent *) 0)->d_name))

/* File type conversion. */

static int convert_file_type(int type)

{

  switch (type)

  {

    case EXT2_FT_REG_FILE:  return DT_REG;

    case EXT2_FT_DIR:       return DT_DIR;

    case EXT2_FT_CHRDEV:    return DT_CHR;

    case EXT2_FT_BLKDEV:    return DT_BLK;

    case EXT2_FT_FIFO:      return DT_FIFO;

    case EXT2_FT_SOCK:      return DT_SOCK;

    case EXT2_FT_SYMLINK:   return DT_LNK;

    default:                return DT_UNKNOWN;

  }

}

/* Helper function to ensure alignment in generated entries. */

static int pad_align(int value)

{

  return value + (sizeof(l4_umword_t) - (value % sizeof(l4_umword_t)));

}

/* Callback function. */

static int read_directory_entry(struct ext2_dir_entry *dir_entry, int offset,

                                int blocksize, char *buf, void *priv_data)

{

    (void) offset; (void) blocksize; (void) buf;

    struct Ext2DirectoryState *dir = reinterpret_cast<struct Ext2DirectoryState *>(priv_data);

    dir->entry = dir_entry;

    dir->offset = offset;

    return dir->directory->write_directory_entry(dir);

}

/* Accessor methods. */

Ext2DirectoryAccessor::Ext2DirectoryAccessor(Ext2FileOperations *ops,

                                             fileid_t fileid)

: _ops(ops), _fileid(fileid)

{

}

Ext2DirectoryAccessor::~Ext2DirectoryAccessor()

{

}

/* Thread payload helper method. */

void Ext2DirectoryAccessor::read_directory(file_t *writer)

{

    /* Initialise directory reading state: directory, writer, entry, offset. */

    struct Ext2DirectoryState dir = {this, writer, NULL, 0};

    /* Call the handler function for each directory entry. */

    _ops->directory_iterate((ext2_ino_t) _fileid, read_directory_entry, &dir);

}

/* Callback method for directory entry output. */

int Ext2DirectoryAccessor::write_directory_entry(struct Ext2DirectoryState *dir)

{

    struct ext2_inode inode;

    /* Obtain the inode details for metadata. */

    if (_ops->read_inode(dir->entry->inode, &inode))

        return DIRENT_ABORT;

    /* Align the size of the entry to avoid problems on architectures which

       require aligned accesses and where the compiler needs to assume an

       aligned structure. */

    offset_t namelen = ext2fs_dirent_name_len(dir->entry);

    offset_t reclen = pad_align(DIRENT_CORE_SIZE + namelen);

    /* Construct a directory entry structure of the calculated size. */

    char buffer[reclen];

    struct dirent *dirent = (struct dirent *) buffer;

    memset(dirent, 0, reclen);

    dirent->d_ino = dir->entry->inode;

    dirent->d_off = dir->offset;

    dirent->d_reclen = reclen;

    dirent->d_type = convert_file_type(ext2fs_dirent_file_type(dir->entry));

    /* Copy the name, padding the memory after it to the alignment boundary. */

    memcpy(dirent->d_name, dir->entry->name, namelen);

    /* Write the structure to the pipe. */

    offset_t nwritten = client_write(dir->writer, (const void *) dirent, reclen);

    /* Stop writing if the pipe is closed. */

    if (nwritten < reclen)

        return DIRENT_ABORT;

    return 0;

}

// vim: tabstop=4 expandtab shiftwidth=4