acl.h

Go to the documentation of this file.

#ifndef __acl_h__
#define __acl_h__
 
#include <vector>
#include "enumAsBitmask.h"
 
namespace acl {
    class list {
      public:
        class entryType {
          public:
            union {
                id_t        e_id;
                char *      e_who;
            };
            enum class typeValue : bool {
                access_allowed_ace_type = false,
                access_denied_ace_type  = true
            } _type;
            void setType(bool aIsAllowedType) {
                _type = aIsAllowedType ? typeValue::access_allowed_ace_type : typeValue::access_denied_ace_type;
            }
            bool isAllowedType() const {
                return _type == typeValue::access_allowed_ace_type;
            }
            bool isDeniedType() const {
                return _type == typeValue::access_denied_ace_type;
            }
            enum class flagsType : unsigned short {
                file_inherit_ace =  0x0001,
                directory_inherit_ace   =   0x0002,
                no_propagate_inherit_ace =  0x0004,
                inherit_only_ace    =   0x0008,
                identifier_group    =   0x0040,
                inherited_ace       =   0x0080,
                unmapped_who    =       0x2000,
                special_who =       0x4000,
                valid_flags = file_inherit_ace | directory_inherit_ace | no_propagate_inherit_ace | inherit_only_ace | identifier_group | inherited_ace | unmapped_who | special_who,
                inheritance_flags = file_inherit_ace | directory_inherit_ace | no_propagate_inherit_ace | inherit_only_ace | inherited_ace
            };
            enumAsBitmask<flagsType> _flags;
            void setFlags(unsigned short aFlags) {
                _flags = static_cast<flagsType>(aFlags);
            }
            void addFlags(flagsType aFlags) {
                _flags |= aFlags;
            }
            bool isFlagSet(flagsType aFlag) const {
                return _flags & aFlag;
            }
            typename std::underlying_type<decltype(_flags)::enumType>::type getFlagBits() const {
                return _flags.asBits();
            }
 
 
            enum class maskType : unsigned int {
                read_data        = 0x00000001,
                list_directory       = 0x00000001,
                write_data       = 0x00000002,
                add_file         = 0x00000002,
                append_data      = 0x00000004,
                add_subdirectory     = 0x00000004,
                read_named_attrs     = 0x00000008,
                write_named_attrs    = 0x00000010,
                execute          = 0x00000020,
                delete_child         = 0x00000040,
                read_attributes      = 0x00000080,
                write_attributes     = 0x00000100,
                write_retention      = 0x00000200,
                write_retention_hold     = 0x00000400,
                delete_          = 0x00010000,
                read_acl         = 0x00020000,
                write_acl        = 0x00040000,
                write_owner      = 0x00080000,
                synchronize      = 0x00100000,
                valid_flags = read_data | list_directory | write_data | add_file | append_data | add_subdirectory | read_named_attrs | write_named_attrs | execute | delete_child | read_attributes | write_attributes | write_retention | write_retention_hold | delete_ | read_acl | write_acl | write_owner | synchronize
            };
            enumAsBitmask<maskType> _mask;
            void setMask(unsigned int aMask) {
                _mask = static_cast<maskType>(aMask);
            }
            typename std::underlying_type<decltype(_mask)::enumType>::type getMaskBits() const {
                return _mask.asBits();
            }
 
            static std::vector<std::pair<list::entryType::maskType, char>> aclMaskBits;
 
            enum specialIdType : unsigned char {
                owner_special_id =      0,
                group_special_id =      1,
                everyone_special_id =   2
            };
        };
        enum class flagsType : unsigned char {
            auto_inherit = 0x01,
            protected_ =  0x02,
            defaulted = 0x04,
            write_through = 0x40,
            masked = 0x80,
            valid_flags = auto_inherit | protected_ | defaulted | write_through | masked
        };
      protected:
        enumAsBitmask<flagsType>    flags;
        unsigned int    a_owner_mask;
        unsigned int    a_group_mask;
        unsigned int    a_other_mask;
      public:
        std::vector<entryType> entries;
 
        list();
        ~list();
    };
} // end namespace scl
#endif