Iso9660Directory.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef ISO9660DIRECTORY_H
#define ISO9660DIRECTORY_H

#include "Iso9660File.h"
#include "Iso9660Filesystem.h"
#include "iso9660.h"
#include "modules/system/vfs/Directory.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/machine/Disk.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/utility.h"

class File;

class Iso9660Directory : public Directory
{
    friend class Iso9660File;

  private:
    Iso9660Directory(const Iso9660Directory &);
    Iso9660Directory &operator=(const Iso9660Directory &);

  public:
    Iso9660Directory(
        String name, size_t inode, class Iso9660Filesystem *pFs, File *pParent,
        Iso9660DirRecord &dirRec, Time::Timestamp accessedTime = 0,
        Time::Timestamp modifiedTime = 0, Time::Timestamp creationTime = 0)
        : Directory(
              name, accessedTime, modifiedTime, creationTime, inode, pFs, 0,
              pParent),
          m_pFs(pFs), m_Dir(dirRec)
    {
    }
    virtual ~Iso9660Directory();

    virtual void cacheDirectoryContents()
    {
        if (!m_pFs)
        {
            ERROR("ISO9660: m_pFs is null!");
            return;
        }

        Disk *myDisk = m_pFs->getDisk();

        // Grab our parent (will always be a directory)
        Iso9660Directory *pParentDir =
            reinterpret_cast<Iso9660Directory *>(m_pParent);
        if (pParentDir == 0)
        {
            // Root directory, . and .. should redirect to this directory
            Iso9660Directory *dot = new Iso9660Directory(
                String("."), m_Inode, m_pFs, m_pParent, m_Dir, m_AccessedTime,
                m_ModifiedTime, m_CreationTime);
            Iso9660Directory *dotdot = new Iso9660Directory(
                String(".."), m_Inode, m_pFs, m_pParent, m_Dir, m_AccessedTime,
                m_ModifiedTime, m_CreationTime);
            addDirectoryEntry(String("."), dot);
            addDirectoryEntry(String(".."), dotdot);
        }
        else
        {
            // Non-root, . and .. should point to the correct locations
            Iso9660Directory *dot = new Iso9660Directory(
                String("."), m_Inode, m_pFs, m_pParent, m_Dir, m_AccessedTime,
                m_ModifiedTime, m_CreationTime);
            addDirectoryEntry(String("."), dot);

            Iso9660Directory *dotdot = new Iso9660Directory(
                String(".."), pParentDir->getInode(), pParentDir->m_pFs,
                pParentDir->getParent(), pParentDir->getDirRecord(),
                pParentDir->getAccessedTime(), pParentDir->getModifiedTime(),
                pParentDir->getCreationTime());
            addDirectoryEntry(String(".."), dotdot);
        }

        // How big is the directory?
        size_t dirSize = LITTLE_TO_HOST32(m_Dir.DataLen_LE);
        size_t dirLoc = LITTLE_TO_HOST32(m_Dir.ExtentLocation_LE);

        // Read the directory, block by block
        size_t numBlocks = (dirSize > 2048) ? dirSize / 2048 : 1;
        size_t i;
        for (i = 0; i < numBlocks; i++)
        {
            // Read the block
            uintptr_t block = myDisk->read((dirLoc + i) * 2048);

            // Complete, so start reading entries
            size_t offset = 0;
            bool bLastHit = false;
            while (offset < 2048)
            {
                Iso9660DirRecord *record =
                    reinterpret_cast<Iso9660DirRecord *>(block + offset);
                offset += record->RecLen;
                uint8_t *fileIdent = reinterpret_cast<uint8_t *>(
                    adjust_pointer(record, sizeof(*record)));

                if (record->RecLen == 0)
                {
                    bLastHit = true;
                    break;
                }
                else if (record->FileFlags & (1 << 0))
                    continue;
                else if (
                    record->FileFlags & (1 << 1) && record->FileIdentLen == 1)
                {
                    if (fileIdent[0] == 0 || fileIdent[0] == 1)
                        continue;
                }

                String fileName = m_pFs->parseName(*record);

                // Grab the UNIX timestamp
                Time::Timestamp unixTime = m_pFs->timeToUnix(record->Time);
                if (record->FileFlags & (1 << 1))
                {
                    Iso9660Directory *dir = new Iso9660Directory(
                        fileName, 0, m_pFs, this, *record, unixTime, unixTime,
                        unixTime);
                    addDirectoryEntry(fileName, dir);
                }
                else
                {
                    Iso9660File *file = new Iso9660File(
                        fileName, unixTime, unixTime, unixTime, 0, m_pFs,
                        LITTLE_TO_HOST32(record->DataLen_LE), *record, this);
                    addDirectoryEntry(fileName, file);
                }
            }

            // Last in the block, but are there still blocks to read?
            if (bLastHit && ((i + 1) == numBlocks))
                break;
        }

        markCachePopulated();
    }

    virtual bool addEntry(String filename, File *pFile, size_t type)
    {
        return false;
    }

    virtual bool removeEntry(File *pFile)
    {
        return false;
    }

    void fileAttributeChanged()
    {
    }

    inline Iso9660DirRecord &getDirRecord()
    {
        return m_Dir;
    }

  private:
    // Filesystem object
    Iso9660Filesystem *m_pFs;

    // Our internal directory information (info about *this* directory, not the
    // child)
    Iso9660DirRecord m_Dir;
};

#endif