libpermissioner/src/Tree.cpp (355a113) - permissioner · BlinkenArea

Tree.cpp

/**
 * Permissioner: set file ownerships and permissions
 * Copyright 2020: Stefan Schuermans, Aachen, Germany <stefan@schuermans.info>
 * Copyleft: GNU GENERAL PUBLIC LICENSE version 3 (see LICENSE)
 */

#include <permissioner/Tree.h>

#include <permissioner/Group.h>
#include <permissioner/Permissions.h>
#include <permissioner/User.h>
#include <permissioner/StringUtils.h>

#include <boost/filesystem.hpp>
#include <sstream>
#include <stdexcept>
#include <string>
#include <unistd.h>
#include <vector>

void Tree::parseParams(std::string const &paramStr) {
  // format of paramStr is: <user> " " <group> " " <permissions> " " <root>
  // user, group, permissions may be - for no change
  std::string userStr, groupStr, permissionsStr, rootStr;

std::string::size_type pos = 0;
  StringUtils::getNextField(paramStr, pos, userStr, "user");
  StringUtils::getNextField(paramStr, pos, groupStr, "group");
  StringUtils::getNextField(paramStr, pos, permissionsStr, "permissions");
  if (pos >= paramStr.length()) {
    std::stringstream msg;
    msg << "<root> field missing in \"" << paramStr << "\"";
    throw std::runtime_error(msg.str());
  }
  rootStr = paramStr.substr(pos);

try {
    user.parseUserName(userStr);
  } catch (std::exception const & e) {
    std::stringstream msg;
    msg << "invalid <user> field \"" << userStr << "\" in \""
        << paramStr << "\": " << e.what();
    throw std::runtime_error(msg.str());
  }

try {
    group.parseGroupName(groupStr);
  } catch (std::exception const & e) {
    std::stringstream msg;
    msg << "invalid <group> field \"" << groupStr << "\" in \""
        << paramStr << "\": " << e.what();
    throw std::runtime_error(msg.str());
  }

try {
    permissions.parseParams(permissionsStr);
  } catch (std::exception const & e) {
    std::stringstream msg;
    msg << "invalid <permissions> field \"" << permissionsStr << "\" in \""
        << paramStr << "\": " << e.what();
    throw std::runtime_error(msg.str());
  }

try {
    root = boost::filesystem::canonical(rootStr);
  } catch (std::exception const & e) {
    std::stringstream msg;
    msg << "invalid <root> field \"" << rootStr << "\" in \""
        << paramStr << "\": " << e.what();
    throw std::runtime_error(msg.str());
  }
}

User const & Tree::getUser() const {
  return user;
}

Group const & Tree::getGroup() const {
  return group;
}

Permissions const & Tree::getPermissions() const {
  return permissions;
}

boost::filesystem::path const & Tree::getRoot() const {
  return root;
}

void Tree::setPermissions(TreeMap const &exclude) const {
  setPermissionsInternal(root, exclude);
}

void Tree::setPermissionsInternal(boost::filesystem::path const &path,
                                  TreeMap const &exclude) const {
  try {
    if (boost::filesystem::is_regular_file(path)) {
      setPermissionsOne(path);
    } else if (boost::filesystem::is_directory(path)) {
      setPermissionsOne(path);
      for (boost::filesystem::directory_entry entry :
           boost::filesystem::directory_iterator(path)) {
        if (exclude.find(entry) != exclude.end()) {
          continue; // other tree -> skip here
        }
        setPermissionsInternal(entry, exclude); // recurse
      }
    }
  } catch (boost::filesystem::filesystem_error const & e) {
    // ignore filesystem errors for now, as this runs in a daemon in background
    (void)e;
  }
}

void Tree::setPermissionsOne(boost::filesystem::path const &path) const {
  // change permissions
  try {
    permissions.apply(path);
  } catch (boost::filesystem::filesystem_error const & e) {
    // ignore filesystem errors for now, as this runs in a daemon in background
    (void)e;
  }

// change owner/group
  lchown(path.string().c_str(), user.getUid(), group.getGid());
  // ignore error for now, as this runs in a daemon in background
}

permissioner

add copyright & license