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_