Acl.h

Go to the documentation of this file.

/* Copyright 2013-2019 Homegear GmbH
 *
 * libhomegear-base is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * libhomegear-base is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with libhomegear-base.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * In addition, as a special exception, the copyright holders give
 * permission to link the code of portions of this program with the
 * OpenSSL library under certain conditions as described in each
 * individual source file, and distribute linked combinations
 * including the two.
 * You must obey the GNU Lesser General Public License in all respects
 * for all of the code used other than OpenSSL.  If you modify
 * file(s) with this exception, you may extend this exception to your
 * version of the file(s), but you are not obligated to do so.  If you
 * do not wish to do so, delete this exception statement from your
 * version.  If you delete this exception statement from all source
 * files in the program, then also delete it here.
*/

#ifndef BASELIB_SECURITY_ACL_H_
#define BASELIB_SECURITY_ACL_H_

#include "../Exception.h"
#include "../Variable.h"
#include "../Database/IDatabaseController.h"

#include <set>

namespace BaseLib {

namespace Systems {
class Peer;
}

namespace Security {

enum class AclResult {
  error = -3,
  notInList = -2,
  deny = -1,
  accept = 0
};

class AclException : public Exception {
 public:
  AclException(std::string message) : Exception(message) {}
};

class Acl {
 private:
  bool _devicesReadSet = false;

  std::unordered_map<uint64_t, bool> _devicesRead;

  bool _devicesWriteSet = false;

  std::unordered_map<uint64_t, bool> _devicesWrite;

  bool _variablesReadSet = false;

  std::unordered_map<uint64_t, std::unordered_map<int32_t, std::unordered_map<std::string, bool>>> _variablesRead;

  bool _variablesWriteSet = false;

  std::unordered_map<uint64_t, std::unordered_map<int32_t, std::unordered_map<std::string, bool>>> _variablesWrite;

  bool _roomsReadSet = false;

  std::unordered_map<uint64_t, bool> _roomsRead;

  bool _roomsWriteSet = false;

  std::unordered_map<uint64_t, bool> _roomsWrite;

  bool _buildingPartsReadSet = false;

  std::unordered_map<uint64_t, bool> _buildingPartsRead;

  bool _buildingPartsWriteSet = false;

  std::unordered_map<uint64_t, bool> _buildingPartsWrite;

  bool _categoriesReadSet = false;

  std::unordered_map<uint64_t, bool> _categoriesRead;

  bool _categoriesWriteSet = false;

  std::unordered_map<uint64_t, bool> _categoriesWrite;

  bool _rolesReadSet = false;

  std::unordered_map<uint64_t, bool> _rolesRead;

  bool _rolesWriteSet = false;

  std::unordered_map<uint64_t, bool> _rolesWrite;

  bool _methodsSet = false;

  std::unordered_map<std::string, bool> _methods;

  bool _eventServerMethodsSet = false;

  std::unordered_map<std::string, bool> _eventServerMethods;

  bool _servicesSet = false;

  std::unordered_map<std::string, bool> _services;
 public:
  Acl();

  virtual ~Acl();

  bool categoriesReadSet() { return _categoriesReadSet; }
  bool categoriesWriteSet() { return _categoriesWriteSet; }
  bool rolesReadSet() { return _rolesReadSet; }
  bool rolesWriteSet() { return _rolesWriteSet; }
  bool devicesReadSet() { return _devicesReadSet; }
  bool devicesWriteSet() { return _devicesWriteSet; }
  bool roomsReadSet() { return _roomsReadSet; }
  bool roomsWriteSet() { return _roomsWriteSet; }
  bool buildingPartsReadSet() { return _buildingPartsReadSet; }
  bool buildingPartsWriteSet() { return _buildingPartsWriteSet; }
  bool variablesReadSet() { return _variablesReadSet; }
  bool variablesWriteSet() { return _variablesWriteSet; }

  PVariable toVariable();

  void fromVariable(PVariable serializedData);

  AclResult checkServiceAccess(std::string &serviceName);
  AclResult checkCategoriesReadAccess(std::set<uint64_t> &categories);
  AclResult checkCategoriesWriteAccess(std::set<uint64_t> &categories);
  AclResult checkCategoryReadAccess(uint64_t category);
  AclResult checkCategoryWriteAccess(uint64_t category);
  AclResult checkRolesReadAccess(std::set<uint64_t> &roles);
  AclResult checkRolesWriteAccess(std::set<uint64_t> &roles);
  AclResult checkRoleReadAccess(uint64_t role);
  AclResult checkRoleWriteAccess(uint64_t role);
  AclResult checkDeviceReadAccess(std::shared_ptr<Systems::Peer> peer);
  AclResult checkDeviceWriteAccess(std::shared_ptr<Systems::Peer> peer);
  AclResult checkEventServerMethodAccess(std::string &methodName);
  AclResult checkMethodAccess(std::string &methodName);
  AclResult checkMethodAndCategoryReadAccess(std::string &methodName, uint64_t categoryId);
  AclResult checkMethodAndCategoryWriteAccess(std::string &methodName, uint64_t categoryId);
  AclResult checkMethodAndRoleReadAccess(std::string &methodName, uint64_t roleId);
  AclResult checkMethodAndRoleWriteAccess(std::string &methodName, uint64_t roleId);
  AclResult checkMethodAndRoomReadAccess(std::string &methodName, uint64_t roomId);
  AclResult checkMethodAndRoomWriteAccess(std::string &methodName, uint64_t roomId);
  AclResult checkMethodAndBuildingPartReadAccess(std::string &methodName, uint64_t buildingPartId);
  AclResult checkMethodAndBuildingPartWriteAccess(std::string &methodName, uint64_t buildingPartId);
  AclResult checkMethodAndDeviceWriteAccess(std::string &methodName, uint64_t peerId);
  AclResult checkNodeBlueVariableReadAccess(const std::string &nodeId, int32_t input);
  AclResult checkNodeBlueVariableWriteAccess(const std::string &nodeId, int32_t input);
  AclResult checkRoomReadAccess(uint64_t roomId);
  AclResult checkRoomWriteAccess(uint64_t roomId);
  AclResult checkBuildingPartReadAccess(uint64_t buildingPartId);
  AclResult checkBuildingPartWriteAccess(uint64_t buildingPartId);
  AclResult checkSystemVariableReadAccess(Database::PSystemVariable systemVariable);
  AclResult checkSystemVariableWriteAccess(Database::PSystemVariable systemVariable);
  AclResult checkVariableReadAccess(std::shared_ptr<Systems::Peer> peer, int32_t channel, const std::string &variableName);
  AclResult checkVariableWriteAccess(std::shared_ptr<Systems::Peer> peer, int32_t channel, const std::string &variableName);

  std::string toString(int32_t indentation = 0);
};

typedef std::shared_ptr<Acl> PAcl;

}
}
#endif