use abs path for archives

Author: andiwand

src/odr/exceptions.cpp

@@ -126,4 +126,7 @@ DecryptionFailed::DecryptionFailed()
 NotEncryptedError::NotEncryptedError()
     : std::runtime_error("not encrypted error") {}
 
+InvalidPath::InvalidPath(const std::string &message)
+    : std::runtime_error("invalid path: " + message) {}
+
 } // namespace odr

src/odr/exceptions.hpp

@@ -215,4 +215,9 @@ struct NotEncryptedError : public std::runtime_error {
   explicit NotEncryptedError();
 };
 
+/// @brief Invalid path
+struct InvalidPath : public std::runtime_error {
+  explicit InvalidPath(const std::string &message);
+};
+
 } // namespace odr

src/odr/internal/cfb/cfb_archive.cpp

@@ -34,7 +34,6 @@ std::shared_ptr<abstract::Filesystem> CfbArchive::as_filesystem() const {
 
 void CfbArchive::save(std::ostream &out) const {
   (void)out;
-
   throw UnsupportedOperation();
 }
 

src/odr/internal/common/filesystem.cpp

@@ -19,7 +19,11 @@ class SystemFileWalker final : public abstract::FileWalker {
 public:
   SystemFileWalker(Path root, const Path &path)
       : m_root{std::move(root)},
-        m_iterator{std::filesystem::recursive_directory_iterator(path)} {}
+        m_iterator{std::filesystem::recursive_directory_iterator(path)} {
+    if (path.relative()) {
+      throw InvalidPath("SystemFileWalker: path must be absolute");
+    }
+  }
 
   [[nodiscard]] std::unique_ptr<FileWalker> clone() const final {
     return std::make_unique<SystemFileWalker>(*this);
@@ -69,40 +73,77 @@ Path SystemFilesystem::to_system_path_(const Path &path) const {
 }
 
 bool SystemFilesystem::exists(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("SystemFilesystem::exists: path must be absolute");
+  }
+
   return std::filesystem::exists(to_system_path_(path));
 }
 
 bool SystemFilesystem::is_file(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("SystemFilesystem::is_file: path must be absolute");
+  }
+
   return std::filesystem::is_regular_file(to_system_path_(path));
 }
 
 bool SystemFilesystem::is_directory(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("SystemFilesystem::is_directory: path must be absolute");
+  }
+
   return std::filesystem::is_directory(to_system_path_(path));
 }
 
 std::unique_ptr<abstract::FileWalker>
 SystemFilesystem::file_walker(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("SystemFilesystem::file_walker: path must be absolute");
+  }
+
   return std::make_unique<SystemFileWalker>(m_root, to_system_path_(path));
 }
 
 std::shared_ptr<abstract::File> SystemFilesystem::open(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("SystemFilesystem::open: path must be absolute");
+  }
+
   return std::make_unique<DiskFile>(to_system_path_(path));
 }
 
 std::unique_ptr<std::ostream> SystemFilesystem::create_file(const Path &path) {
+  if (path.relative()) {
+    throw InvalidPath("SystemFilesystem::create_file: path must be absolute");
+  }
+
   return std::make_unique<std::ofstream>(
       util::file::create(to_system_path_(path).string()));
 }
 
 bool SystemFilesystem::create_directory(const Path &path) {
+  if (path.relative()) {
+    throw InvalidPath(
+        "SystemFilesystem::create_directory: path must be absolute");
+  }
+
   return std::filesystem::create_directory(to_system_path_(path));
 }
 
 bool SystemFilesystem::remove(const Path &path) {
+  if (path.relative()) {
+    throw InvalidPath("SystemFilesystem::remove: path must be absolute");
+  }
+
   return std::filesystem::remove(to_system_path_(path));
 }
 
 bool SystemFilesystem::copy(const Path &from, const Path &to) {
+  if (from.relative() || to.relative()) {
+    throw InvalidPath("SystemFilesystem::copy: paths must be absolute");
+  }
+
   std::error_code error_code;
   std::filesystem::copy(to_system_path_(from), to_system_path_(to), error_code);
   if (error_code) {
@@ -113,6 +154,10 @@ bool SystemFilesystem::copy(const Path &from, const Path &to) {
 
 std::shared_ptr<abstract::File>
 SystemFilesystem::copy(const abstract::File &from, const Path &to) {
+  if (to.relative()) {
+    throw InvalidPath("SystemFilesystem::copy: path must be absolute");
+  }
+
   auto istream = from.stream();
   auto ostream = create_file(to_system_path_(to));
 
@@ -123,10 +168,18 @@ SystemFilesystem::copy(const abstract::File &from, const Path &to) {
 
 std::shared_ptr<abstract::File>
 SystemFilesystem::copy(std::shared_ptr<abstract::File> from, const Path &to) {
+  if (to.relative()) {
+    throw InvalidPath("SystemFilesystem::copy: path must be absolute");
+  }
+
   return copy(*from, to_system_path_(to));
 }
 
 bool SystemFilesystem::move(const Path &from, const Path &to) {
+  if (from.relative() || to.relative()) {
+    throw InvalidPath("SystemFilesystem::move: paths must be absolute");
+  }
+
   std::error_code error_code;
   std::filesystem::rename(to_system_path_(from), to_system_path_(to),
                           error_code);
@@ -142,6 +195,10 @@ class VirtualFileWalker final : public abstract::FileWalker {
   VirtualFileWalker(
       const Path &root,
       const std::map<Path, std::shared_ptr<abstract::File>> &files) {
+    if (root.relative()) {
+      throw InvalidPath("VirtualFileWalker: path must be absolute");
+    }
+
     for (auto &&f : files) {
       if (f.first.ancestor_of(root)) {
         m_files[f.first] = f.second;
@@ -195,10 +252,18 @@ class VirtualFileWalker final : public abstract::FileWalker {
 } // namespace
 
 bool VirtualFilesystem::exists(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("VirtualFilesystem::exists: path must be absolute");
+  }
+
   return m_files.find(path) != std::end(m_files);
 }
 
 bool VirtualFilesystem::is_file(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("VirtualFilesystem::is_file: path must be absolute");
+  }
+
   auto file_it = m_files.find(path);
   if (file_it == std::end(m_files)) {
     return false;
@@ -207,6 +272,10 @@ bool VirtualFilesystem::is_file(const Path &path) const {
 }
 
 bool VirtualFilesystem::is_directory(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("VirtualFilesystem::is_directory: path must be absolute");
+  }
+
   auto file_it = m_files.find(path);
   if (file_it == std::end(m_files)) {
     return false;
@@ -216,11 +285,19 @@ bool VirtualFilesystem::is_directory(const Path &path) const {
 
 std::unique_ptr<abstract::FileWalker>
 VirtualFilesystem::file_walker(const Path &path) const {
-  return std::make_unique<VirtualFileWalker>(std::move(path), m_files);
+  if (path.relative()) {
+    throw InvalidPath("VirtualFilesystem::file_walker: path must be absolute");
+  }
+
+  return std::make_unique<VirtualFileWalker>(path, m_files);
 }
 
 std::shared_ptr<abstract::File>
 VirtualFilesystem::open(const Path &path) const {
+  if (path.relative()) {
+    throw InvalidPath("VirtualFilesystem::open: path must be absolute");
+  }
+
   auto file_it = m_files.find(path);
   if (file_it == std::end(m_files)) {
     return {};
@@ -234,6 +311,11 @@ VirtualFilesystem::create_file(const Path & /*path*/) {
 }
 
 bool VirtualFilesystem::create_directory(const Path &path) {
+  if (path.relative()) {
+    throw InvalidPath(
+        "VirtualFilesystem::create_directory: path must be absolute");
+  }
+
   if (exists(path)) {
     return false;
   }
@@ -242,6 +324,10 @@ bool VirtualFilesystem::create_directory(const Path &path) {
 }
 
 bool VirtualFilesystem::remove(const Path &path) {
+  if (path.relative()) {
+    throw InvalidPath("VirtualFilesystem::remove: path must be absolute");
+  }
+
   auto file_it = m_files.find(path);
   if (file_it == std::end(m_files)) {
     return false;
@@ -251,6 +337,10 @@ bool VirtualFilesystem::remove(const Path &path) {
 }
 
 bool VirtualFilesystem::copy(const Path &from, const Path &to) {
+  if (from.relative() || to.relative()) {
+    throw InvalidPath("VirtualFilesystem::copy: paths must be absolute");
+  }
+
   // TODO what about directories?
 
   auto from_it = m_files.find(from);
@@ -271,6 +361,10 @@ VirtualFilesystem::copy(const abstract::File & /*from*/, const Path & /*to*/) {
 
 std::shared_ptr<abstract::File>
 VirtualFilesystem::copy(std::shared_ptr<abstract::File> from, const Path &to) {
+  if (to.relative()) {
+    throw InvalidPath("VirtualFilesystem::copy: path must be absolute");
+  }
+
   if (exists(to)) {
     return {};
   }
@@ -279,6 +373,10 @@ VirtualFilesystem::copy(std::shared_ptr<abstract::File> from, const Path &to) {
 }
 
 bool VirtualFilesystem::move(const Path &from, const Path &to) {
+  if (from.relative() || to.relative()) {
+    throw InvalidPath("VirtualFilesystem::move: paths must be absolute");
+  }
+
   if (!copy(from, to)) {
     return false;
   }

src/odr/internal/html/filesystem.cpp

@@ -65,7 +65,7 @@ class HtmlServiceImpl : public HtmlService {
   HtmlResources write_filesystem(HtmlWriter &out) const {
     HtmlResources resources;
 
-    auto file_walker = m_filesystem.file_walker("");
+    auto file_walker = m_filesystem.file_walker("/");
 
     out.write_begin();
 

src/odr/internal/oldms/oldms_file.cpp

@@ -14,14 +14,14 @@ FileMeta parse_meta(const abstract::ReadableFilesystem &storage) {
   static const std::unordered_map<common::Path, FileType> types = {
       // MS-DOC: The "WordDocument" stream MUST be present in the file.
       // https://msdn.microsoft.com/en-us/library/dd926131(v=office.12).aspx
-      {common::Path("WordDocument"), FileType::legacy_word_document},
+      {common::Path("/WordDocument"), FileType::legacy_word_document},
       // MS-PPT: The "PowerPoint Document" stream MUST be present in the file.
       // https://msdn.microsoft.com/en-us/library/dd911009(v=office.12).aspx
-      {common::Path("PowerPoint Document"),
+      {common::Path("/PowerPoint Document"),
        FileType::legacy_powerpoint_presentation},
       // MS-XLS: The "Workbook" stream MUST be present in the file.
       // https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-ppt/1fc22d56-28f9-4818-bd45-67c2bf721ccf
-      {common::Path("Workbook"), FileType::legacy_excel_worksheets},
+      {common::Path("/Workbook"), FileType::legacy_excel_worksheets},
   };
 
   FileMeta result;

src/odr/internal/open_strategy.cpp

@@ -143,6 +143,16 @@ open_strategy::list_file_types(const std::shared_ptr<abstract::File> &file,
       ODR_VERBOSE(logger, "failed to open as pdf with poppler");
     }
 #endif
+
+    // just to be sure we don't miss any legacy ms files
+#ifdef ODR_WITH_WVWARE
+    try {
+      ODR_VERBOSE(logger, "try open as legacy ms with wvware");
+      result.push_back(WvWareLegacyMicrosoftFile(memory_file).file_type());
+    } catch (...) {
+      ODR_VERBOSE(logger, "failed to open as legacy ms with wvware");
+    }
+#endif
   } else {
     ODR_VERBOSE(logger, "anything else");
     result.push_back(file_type);
@@ -364,7 +374,7 @@ open_strategy::open_file(std::shared_ptr<abstract::File> file, FileType as,
       ODR_VERBOSE(logger, "using wvware engine");
       try {
         auto memory_file = std::make_shared<common::MemoryFile>(*file);
-        return std::make_unique<odr::internal::WvWareLegacyMicrosoftFile>(
+        return std::make_unique<WvWareLegacyMicrosoftFile>(
             std::move(memory_file));
       } catch (...) {
         ODR_VERBOSE(logger, "failed to open as legacy ms with wvware engine");

src/odr/internal/zip/zip_archive.cpp

@@ -60,10 +60,15 @@ std::shared_ptr<abstract::Filesystem> ZipArchive::as_filesystem() const {
   auto filesystem = std::make_shared<common::VirtualFilesystem>();
 
   for (const auto &e : *this) {
+    common::Path path = e.path();
+    if (path.relative()) {
+      path = common::Path("/").join(path);
+    }
+
     if (e.is_directory()) {
-      filesystem->create_directory(e.path());
+      filesystem->create_directory(path);
     } else if (e.is_file()) {
-      filesystem->copy(e.file(), e.path());
+      filesystem->copy(e.file(), path);
     }
   }