authorization_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <sysio/chain/types.hpp>
#include <sysio/chain/permission_object.hpp>
#include <sysio/chain/snapshot.hpp>
 
#include <utility>
#include <functional>
 
namespace sysio { namespace chain {
 
   class controller;
   struct updateauth;
   struct deleteauth;
   struct linkauth;
   struct unlinkauth;
   struct canceldelay;
 
   class authorization_manager {
      public:
         using permission_id_type = permission_object::id_type;
 
         explicit authorization_manager(controller& c, chainbase::database& d);
 
         void add_indices();
         void initialize_database();
         void add_to_snapshot( const snapshot_writer_ptr& snapshot ) const;
         void read_from_snapshot( const snapshot_reader_ptr& snapshot );
 
         const permission_object& create_permission( account_name account,
                                                     permission_name name,
                                                     permission_id_type parent,
                                                     const authority& auth,
                                                     time_point initial_creation_time = time_point()
                                                   );
 
         const permission_object& create_permission( account_name account,
                                                     permission_name name,
                                                     permission_id_type parent,
                                                     authority&& auth,
                                                     time_point initial_creation_time = time_point()
                                                   );
 
         void modify_permission( const permission_object& permission, const authority& auth );
 
         void remove_permission( const permission_object& permission );
 
         void update_permission_usage( const permission_object& permission );
 
         fc::time_point get_permission_last_used( const permission_object& permission )const;
 
         const permission_object*  find_permission( const permission_level& level )const;
         const permission_object&  get_permission( const permission_level& level )const;
 
         std::optional<permission_name> lookup_minimum_permission( account_name authorizer_account,
                                                                   scope_name code_account,
                                                                   action_name type
                                                                 )const;
 
         void
         check_authorization( const vector<action>&                actions,
                              const flat_set<public_key_type>&     provided_keys,
                              const flat_set<permission_level>&    provided_permissions = flat_set<permission_level>(),
                              fc::microseconds                     provided_delay = fc::microseconds(0),
                              const std::function<void()>&         checktime = std::function<void()>(),
                              bool                                 allow_unused_keys = false,
                              bool                                 check_but_dont_fail = false,
                              const flat_set<permission_level>&    satisfied_authorizations = flat_set<permission_level>()
                            )const;
 
 
         void
         check_authorization( account_name                         account,
                              permission_name                      permission,
                              const flat_set<public_key_type>&     provided_keys,
                              const flat_set<permission_level>&    provided_permissions = flat_set<permission_level>(),
                              fc::microseconds                     provided_delay = fc::microseconds(0),
                              const std::function<void()>&         checktime = std::function<void()>(),
                              bool                                 allow_unused_keys = false
                            )const;
 
         flat_set<public_key_type> get_required_keys( const transaction& trx,
                                                      const flat_set<public_key_type>& candidate_keys,
                                                      fc::microseconds provided_delay = fc::microseconds(0)
                                                    )const;
 
 
         static std::function<void()> _noop_checktime;
 
      private:
         const controller&    _control;
         chainbase::database& _db;
 
         void             check_updateauth_authorization( const updateauth& update, const vector<permission_level>& auths )const;
         void             check_deleteauth_authorization( const deleteauth& del, const vector<permission_level>& auths )const;
         void             check_linkauth_authorization( const linkauth& link, const vector<permission_level>& auths )const;
         void             check_unlinkauth_authorization( const unlinkauth& unlink, const vector<permission_level>& auths )const;
         fc::microseconds check_canceldelay_authorization( const canceldelay& cancel, const vector<permission_level>& auths )const;
 
         std::optional<permission_name> lookup_linked_permission( account_name authorizer_account,
                                                                  scope_name code_account,
                                                                  action_name type
                                                                )const;
   };
 
} }