tools::private_file Class Reference

A file restricted to process owner AND process. Deletes file on destruction. More...

#include <util.h>

Public Member Functions
	private_file () noexcept
	handle() == nullptr && filename.empty().
	private_file (private_file &&)=default
private_file &	operator= (private_file &&)=default
	~private_file () noexcept
	Deletes filename() and closes handle().
std::FILE *	handle () const noexcept
const std::string &	filename () const noexcept

Static Public Member Functions
static private_file	create (std::string filename)

Detailed Description

A file restricted to process owner AND process. Deletes file on destruction.

Definition at line 71 of file util.h.

Constructor & Destructor Documentation

private_file() [1/2]

tools::private_file::private_file ( )

noexcept

handle() == nullptr && filename.empty().

Definition at line 120 of file util.cpp.

: m_handle(), m_filename() {}

private_file() [2/2]

tools::private_file::private_file ( private_file && )

default

~private_file()

tools::private_file::~private_file ( )

noexcept

Deletes filename() and closes handle().

Definition at line 228 of file util.cpp.

  {
    try
    {
      boost::system::error_code ec{};
      boost::filesystem::remove(filename(), ec);
    }
    catch (...) {}
  }

Here is the call graph for this function:

Member Function Documentation

create()

private_file tools::private_file::create ( std::string filename )

static

Returns

File only readable by owner and only used by this process OR private_file{} on error.

Definition at line 125 of file util.cpp.

  {
#ifdef WIN32
    struct close_handle
    {
      void operator()(HANDLE handle) const noexcept
      {
        CloseHandle(handle);
      }
    };
 
    std::unique_ptr<void, close_handle> process = nullptr;
    {
      HANDLE temp{};
      const bool fail = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, std::addressof(temp)) == 0;
      process.reset(temp);
      if (fail)
        return {};
    }
 
    DWORD sid_size = 0;
    GetTokenInformation(process.get(), TokenOwner, nullptr, 0, std::addressof(sid_size));
    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
      return {};
 
    std::unique_ptr<char[]> sid{new char[sid_size]};
    if (!GetTokenInformation(process.get(), TokenOwner, sid.get(), sid_size, std::addressof(sid_size)))
      return {};
 
    const PSID psid = reinterpret_cast<const PTOKEN_OWNER>(sid.get())->Owner;
    const DWORD daclSize =
      sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(psid) - sizeof(DWORD);
 
    const std::unique_ptr<char[]> dacl{new char[daclSize]};
    if (!InitializeAcl(reinterpret_cast<PACL>(dacl.get()), daclSize, ACL_REVISION))
      return {};
 
    if (!AddAccessAllowedAce(reinterpret_cast<PACL>(dacl.get()), ACL_REVISION, (READ_CONTROL | FILE_GENERIC_READ | DELETE), psid))
      return {};
 
    SECURITY_DESCRIPTOR descriptor{};
    if (!InitializeSecurityDescriptor(std::addressof(descriptor), SECURITY_DESCRIPTOR_REVISION))
      return {};
 
    if (!SetSecurityDescriptorDacl(std::addressof(descriptor), true, reinterpret_cast<PACL>(dacl.get()), false))
      return {};
 
    SECURITY_ATTRIBUTES attributes{sizeof(SECURITY_ATTRIBUTES), std::addressof(descriptor), false};
    std::unique_ptr<void, close_handle> file{
      CreateFile(
        name.c_str(),
        GENERIC_WRITE, FILE_SHARE_READ,
        std::addressof(attributes),
        CREATE_NEW, (FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE),
        nullptr
      )
    };
    if (file)
    {
      const int fd = _open_osfhandle(reinterpret_cast<intptr_t>(file.get()), 0);
      if (0 <= fd)
      {
        file.release();
        std::FILE* real_file = _fdopen(fd, "w");
        if (!real_file)
        {
          _close(fd);
        }
        return {real_file, std::move(name)};
      }
    }
#else
    const int fdr = open(name.c_str(), (O_RDONLY | O_CREAT), S_IRUSR);
    if (0 <= fdr)
    {
      struct stat rstats = {};
      if (fstat(fdr, std::addressof(rstats)) != 0)
      {
        close(fdr);
        return {};
      }
      fchmod(fdr, (S_IRUSR | S_IWUSR));
      const int fdw = open(name.c_str(), O_RDWR);
      fchmod(fdr, rstats.st_mode);
      close(fdr);
 
      if (0 <= fdw)
      {
        struct stat wstats = {};
        if (fstat(fdw, std::addressof(wstats)) == 0 &&
            rstats.st_dev == wstats.st_dev && rstats.st_ino == wstats.st_ino &&
            flock_exnb(fdw) == 0 && ftruncate(fdw, 0) == 0)
        {
          std::FILE* file = fdopen(fdw, "w");
          if (file) return {file, std::move(name)};
        }
        close(fdw);
      }
    }
#endif
    return {};
  }

Here is the call graph for this function:

Here is the caller graph for this function:

filename()

const std::string & tools::private_file::filename ( ) const

inlinenoexcept

Definition at line 92 of file util.h.

{ return m_filename; }

Here is the caller graph for this function:

handle()

std::FILE * tools::private_file::handle ( ) const

inlinenoexcept

Definition at line 91 of file util.h.

{ return m_handle.get(); }

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

private_file & tools::private_file::operator= ( private_file && )

default

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/common/util.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/common/util.cpp