xcksfilereader_1.cpp

Go to the documentation of this file.

/*
 * libxcks
 * Copyright (C) 2022 Julien Couot
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
//---------------------------------------------------------------------------
#include <boost/locale.hpp>
#include <cassert>
 
#include "xcksfilereader_1.hpp"
#include "libxcks/ckfactory.hpp"
#include "libxcks/xcksver.hpp"
#include "pathutil.hpp"
#include "strutil.hpp"
//---------------------------------------------------------------------------
 
using namespace std;
 
using namespace boost::locale;
 
using namespace std::filesystem;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
static bool isFileNameIsInStringSet(const StringSet& set, const string& filename)
{
  #if defined(_WIN32) || defined(_WIN64)
  bool notFound = true;
  StringSet::const_iterator it = set.cbegin();
 
  while (notFound && it != set.cend())
  {
    if (compareFileName(*it, filename) == 0)
      notFound = false;
    else
      it++;
  }
  return !notFound;
  #else
  return (find(set.cbegin(), set.cend(), filename) != set.cend());
  #endif  // defined(_WIN32) || defined(_WIN64)
}
//---------------------------------------------------------------------------
 
 
const string XCKS1FileHandler::parentDir = "..";
//---------------------------------------------------------------------------
 
 
XCKS1FileHandler::XCKS1FileHandler(XCKSReaderHandler& handler,
                                   const std::filesystem::path& baseDir) : readerHandler(handler),
                                                          baseDirectory(baseDir),
                                                          baseDirectoryDirs(getDirectories(baseDirectory)),
                                                          possibleSumsAlgosName(getAvailableAlgorithmNames(Version::V1_0_0))
{
  assert(baseDir.is_absolute());
  curBaseDirectoryDir = baseDirectoryDirs.size() - 1;
  readTags.push(XMLTags::CHECKSUMSFILE);
  tagInChecksumsFileTag = XMLTags::SEQ_BEGIN;
}
//---------------------------------------------------------------------------
 
 
XCKS1FileHandler::~XCKS1FileHandler()
{
}
//---------------------------------------------------------------------------
 
 
XCKS1FileHandler::XMLTags XCKS1FileHandler::stringToXMLTags(const string& str)
{
  if (str == "checksum")
    return XMLTags::CHECKSUM;
  else if (str == "file")
    return XMLTags::FILE;
  else if (str == "information")
    return XMLTags::INFORMATION;
  else if (str == "directory")
    return XMLTags::DIRECTORY;
  else if (str == "parentDirectory")
    return XMLTags::PARENTDIRECTORY;
  else if (str == "algorithm")
    return XMLTags::ALGORITHM;
  else if (str== "algorithms")
    return XMLTags::ALGORITHMS;
  else if (str == "localFiles")
    return XMLTags::LOCALFILES;
  else if (str == "generated")
    return XMLTags::GENERATED;
  else if (str == "checksumsFile")
    return XMLTags::CHECKSUMSFILE;
  else
    return XMLTags::BAD_TAG;
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startGeneratedElement(const XMLParserAttributes& atts) noexcept(false)
{
  if ((readTags.top() == XMLTags::CHECKSUMSFILE) && (tagInChecksumsFileTag == XMLTags::SEQ_BEGIN))
  {
    if (atts.getCount() == 3)
    {
      int byIdx = atts.getIndex("by"),
          versionIdx = atts.getIndex("version"),
          onIdx = atts.getIndex("on");
      if ((byIdx != XMLParserAttributes::Not_Found) && (versionIdx != XMLParserAttributes::Not_Found) && (onIdx != XMLParserAttributes::Not_Found))
      {
        time_t on;
        string onStr;
        atts.getValue(onIdx, onStr);
        if ((on = parseISO8601(onStr)) != Invalid_DateTime)  
        {
          tagInChecksumsFileTag = XMLTags::GENERATED;
          readTags.push(XMLTags::GENERATED);
          string by, version;
          atts.getValue(byIdx, by);
          atts.getValue(versionIdx, version);
          readerHandler.onGenerated(by, version, on);
        }
        else
        {
          throw XMLParserException(translate("The date/time of the creation of the checksums' file is invalid.").str(libxcks_domain));
        }
      }
      else
      {
        throw XMLParserException(translate("The \"generated\" tag must have \"by\", \"version\", and \"on\" attributes.").str(libxcks_domain));
      }
    }
    else
    {
      throw XMLParserException(translate("The \"generated\" tag must have \"by\", \"version\", and \"on\" attributes.").str(libxcks_domain));
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"generated\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startAlgorithmsElement(const XMLParserAttributes& atts) noexcept(false)
{
  if ((readTags.top() == XMLTags::CHECKSUMSFILE) &&
      ((tagInChecksumsFileTag == XMLTags::SEQ_BEGIN) || (tagInChecksumsFileTag == XMLTags::GENERATED)))
  {
    if (atts.getCount() == 0)
    {
      tagInChecksumsFileTag = XMLTags::ALGORITHMS;
      readTags.push(XMLTags::ALGORITHMS);
      readerHandler.onAlgorithmsStart();
    }
    else
    {
      throw XMLParserException(translate("The \"algorithms\" tag mustn't have any attribute.").str(libxcks_domain));
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"algorithms\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startAlgorithmElement(const XMLParserAttributes& atts) noexcept(false)
{
  if (readTags.top() == XMLTags::ALGORITHMS)
  {
    if (atts.getCount() == 1)
    {
      string type;
      if (atts.getValue("type", type))
      {
        if (possibleSumsAlgosName.find(type) != possibleSumsAlgosName.end())
        {
          ChecksumAlgoId ckId;
          if (ChecksumFactory::getAlgorithmId(ckId, type, true))
          {
            if (find(sumsAlgos.cbegin(), sumsAlgos.cend(), ckId) == sumsAlgos.cend())
            {
              sumsAlgos.push_back(ckId);
              readTags.push(XMLTags::ALGORITHM);
              readerHandler.onAlgorithm(ckId);
            }
            else
            {
              throw XMLParserException((format(translate("The algorithm \"{1}\" has already been declared.").str(libxcks_domain)) % type).str());
            }
          }
          else
          {
            throw XMLParserException((format(translate("This release doesn't support this checksum algorithm: {1}").str(libxcks_domain)) % type).str());
          }
        }
        else
        {
          throw XMLParserException((format(translate("Invalid checksum's algorithm name: {1}.").str(libxcks_domain)) % type).str());
        }
      }
      else
      {
        throw XMLParserException(translate("The \"algorithm\" tag must have a \"type\" attribute.").str(libxcks_domain));
      }
    }
    else
    {
      throw XMLParserException(translate("The \"algorithm\" tag has only one attribute: \"type\" (which is mandatory).").str(libxcks_domain));
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"algorithm\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startLocalFilesElement(const XMLParserAttributes& atts) noexcept(false)
{
  if ((readTags.top() == XMLTags::CHECKSUMSFILE) && (tagInChecksumsFileTag == XMLTags::ALGORITHMS))
  {
    if (atts.getCount() == 0)
    {
      namesInDirectories.emplace(StringSet());
      tagInChecksumsFileTag = XMLTags::LOCALFILES;
      readTags.push(XMLTags::LOCALFILES);
      readerHandler.onLocalFilesStart();
    }
    else
    {
      throw XMLParserException(translate("The \"localFiles\" tag mustn't have any attribute.").str(libxcks_domain));
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"localFiles\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startParentDirectoryElement(const XMLParserAttributes& atts) noexcept(false)
{
  if ((readTags.top() == XMLTags::LOCALFILES) || (readTags.top() == XMLTags::PARENTDIRECTORY))
  {
    if (atts.getCount() == 0)
    {
      StringSet& filesAndDirsInDir = namesInDirectories.top();
      if (!isFileNameIsInStringSet(filesAndDirsInDir, parentDir))
      {
        if (curBaseDirectoryDir >= 0)
        {
          filesAndDirsInDir.emplace(parentDir);
          currentRelativeDirectory.emplace_back(parentDir);  // works on Windows and Unix
          namesInDirectories.emplace(StringSet());
          namesInDirectories.top().emplace(from_u8string(baseDirectoryDirs[curBaseDirectoryDir].u8string()));
          curBaseDirectoryDir--;
          readTags.push(XMLTags::PARENTDIRECTORY);
          readerHandler.onParentDirectoryStart();
          readerHandler.onParentDirectoryStart(ensureEndsWithPathSeparator((baseDirectory / constructPath(currentRelativeDirectory)).lexically_normal()));
        }
        else
        {
          throw XMLParserException(translate("Want to go the parent directory, but we are at the root of the current volume.").str(libxcks_domain));
        }
      }
      else
      {
        throw XMLParserException(translate("There is already a parent directory element in the current directory.").str(libxcks_domain));
      }
    }
    else
    {
      throw XMLParserException(translate("The \"parentDirectory\" tag mustn't have any attribute.").str(libxcks_domain));
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"parentDirectory\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startDirectoryElement(const XMLParserAttributes& atts) noexcept(false)
{
  if ((readTags.top() == XMLTags::LOCALFILES) ||
      (readTags.top() == XMLTags::PARENTDIRECTORY) ||
      (readTags.top() == XMLTags::DIRECTORY))
  {
    if (atts.getCount() == 1)
    {
      string name;
      if (atts.getValue("name", name))
      {
        if (isFileNameValid(name))
        {
          StringSet& filesAndDirsInDir = namesInDirectories.top();
          if (!isFileNameIsInStringSet(filesAndDirsInDir, name))
          {
            filesAndDirsInDir.emplace(name);
            namesInDirectories.emplace(StringSet());
            currentRelativeDirectory.emplace_back(name);
            readTags.push(XMLTags::DIRECTORY);
            readerHandler.onDirectoryStart(name);
            readerHandler.onDirectoryStart(ensureEndsWithPathSeparator((baseDirectory / constructPath(currentRelativeDirectory)).lexically_normal()));
          }
          else
          {
            throw XMLParserException((format(translate("There is already a file or a directory with the name \"{1}\" in the current directory.").str(libxcks_domain)) % name).str());
          }
        }
        else
        {
          throw XMLParserException((format(translate("Invalid directory name: {1}.").str(libxcks_domain)) % name).str());
        }
      }
      else
      {
        throw XMLParserException(translate("The \"directory\" tag must have a \"name\" attribute.").str(libxcks_domain));
      }
    }
    else
    {
      throw XMLParserException(translate("The \"directory\" tag has only one attribute: \"name\" (which is mandatory).").str(libxcks_domain));
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"directory\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startFileElement(const XMLParserAttributes& atts) noexcept(false)
{
  if ((readTags.top() == XMLTags::LOCALFILES) ||
      (readTags.top() == XMLTags::PARENTDIRECTORY) ||
      (readTags.top() == XMLTags::DIRECTORY))
  {
    if (atts.getCount() == 1)
    {
      string name;
      if (atts.getValue("name", name))
      {
        if (isFileNameValid(name))
        {
          StringSet& filesAndDirsInDir = namesInDirectories.top();
          if (!isFileNameIsInStringSet(filesAndDirsInDir, name))
          {
            filesAndDirsInDir.emplace(name);
            fileName = name;
            tagInFileTag = XMLTags::SEQ_BEGIN;
            fileLength = Invalid_File_Size;
            lastFileModicationTime = Invalid_DateTime;
            readChecksumsValues.clear();
            algosToRead = sumsAlgos;
            readTags.push(XMLTags::FILE);
            readerHandler.onFileStart(fileName);
            readerHandler.onFileStart((baseDirectory / constructPath(currentRelativeDirectory, fileName)).lexically_normal());
          }
          else
          {
            throw XMLParserException((format(translate("There is already a file or a directory with the name \"{1}\" in the current directory.").str(libxcks_domain)) % name).str());
          }
        }
        else
        {
          throw XMLParserException((format(translate("Invalid file name: {1}.").str(libxcks_domain)) % name).str());
        }
      }
      else
      {
        throw XMLParserException(translate("The \"file\" tag must have a \"name\" attribute.").str(libxcks_domain));
      }
    }
    else
    {
      throw XMLParserException(translate("The \"file\" tag has only one attribute: \"name\" (which is mandatory).").str(libxcks_domain));
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"file\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startInformationElement(const XMLParserAttributes& atts) noexcept(false)
{
  if ((readTags.top() == XMLTags::FILE) && (tagInFileTag == XMLTags::SEQ_BEGIN))
  {
    if (atts.getCount() >= 0 && atts.getCount() <= 2)
    {
      string fileSize, fileDate;
      for (size_t i = 0; i < atts.getCount(); i++)
      {
        string attName;
        atts.getName(i, attName);
        if (attName == "size")
          atts.getValue(i, fileSize);
        else if (attName == "date")
          atts.getValue(i, fileDate);
        else
          throw XMLParserException((format(translate("Invalid attribute \"{1}\" for the \"information\" tag (valid values are \"size\" and \"date\").").str(libxcks_domain)) % attName).str());
      }
      if (!fileSize.empty())
      {
        bool ok = true;
        try
        {
          unsigned long long fs = stoull(fileSize);
          fileLength = static_cast<uintmax_t>(fs);
        }
        catch (logic_error&)
        {
          ok = false;
        }
        if (!ok)
          throw XMLParserException((format(translate("The \"size\" attribute of the \"information\" tag has an invalid value: {1}.").str(libxcks_domain)) % fileSize).str());
      }
      if (!fileDate.empty())
        if ((lastFileModicationTime = parseISO8601(fileDate)) == Invalid_DateTime)  
          throw XMLParserException((format(translate("The \"date\" attribute of the \"information\" tag has an invalid value: {1}.").str(libxcks_domain)) % fileDate).str());
 
      tagInFileTag = XMLTags::INFORMATION;
      readTags.push(XMLTags::INFORMATION);
      readerHandler.onFileInformation(fileLength, lastFileModicationTime);
    }
    else
    {
      throw XMLParserException(translate("The \"information\" tag could have none, one or two attributes.").str(libxcks_domain));
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"information\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::startChecksumElement(const XMLParserAttributes& atts) noexcept(false)
{
  if ((readTags.top() == XMLTags::FILE) &&
      ((tagInFileTag == XMLTags::SEQ_BEGIN) || (tagInFileTag == XMLTags::INFORMATION)))
  {
    if (!sumsAlgos.empty())
    {
      if (atts.getCount() == 2)
      {
        string type;
        string value;
        for (size_t i = 0; i < atts.getCount(); i++)
        {
          string attName;
          atts.getName(i, attName);
          if (attName == "type")
            atts.getValue(i, type);
          else if (attName == "value")
            atts.getValue(i, value);
          else
            throw XMLParserException((format(translate("Invalid attribute \"{1}\" for the \"checksum\" tag (valid values are \"type\" and \"value\").").str(libxcks_domain)) % attName).str());
        }
 
        if (possibleSumsAlgosName.find(type) != possibleSumsAlgosName.end())
        {
          ChecksumAlgoId ckId;
          if (ChecksumFactory::getAlgorithmId(ckId, type, true))
          {
            if (!hasChecksumValueWithAlgoId(readChecksumsValues, ckId))
            {
              ArrayChecksumAlgoId::const_iterator itCkId;
              if ((itCkId = find(algosToRead.cbegin(), algosToRead.cend(), ckId)) != algosToRead.cend())
              {
                ChecksumValue ckv(value, ckId);
                ChecksumValue c = ChecksumFactory::getNullValue(ckId);
                if (ckv.getSize() == c.getSize())
                {
                  readChecksumsValues.emplace_back(ckv);
                  algosToRead.erase(itCkId);
                  readTags.push(XMLTags::CHECKSUM);
                  readerHandler.onFileChecksum(ckv);
                }
                else
                {
                  throw XMLParserException((format(translate("The value \"{1}\" of the checksum algorithm \"{2}\" is invalid.").str(libxcks_domain)) % value % type).str());
                }
              }
              else
              {
                throw XMLParserException((format(translate("The algorithm \"{1}\" isn't present in the algorithms of the checksums' file.").str(libxcks_domain)) % type).str());
              }
            }
            else
            {
              throw XMLParserException((format(translate("The algorithm \"{1}\" has been already read once for the file \"{2}\".").str(libxcks_domain)) % type % fileName).str());
            }
          }
          else
          {
            throw XMLParserException((format(translate("This release doesn't support this checksum algorithm: {1}").str(libxcks_domain)) % type).str());
          }
        }
        else
        {
          throw XMLParserException((format(translate("Invalid checksum's algorithm name: {1}.").str(libxcks_domain)) % type).str());
        }
      }
      else
      {
        throw XMLParserException(translate("The \"algorithm\" tag has only one attribute: \"type\" (which is mandatory).").str(libxcks_domain));
      }
    }
    else
    {
      throw XMLParserException((format(translate("The file \"{1}\" has already all its checkums.").str(libxcks_domain)) % fileName).str());
    }
  }
  else
  {
    throw XMLParserException(translate("Unexpected \"checksum\" tag.").str(libxcks_domain));
  }
}
//---------------------------------------------------------------------------
 
 
void XCKS1FileHandler::startElement(const string& name, const XMLParserAttributes& atts) noexcept(false)
{
  XMLTags curTag = stringToXMLTags(name);
  switch (curTag)
  {
    case XMLTags::GENERATED :
      startGeneratedElement(atts);
      break;
 
    case XMLTags::ALGORITHMS :
      startAlgorithmsElement(atts);
      break;
 
    case XMLTags::ALGORITHM :
      startAlgorithmElement(atts);
      break;
 
    case XMLTags::LOCALFILES :
      startLocalFilesElement(atts);
      break;
 
    case XMLTags::PARENTDIRECTORY :
      startParentDirectoryElement(atts);
      break;
 
    case XMLTags::DIRECTORY :
      startDirectoryElement(atts);
      break;
 
    case XMLTags::FILE :
      startFileElement(atts);
      break;
 
    case XMLTags::INFORMATION :
      startInformationElement(atts);
      break;
 
    case XMLTags::CHECKSUM :
      startChecksumElement(atts);
      break;
 
    default :
      throw XMLParserException((format(translate("Unexpected tag (\"{1}\").").str(libxcks_domain)) % name).str());
  }
}
//---------------------------------------------------------------------------
 
 
inline void XCKS1FileHandler::endFileElement() noexcept(false)
{
  // Checks the number of read checksums for the file
  if (!algosToRead.empty())
  {
    string algoName;
    ChecksumFactory::getAlgorithmName(algoName, algosToRead[0]);
    throw XMLParserException((format(translate("Missing checksum for \"{1}\" algorithm.").str(libxcks_domain)) % algoName).str());
  }
 
  readerHandler.onFileEnd();
  readerHandler.onFile((baseDirectory / constructPath(currentRelativeDirectory, fileName)).lexically_normal(),
                       readChecksumsValues, fileLength, lastFileModicationTime);
 
  fileName.clear();
  /*tagInFileTag = XMLTags::SEQ_BEGIN;
  fileLength = Invalid_File_Size;
  lastFileModicationTime = Invalid_DateTime;*/
  readChecksumsValues.clear();
  algosToRead.clear();
}
//---------------------------------------------------------------------------
 
 
void XCKS1FileHandler::endElement(const string& name) noexcept(false)
{
  XMLTags curTag = stringToXMLTags(name);
  if (curTag != readTags.top())
    throw XMLParserException((format(translate("Mismatching tag: \"{1}\".").str(libxcks_domain)) % name).str());
  else
  {
    switch (curTag)
    {
      case XMLTags::GENERATED :
        // Nothing to do
        break;
 
      case XMLTags::ALGORITHMS :
        readerHandler.onAlgorithmsEnd();
        if (sumsAlgos.empty())
          throw XMLParserException(translate("The checksums' file must specify at least one algorithm.").str(libxcks_domain));
        else
        {
          readerHandler.onAlgorithms(sumsAlgos);
        }
        break;
 
      case XMLTags::ALGORITHM :
        // Nothing to do
        break;
 
      case XMLTags::LOCALFILES :
        if (namesInDirectories.size() != 1)
        {
          throw XMLParserException((format("There should be only one list of filenames to pop, but there is {1}. This shouldn't happen.") % namesInDirectories.size()).str());
        }
        else
        {
          namesInDirectories.pop();
          readerHandler.onLocalFilesEnd();
        }
        break;
 
      case XMLTags::PARENTDIRECTORY :
        curBaseDirectoryDir++;
        if (curBaseDirectoryDir >= static_cast<ssize_t>(baseDirectoryDirs.size()))
        {
          throw XMLParserException("Pointer to current directory of new checksums' file is out of bounds. This shouldn't happen.");
        }
        readerHandler.onParentDirectoryEnd();
        // no break here
      case XMLTags::DIRECTORY :
        if (namesInDirectories.empty())
        {
          throw XMLParserException("There is no list of filenames to pop. This shouldn't happen.");
        }
        else
        {
          if (namesInDirectories.top().empty())
          {
            throw XMLParserException(translate("The directory is empty, it's forbidden by the XCKS file's specification.").str(libxcks_domain));
          }
          else
          {
            namesInDirectories.pop();
          }
        }
        if (currentRelativeDirectory.empty())
        {
          throw XMLParserException("There is no directory to pop in the directories' list. This shouldn't happen.");
        }
        else
        {
          currentRelativeDirectory.pop_back();
        }
        if (curTag == XMLTags::DIRECTORY)  // case shared with XMLTags::PARENTDIRECTORY
          readerHandler.onDirectoryEnd();
        break;
 
      case XMLTags::FILE :
        endFileElement();
        break;
 
      case XMLTags::INFORMATION :
        // Nothing to do
        break;
 
      case XMLTags::CHECKSUM :
        // Nothing to do
        break;
 
      default :
        throw XMLParserException((format(translate("Mismatching tag: \"{1}\".").str(libxcks_domain)) % name).str());
    }
 
    readTags.pop();
  }
}
//---------------------------------------------------------------------------
 
 
void XCKS1FileHandler::characters(const string& chars) noexcept(false)
{
  string s = trim_copy(chars);
  if (!s.empty())
    throw XMLParserException(translate("The file cannot contains characters between tags.").str(libxcks_domain));
}
//---------------------------------------------------------------------------
 
 
void XCKS1FileHandler::fatalError(XML_Error errorCode, const string& errorMessage, int line, int column) noexcept
{
  readerHandler.onFatalError(errorMessage, line, column);
}
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------