ssgx_filesystem_t.h

Go to the documentation of this file.

 
#ifndef SAFEHERON_SGX_TRUSTED_FILESTREAM_H
#define SAFEHERON_SGX_TRUSTED_FILESTREAM_H
#include <string>
 
#include "sgx_key.h"
#include "sgx_tprotected_fs.h"
 
#include "ssgx_filesystem_t_enum.h"
namespace ssgx {
namespace filesystem_t {
class FileStatus {
  public:
    FileStatus() noexcept : FileStatus(FileType::None) {
    }
 
    explicit FileStatus(FileType ft, Perms prms = Perms::Unknown) noexcept : ft_(ft), prms_(prms) {
    }
 
    FileStatus(const FileStatus&) noexcept = default;
 
    FileStatus(FileStatus&&) noexcept = default;
 
    ~FileStatus() {
    }
 
    FileStatus& operator=(const FileStatus&) noexcept = default;
 
    FileStatus& operator=(FileStatus&&) noexcept = default;
 
    FileType Type() const noexcept {
        return ft_;
    }
 
    Perms Permissions() const noexcept {
        return prms_;
    }
 
    void Type(FileType ft) noexcept {
        ft_ = ft;
    }
 
    void Permissions(Perms p) noexcept {
        prms_ = p;
    }
 
  private:
    FileType ft_; 
    Perms prms_;  
};
 
class Path {
#if defined(_LIBCPP_WIN32API)
#error "We do not support Windows."
    typedef wchar_t value_type;
    static constexpr value_type preferred_separator = L'\\';
#else
    typedef char value_type;
    static constexpr value_type preferred_separator = '/';
#endif
    typedef std::basic_string<value_type> string_type;
 
  public:
    Path() noexcept {
    }
 
    Path(const Path& p) : pn_(p.pn_) {
    }
 
    Path(Path&& p) noexcept : pn_(std::move(p.pn_)) {
    }
 
    Path(string_type&& source) : pn_(std::move(source)) {
    }
 
    ~Path() = default;
 
    Path& operator=(const Path& p) {
        pn_ = p.pn_;
        return *this;
    }
 
    Path& operator=(Path&& p) noexcept {
        pn_ = std::move(p.pn_);
        return *this;
    }
 
    Path& operator=(string_type&& source) noexcept {
        pn_ = std::move(source);
        return *this;
    }
 
    Path& assign(string_type&& source) noexcept {
        pn_ = std::move(source);
        return *this;
    }
 
    Path& operator+=(const Path& x) {
        pn_ += x.pn_;
        return *this;
    }
 
    Path& operator+=(const string_type& x) {
        pn_ += x;
        return *this;
    }
 
    Path& operator/=(const Path& p) {
        if (p.IsAbsolute()) {
            pn_ = p.pn_;
            return *this;
        }
        if (HasFilename())
            pn_ += preferred_separator;
        pn_ += p.pn_;
        return *this;
    }
 
    friend bool operator==(const Path& lhs, const Path& rhs) noexcept {
        return lhs.String() == rhs.String();
    }
 
    friend bool operator!=(const Path& lhs, const Path& rhs) noexcept {
        return lhs.String() != rhs.String();
    }
 
    friend Path operator/(const Path& lhs, const Path& rhs) {
        Path result(lhs);
        result /= rhs;
        return result;
    }
 
    bool IsAbsolute() const noexcept {
        return !pn_.empty() && pn_.front() == preferred_separator;
    }
 
    bool HasFilename() const noexcept {
        return !pn_.empty() && pn_.back() != preferred_separator;
    }
 
    bool Empty() const noexcept {
        return pn_.empty();
    }
 
    const char* c_str() const noexcept {
        return pn_.c_str();
    }
 
    std::string String() const {
        return pn_;
    }
 
    void Clear() noexcept {
        pn_.clear();
    }
 
  private:
    string_type pn_;
};
 
bool CreateDirectory(const Path& p);
 
FileStatus Status(const Path& p);
 
FileStatus SymlinkStatus(const Path& p);
 
bool Exists(const FileStatus& s) noexcept;
 
bool Exists(const Path& p);
 
bool Remove(const Path& p);
 
bool RemoveProtectedFile(const Path& file_name);
 
uintmax_t FileSize(const Path& p);
 
bool IsDirectory(const FileStatus& s) noexcept;
 
bool IsDirectory(const Path& p);
 
bool IsEmpty(const Path& p);
 
bool IsRegularFile(const FileStatus& s) noexcept;
 
bool IsRegularFile(const Path& p);
 
class FileSystemException : public std::exception {
  public:
    explicit FileSystemException(std::string err_msg) : err_msg_(std::move(err_msg)) {
    }
 
    const char* what() const noexcept override {
        return err_msg_.c_str();
    }
 
  private:
    std::string err_msg_;
};
 
class PlainFileReader {
  public:
    explicit PlainFileReader(std::string filepath) : file_path_(std::move(filepath)) {
    }
 
    std::vector<uint8_t> ReadAllBytes() const;
 
    std::string ReadAllText() const;
 
  private:
    std::string file_path_;
};
 
class PlainFileWriter {
  public:
    explicit PlainFileWriter(std::string filepath) : file_path_(std::move(filepath)) {
    }
 
    void WriteAllBytes(const std::vector<uint8_t>& data);
 
    void WriteAllText(const std::string& str);
 
  private:
    std::string file_path_;
};
 
class ProtectedFileReader {
  private:
    SGX_FILE* file_;
    const char* file_name_;
 
  public:
    ProtectedFileReader(const ProtectedFileReader&) = delete;
    ProtectedFileReader& operator=(const ProtectedFileReader&) = delete;
 
    explicit ProtectedFileReader(const char* file_name);
    ~ProtectedFileReader();
 
    size_t Read(void* buffer, size_t size) const;
 
    int64_t Tell() const;
 
    void Seek(int64_t offset, int origin) const;
 
    void Close();
};
 
class ProtectedFileWriter {
  private:
    SGX_FILE* file_;
    const char* file_name_;
 
  public:
    ProtectedFileWriter(const ProtectedFileWriter&) = delete;
    ProtectedFileWriter& operator=(const ProtectedFileWriter&) = delete;
 
    explicit ProtectedFileWriter(const char* file_name, FileMode file_mode = FileMode::CreateNew, uint16_t key_policy = SGX_KEYPOLICY_MRENCLAVE);
 
    ~ProtectedFileWriter();
 
    void Write(const void* data, size_t size) const;
 
    void Flush() const;
 
    void Close();
};
 
}; // namespace filesystem_t
}; // namespace ssgx
 
#endif // SAFEHERON_SGX_TRUSTED_FILESTREAM_H