unshare.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <map>
#include <cstring>
#include <set>
#include <ranges>
 
#include "reserved.hpp"
#include "../std/enum.hpp"
#include "../std/expected.hpp"

namespace ns_reserved::ns_unshare
{
 
namespace
{
 
namespace fs = std::filesystem;
 
}
 
// Unshare bits (stored as uint16_t, 2 bytes)
using Bits = uint16_t;
 
// Unshare options as fields
ENUM(Unshare,ALL,USER,IPC,PID,NET,UTS,CGROUP);
 
// Corresponding bit position index
inline std::map<Unshare,Bits> const unshare_mask =
{
  {Unshare::USER, Bits{1} << 0},
  {Unshare::IPC, Bits{1} << 1},
  {Unshare::PID, Bits{1} << 2},
  {Unshare::NET, Bits{1} << 3},
  {Unshare::UTS, Bits{1} << 4},
  {Unshare::CGROUP, Bits{1} << 5},
};

[[nodiscard]] inline Value<void> bit_set(Bits& bits, Unshare const& unshare, bool value) noexcept
{
  auto it = unshare_mask.find(unshare);
  return_if(it == unshare_mask.end(), Error("E::Unshare option '{}' not found", unshare));
  Bits mask = it->second;
  if (value) { bits |= mask;  }
  else       { bits &= ~mask; }
  return {};
}

[[nodiscard]] inline std::set<std::string> to_strings(Bits const& bits) noexcept
{
  std::set<std::string> out;
  for(auto&& [unshare,mask] : unshare_mask)
  {
    if(bits & mask)
    {
      std::string str = unshare;
      std::ranges::transform(str, str.begin(), ::tolower);
      out.insert(str);
    }
  }
  return out;
}

inline Value<void> write(fs::path const& path_file_binary, Bits const& bits) noexcept
{
  static_assert(sizeof(Bits) == sizeof(uint16_t), "Bits size must be 2 bytes");
  uint64_t offset_begin = ns_reserved::FIM_RESERVED_OFFSET_UNSHARE_BEGIN;
  uint64_t offset_end = ns_reserved::FIM_RESERVED_OFFSET_UNSHARE_END;
  return ns_reserved::write(path_file_binary, offset_begin, offset_end, reinterpret_cast<char const*>(&bits), sizeof(bits));
}

inline Value<Bits> read(fs::path const& path_file_binary) noexcept
{
  static_assert(sizeof(Bits) == sizeof(uint16_t), "Bits size must be 2 bytes");
  uint64_t offset_begin = ns_reserved::FIM_RESERVED_OFFSET_UNSHARE_BEGIN;
  uint64_t size = ns_reserved::FIM_RESERVED_OFFSET_UNSHARE_END - offset_begin;
  constexpr size_t const size_bits = sizeof(Bits);
  return_if(size_bits != size, Error("E::Trying to read an exceeding number of bytes: {} vs {}", size_bits, size));
  Bits bits;
  Pop(ns_reserved::read(path_file_binary, offset_begin, reinterpret_cast<char*>(&bits), size_bits));
  return bits;
}

class Unshares
{
  private:
    fs::path m_path_file_binary;
 
    Value<void> set_unshares(Bits bits, std::set<Unshare> const& unshares, bool value)
    {
      if(unshares.contains(Unshare::NONE))
      {
        return Error("E::Invalid unshare option 'NONE'");
      }
      if(unshares.contains(Unshare::ALL))
      {
        return_if(unshares.size() > 1, Error("E::Unshare option 'all' should not be used with others"));
        return this->set_all(true);
      }
      for(Unshare const& unshare : unshares)
      {
        Pop(bit_set(bits, unshare, value));
      };
      Pop(write(m_path_file_binary, bits));
      return {};
    }
  public:
    Unshares(fs::path const& path_file_binary)
      : m_path_file_binary(path_file_binary)
    {}

    [[nodiscard]] inline Value<void> set_all(bool value)
    {
      auto unshares = unshare_mask
        | std::views::transform([](auto&& e){ return e.first; })
        | std::views::filter([](auto&& e){ return e != Unshare::ALL; })
        | std::ranges::to<std::set<Unshare>>();
      return set_unshares(Bits{}, unshares, value);
    }

    [[nodiscard]] inline Value<void> set(std::set<Unshare> const& unshares)
    {
      return set_unshares(Bits{}, unshares, true);
    }

    [[nodiscard]] inline Value<void> add(std::set<Unshare> const& unshares)
    {
      return set_unshares(Pop(read(m_path_file_binary)), unshares, true);
    }

    [[nodiscard]] inline Value<void> del(std::set<Unshare> const& unshares)
    {
      return set_unshares(Pop(read(m_path_file_binary)), unshares, false);
    }

    [[nodiscard]] inline bool contains(Unshare const& unshare) const noexcept
    {
      return_if(unshare == Unshare::NONE or unshare == Unshare::ALL, false);
      Bits bits = read(m_path_file_binary).value_or(0);
      auto it = unshare_mask.find(unshare);
      return_if(it == unshare_mask.end(), false);
      return (bits & it->second) != 0;
    }

    [[nodiscard]] inline Value<void> clear() noexcept
    {
      return write(m_path_file_binary, Bits{});
    }

    [[nodiscard]] inline Value<std::set<std::string>> to_strings() const noexcept
    {
      return ::ns_reserved::ns_unshare::to_strings(Pop(read(m_path_file_binary)));
    }
};
 
} // namespace ns_reserved::ns_unshare
 
/* vim: set expandtab fdm=marker ts=2 sw=2 tw=100 et :*/