basicio.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef BASICIO_HPP_
#define BASICIO_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "error.hpp"
#include "types.hpp"
 
// + standard includes
#include <memory>
 
// The way to handle data from stdin or data uri path. If EXV_XPATH_MEMIO = 1,
// it uses MemIo. Otherwises, it uses FileIo.
#ifndef EXV_XPATH_MEMIO
#define EXV_XPATH_MEMIO 0
#endif
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class definitions
 
class EXIV2API BasicIo {
 public:
  using UniquePtr = std::unique_ptr<BasicIo>;
 
  enum Position { beg, cur, end };
 
 
  virtual ~BasicIo() = default;
 
 
 
  virtual int open() = 0;
 
  virtual int close() = 0;
  virtual size_t write(const byte* data, size_t wcount) = 0;
  virtual size_t write(BasicIo& src) = 0;
  virtual int putb(byte data) = 0;
  virtual DataBuf read(size_t rcount) = 0;
  virtual size_t read(byte* buf, size_t rcount) = 0;
  void readOrThrow(byte* buf, size_t rcount, ErrorCode err = ErrorCode::kerCorruptedMetadata);
  virtual int getb() = 0;
  virtual void transfer(BasicIo& src) = 0;
  virtual int seek(int64_t offset, Position pos) = 0;
 
  void seekOrThrow(int64_t offset, Position pos, ErrorCode err);
 
  virtual byte* mmap(bool isWriteable = false) = 0;
  virtual int munmap() = 0;
 
 
 
 
  [[nodiscard]] virtual size_t tell() const = 0;
  [[nodiscard]] virtual size_t size() const = 0;
  [[nodiscard]] virtual bool isopen() const = 0;
  [[nodiscard]] virtual int error() const = 0;
  [[nodiscard]] virtual bool eof() const = 0;
  [[nodiscard]] virtual const std::string& path() const noexcept = 0;
 
  virtual void populateFakeData() = 0;
 
  byte* bigBlock_{};
 
};  // class BasicIo
 
class EXIV2API IoCloser {
 public:
 
  explicit IoCloser(BasicIo& bio) : bio_(bio) {
  }
  virtual ~IoCloser() {
    close();
  }
 
 
  void close() {
    if (bio_.isopen())
      bio_.close();
  }
 
  // DATA
  BasicIo& bio_;
 
  // Not implemented
  IoCloser(const IoCloser&) = delete;
  IoCloser& operator=(const IoCloser&) = delete;
};  // class IoCloser
 
#ifdef EXV_ENABLE_FILESYSTEM
class EXIV2API FileIo : public BasicIo {
 public:
 
 
  explicit FileIo(const std::string& path);
 
  ~FileIo() override;
 
 
 
  int open(const std::string& mode);
  int open() override;
  int close() override;
  size_t write(const byte* data, size_t wcount) override;
  size_t write(BasicIo& src) override;
  int putb(byte data) override;
  DataBuf read(size_t rcount) override;
  size_t read(byte* buf, size_t rcount) override;
  int getb() override;
  void transfer(BasicIo& src) override;
 
  int seek(int64_t offset, Position pos) override;
 
  byte* mmap(bool isWriteable = false) override;
  int munmap() override;
  virtual void setPath(const std::string& path);
 
 
 
  [[nodiscard]] size_t tell() const override;
  [[nodiscard]] size_t size() const override;
  [[nodiscard]] bool isopen() const override;
  [[nodiscard]] int error() const override;
  [[nodiscard]] bool eof() const override;
  [[nodiscard]] const std::string& path() const noexcept override;
 
  void populateFakeData() override;
 
  // NOT IMPLEMENTED
  FileIo(const FileIo&) = delete;
  FileIo& operator=(const FileIo&) = delete;
 
 private:
  // Pimpl idiom
  class Impl;
  std::unique_ptr<Impl> p_;
 
};  // class FileIo
#endif
 
class EXIV2API MemIo : public BasicIo {
 public:
 
  MemIo();
  MemIo(const byte* data, size_t size);
  ~MemIo() override;
 
 
 
  int open() override;
  int close() override;
  size_t write(const byte* data, size_t wcount) override;
  size_t write(BasicIo& src) override;
  int putb(byte data) override;
  DataBuf read(size_t rcount) override;
  size_t read(byte* buf, size_t rcount) override;
  int getb() override;
  void transfer(BasicIo& src) override;
 
  int seek(int64_t offset, Position pos) override;
 
  byte* mmap(bool /*isWriteable*/ = false) override;
  int munmap() override;
 
 
 
  [[nodiscard]] size_t tell() const override;
  [[nodiscard]] size_t size() const override;
  [[nodiscard]] bool isopen() const override;
  [[nodiscard]] int error() const override;
  [[nodiscard]] bool eof() const override;
  [[nodiscard]] const std::string& path() const noexcept override;
 
  void populateFakeData() override;
 
 
  // NOT IMPLEMENTED
  MemIo(const MemIo&) = delete;
  MemIo& operator=(const MemIo&) = delete;
 
 private:
  // Pimpl idiom
  class Impl;
  std::unique_ptr<Impl> p_;
 
};  // class MemIo
 
#if EXV_XPATH_MEMIO
class EXIV2API XPathIo : public MemIo {
 public:
 
  XPathIo(const std::string& path);
 private:
  void ReadStdin();
  void ReadDataUri(const std::string& path);
};  // class XPathIo
#elif defined(EXV_ENABLE_FILESYSTEM)
class EXIV2API XPathIo : public FileIo {
 public:
  static constexpr auto TEMP_FILE_EXT = ".exiv2_temp";
  static constexpr auto GEN_FILE_EXT = ".exiv2";
 
 
  explicit XPathIo(const std::string& orgPath);
 
  ~XPathIo() override;
 
  XPathIo(const XPathIo&) = delete;
  XPathIo& operator=(const XPathIo&) = delete;
 
 
 
  void transfer(BasicIo& src) override;
 
 
 
 
  static std::string writeDataToFile(const std::string& orgPath);
 
 private:
  // True if the file is a temporary file and it should be deleted in destructor.
  bool isTemp_{true};
  std::string tempFilePath_;
};  // class XPathIo
#endif
 
class EXIV2API RemoteIo : public BasicIo {
 public:
  RemoteIo();
  ~RemoteIo() override;
 
  RemoteIo(const RemoteIo&) = delete;
  RemoteIo& operator=(const RemoteIo&) = delete;
 
 
 
  int open() override;
 
  int close() override;
  size_t write(const byte* data, size_t wcount) override;
  size_t write(BasicIo& src) override;
 
  int putb(byte data) override;
  DataBuf read(size_t rcount) override;
  size_t read(byte* buf, size_t rcount) override;
  int getb() override;
  void transfer(BasicIo& src) override;
 
  int seek(int64_t offset, Position pos) override;
 
  byte* mmap(bool /*isWriteable*/ = false) override;
  int munmap() override;
 
 
  [[nodiscard]] size_t tell() const override;
  [[nodiscard]] size_t size() const override;
  [[nodiscard]] bool isopen() const override;
  [[nodiscard]] int error() const override;
  [[nodiscard]] bool eof() const override;
  [[nodiscard]] const std::string& path() const noexcept override;
 
  void populateFakeData() override;
 
 
 protected:
  // Pimpl idiom
  class Impl;
  std::unique_ptr<Impl> p_;
};  // class RemoteIo
 
class EXIV2API HttpIo : public RemoteIo {
 public:
 
 
  explicit HttpIo(const std::string& url, size_t blockSize = 1024);
 
 private:
  // Pimpl idiom
  class HttpImpl;
};
 
#ifdef EXV_USE_CURL
class EXIV2API CurlIo : public RemoteIo {
 public:
 
 
  explicit CurlIo(const std::string& url, size_t blockSize = 0);
 
  size_t write(const byte* data, size_t wcount) override;
  size_t write(BasicIo& src) override;
 
 protected:
  // Pimpl idiom
  class CurlImpl;
};
#endif
 
// *****************************************************************************
// template, inline and free functions
 
EXIV2API DataBuf readFile(const std::string& path);
EXIV2API size_t writeFile(const DataBuf& buf, const std::string& path);
#ifdef EXV_USE_CURL
EXIV2API size_t curlWriter(char* data, size_t size, size_t nmemb, std::string* writerData);
#endif
}  // namespace Exiv2
#endif  // #ifndef BASICIO_HPP_