Iso9660Filesystem.cc

/*
 * 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.
 */

#include "Iso9660Filesystem.h"
#include "Iso9660Directory.h"
#include "Iso9660File.h"
#include "iso9660.h"
#include "modules/Module.h"
#include "modules/system/vfs/File.h"
#include "modules/system/vfs/VFS.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/machine/Disk.h"
#include "pedigree/kernel/utilities/StaticString.h"
#include "pedigree/kernel/utilities/utility.h"

String WideToMultiByteStr(uint8_t *in, size_t inLen, size_t maxLen)
{
    NormalStaticString ret;
    ret.clear();

    while ((*in || in[1]) && (inLen > 0) && (maxLen > 0))
    {
        uint16_t c = (*in << 8) | in[1];
        if (c > 0x7f)
        {
        }
        else
            ret.append(static_cast<char>(c));

        in += 2;
        inLen--;
    }
    ret.append('\0');

    return String(ret);
}

Iso9660Filesystem::Iso9660Filesystem()
    : m_pDisk(0), m_PrimaryVolDesc(), m_SuppVolDesc(), m_VolDesc(),
      m_RootDir(0), m_JolietLevel(0), m_BlockSize(0), m_BlockNumber(0),
      m_VolumeLabel(""), m_pRoot(0)
{
}

Iso9660Filesystem::~Iso9660Filesystem()
{
}

bool Iso9660Filesystem::initialise(Disk *pDisk)
{
    m_pDisk = pDisk;

    m_BlockSize = 2048;
    m_BlockNumber = 0;

    // Read volume descriptors until the primary one is found
    // Sector 16 is the first sector on the disk
    bool bFound = false;
    for (size_t i = 16; i < 256; i++)
    {
        uintptr_t buff = m_pDisk->read(i * m_BlockSize);

        // Get the descriptor for this entry
        Iso9660VolumeDescriptor *vDesc =
            reinterpret_cast<Iso9660VolumeDescriptor *>(buff);
        if (StringCompareN(
                reinterpret_cast<const char *>(vDesc->Ident), "CD001", 5) != 0)
        {
            NOTICE("IDENT: " << reinterpret_cast<const char *>(vDesc->Ident));
            return false;
        }

        // Is this a primary descriptor?
        if (vDesc->Type == PRIM_VOL_DESC)
        {
            MemoryCopy(
                &m_PrimaryVolDesc, reinterpret_cast<uint8_t *>(buff),
                sizeof(Iso9660VolumeDescriptorPrimary));
            bFound = true;
        }
        else if (vDesc->Type == SUPP_VOL_DESC)
        {
            MemoryCopy(
                &m_SuppVolDesc, reinterpret_cast<uint8_t *>(buff),
                sizeof(Iso9660VolumeDescriptorPrimary));
            bFound = true;

            // Figure out the Joliet level
            if (m_SuppVolDesc.Unused3_EscSequences[0] == 0x25 &&
                m_SuppVolDesc.Unused3_EscSequences[1] == 0x2F)
            {
                if (m_SuppVolDesc.Unused3_EscSequences[2] == 0x40)
                    m_JolietLevel = 1;
                else if (m_SuppVolDesc.Unused3_EscSequences[2] == 0x43)
                    m_JolietLevel = 2;
                else if (m_SuppVolDesc.Unused3_EscSequences[2] == 0x45)
                    m_JolietLevel = 3;
                else
                    NOTICE("No Joliet level found");
            }
            else
                NOTICE("Not handling Joliet level");
        }
        else if (vDesc->Type == TERM_VOL_DESC)
            break;
    }

    if (!bFound)
    {
        WARNING("ISO9660: Neither a primary or supplementary volume descriptor "
                "was found");
        return false;
    }

    if (m_JolietLevel)
    {
        // In this case, the supplementary descriptor is actually the main one
        m_PrimaryVolDesc = m_SuppVolDesc;
    }

    // Grab the volume label, properly trimmed
    char *volLabel = new char[32];
    MemoryCopy(volLabel, m_PrimaryVolDesc.VolIdent, 32);
    if (m_JolietLevel)
    {
        String volLabelString =
            WideToMultiByteStr(reinterpret_cast<uint8_t *>(volLabel), 32, 32);
        NormalStaticString str;
        str.append(volLabelString);

        size_t i;
        for (i = str.length() - 1; static_cast<int32_t>(i) >= 0; i--)
            if (str[i] != ' ')
                break;
        str = str.left(i + 1);
        m_VolumeLabel = String(str);
    }
    else
    {
        for (size_t i = 31; static_cast<int32_t>(i) >= 0; i--)
        {
            if (volLabel[i] != ' ')
            {
                volLabel[i + 1] = 0;
                break;
            }
        }
        m_VolumeLabel = String(volLabel);
    }

    if (m_VolumeLabel.length() == 0)
    {
        // no volume label found, do a default
        NormalStaticString str;
        str += "no-volume-label@";
        str.append(reinterpret_cast<uintptr_t>(this), 16);
        m_VolumeLabel.assign(str, str.length(), true);
    }

    delete[] volLabel;

    m_RootDir =
        reinterpret_cast<Iso9660DirRecord *>(m_PrimaryVolDesc.RootDirRecord);
    m_pRoot = fileFromDirRecord(*m_RootDir, 1, 0, true);

    m_bReadOnly = true;

    return true;
}

Filesystem *Iso9660Filesystem::probe(Disk *pDisk)
{
    Iso9660Filesystem *pFs = new Iso9660Filesystem();
    if (!pFs->initialise(pDisk))
    {
        delete pFs;
        return 0;
    }
    else
    {
        return pFs;
    }
}

File *Iso9660Filesystem::getRoot() const
{
    return m_pRoot;
}

String Iso9660Filesystem::getVolumeLabel() const
{
    return m_VolumeLabel;
}

uintptr_t Iso9660Filesystem::readBlock(File *pFile, uint64_t location)
{
    // Sanity check.
    if (pFile->isDirectory())
        return 0;

    Iso9660File *file = reinterpret_cast<Iso9660File *>(pFile);
    Iso9660DirRecord rec = file->getDirRecord();

    // Attempting to read past the EOF?
    if (location > pFile->getSize())
        return 0;  // Impossible

    size_t blockSkip = location / m_BlockSize;
    size_t blockNum = LITTLE_TO_HOST32(rec.ExtentLocation_LE) + blockSkip;

    // Begin reading
    uintptr_t buff = m_pDisk->read(blockNum * m_BlockSize);

    return buff;
}

bool Iso9660Filesystem::createFile(
    File *parent, const String &filename, uint32_t mask)
{
    return false;
}

bool Iso9660Filesystem::createDirectory(
    File *parent, const String &filename, uint32_t mask)
{
    return false;
}

bool Iso9660Filesystem::createSymlink(
    File *parent, const String &filename, const String &value)
{
    return false;
}

bool Iso9660Filesystem::remove(File *parent, File *file)
{
    return false;
}

String Iso9660Filesystem::parseName(Iso9660DirRecord &dirRecord)
{
    if (m_JolietLevel)
        return parseJolietName(dirRecord);

    NormalStaticString ret;
    ret.clear();

    // ISO9660 maximum name length is 31 bytes
    uint8_t *fileIdent = reinterpret_cast<uint8_t *>(
        adjust_pointer(&dirRecord, sizeof(dirRecord)));
    size_t len = (dirRecord.FileIdentLen < 31) ? dirRecord.FileIdentLen : 31;
    size_t i;
    for (i = 0; i < len; i++)
    {
        if (fileIdent[i] == ';')
            break;
        else
            ret.append(toLower(static_cast<char>(fileIdent[i])));
    }

    if (i && (fileIdent[i - 1] == '.'))
        ret.stripLast();
    ret.append('\0');

    return String(ret);
}

String Iso9660Filesystem::parseJolietName(Iso9660DirRecord &name)
{
    uint8_t *fileIdent =
        reinterpret_cast<uint8_t *>(adjust_pointer(&name, sizeof(name)));
    String s = WideToMultiByteStr(fileIdent, name.FileIdentLen >> 1, 64);
    NormalStaticString str;
    str.append(s);
    size_t len = str.length();

    if ((len > 2) && (str[len - 2] == ';') && (str[len - 1] == '1'))
        len -= 2;

    while (len >= 2 && (str[len - 1] == '.'))
        len--;
    str = str.left(len);

    return String(str);
}

File *Iso9660Filesystem::fileFromDirRecord(
    Iso9660DirRecord &dir, size_t inodeNum, File *parent, bool bDirectory)
{
    String fileName = parseName(dir);
    Time::Timestamp t = timeToUnix(dir.Time);
    if (bDirectory)
    {
        Iso9660Directory *ret = new Iso9660Directory(
            fileName, inodeNum, this, parent, dir, t, t, t);
        return ret;
    }
    else
    {
        Iso9660File *ret = new Iso9660File(
            fileName, t, t, t, inodeNum, this, LITTLE_TO_HOST32(dir.DataLen_LE),
            dir, parent);
        return ret;
    }
}

static bool initIso9660()
{
    VFS::instance().addProbeCallback(&Iso9660Filesystem::probe);
    return true;
}

static void destroyIso9660()
{
}

MODULE_INFO("iso9660", &initIso9660, &destroyIso9660, "vfs");