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 "pedigree/kernel/Log.h"
#include "pedigree/kernel/TargetInfo.h"
#include "pedigree/kernel/machine/Disk.h"
#include "pedigree/kernel/utilities/StaticString.h"
#include "pedigree/kernel/utilities/utility.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"
 
namespace {
constexpr size_t IsoSectorSize = 2048;
constexpr size_t IsoSectorViewCapacity =
    ((IsoSectorSize + TargetInfo::getPageSize() - 1) / TargetInfo::getPageSize()) + 1;
}  // namespace
 
String WideToMultiByteStr(uint8_t* in, size_t inLen, size_t maxLen) {
  NormalStaticString ret;
  ret.clear();
 
  while (inLen > 0 && maxLen > 0 && (*in || in[1])) {
    uint16_t c = (*in << 8) | in[1];
    if (c > 0x7f) {
    } else {
      ret.append(static_cast<char>(c));
      --maxLen;
    }
 
    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 = IsoSectorSize;
  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++) {
    const uint64_t diskLocation = i * m_BlockSize;
    alignas(Iso9660VolumeDescriptorPrimary) uint8_t sector[IsoSectorSize];
    if (!readSector(diskLocation, sector)) {
      return false;
    }
    const BufferView buffer(sector, sizeof(sector));
 
    // Get the descriptor for this entry
    Iso9660VolumeDescriptor* vDesc = buffer.as<Iso9660VolumeDescriptor>();
    if (StringCompareN(reinterpret_cast<const char*>(vDesc->Ident), "CD001", 5) != 0) {
      NOTICE("IDENT: " << reinterpret_cast<const char*>(vDesc->Ident));
      return false;
    }
 
    const uint8_t descriptorType = vDesc->Type;
 
    // Is this a primary descriptor?
    if (descriptorType == PRIM_VOL_DESC) {
      MemoryCopy(&m_PrimaryVolDesc, buffer.data(), sizeof(Iso9660VolumeDescriptorPrimary));
      bFound = true;
    } else if (descriptorType == SUPP_VOL_DESC) {
      MemoryCopy(&m_SuppVolDesc, buffer.data(), 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");
    }
    if (descriptorType == 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[33] = {};
  MemoryCopy(volLabel, m_PrimaryVolDesc.VolIdent, 32);
  if (m_JolietLevel) {
    String volLabelString = WideToMultiByteStr(reinterpret_cast<uint8_t*>(volLabel), 16, 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 {
    size_t labelLength = 32;
    while (labelLength && volLabel[labelLength - 1] == ' ')
      --labelLength;
    volLabel[labelLength] = 0;
    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);
  }
 
  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;
}
 
const String& Iso9660Filesystem::getVolumeLabel() const {
  return m_VolumeLabel;
}
 
bool Iso9660Filesystem::readSector(uint64_t location, void* destination) {
  if (!m_pDisk || !destination) {
    return false;
  }
 
  BufferView storage[IsoSectorViewCapacity];
  BufferViewSequence views(storage, IsoSectorViewCapacity);
  if (!m_pDisk->readViews(location, IsoSectorSize, views)) {
    return false;
  }
 
  const bool copied = views.copyTo(destination, IsoSectorSize);
  m_pDisk->unpinViews(location, views);
  return copied;
}
 
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
 
  const size_t viewLength =
      TargetInfo::getPageSize() < m_BlockSize ? TargetInfo::getPageSize() : m_BlockSize;
  const uint64_t diskLocation =
      (static_cast<uint64_t>(LITTLE_TO_HOST32(rec.ExtentLocation_LE)) * m_BlockSize) + location;
  const BufferView buffer = m_pDisk->read(diskLocation);
  if (!buffer || buffer.size() < viewLength) {
    if (buffer) {
      m_pDisk->unpin(diskLocation);
    }
    return 0;
  }
 
  return buffer.address();
}
 
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::removeNode(File*, const String&, 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;
  }
}
 
#ifndef ISO9660_STANDALONE
static bool initIso9660() {
  VFS::instance().addProbeCallback(&Iso9660Filesystem::probe);
  return true;
}
 
static void destroyIso9660() {
  if (!VFS::instance().removeProbeCallback(&Iso9660Filesystem::probe)) {
    FATAL("ISO9660 probe callback was not registered during unload");
  }
}
 
MODULE_INFO("iso9660", &initIso9660, &destroyIso9660, "vfs");
#endif