[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/vos/acl.hh

Go to the documentation of this file.

#ifndef _ACL_HH_
#define _ACL_HH_

#include <vos/vos/iterator.hh>

namespace VOS {
    class Identity;
    class Group;
    class VobjectIterator;

    /** @class AccessControlList acl.hh vos/vos/acl.hh
        @ingroup libvos

        Class for managing an Access Control List (ACL).  The access
        control list is a mapping from a specific set of policies to a
        specific set of identities and groups to which these policies
        should be applied.
    */
    class VOS_API AccessControlList : public VUtil::RefCounted
    {
    private:
        mutable boost::mutex acl_mutex;

        mutable std::set<Identity*> identity_members;
        mutable std::set<Group*> group_members;
        std::map<std::string, std::string> policies; // domain:policy

    public:
        /** Constructor @param policy a comma-separated list of
            policies in the form "domain:policy" that identify this
            ACL
        */
        AccessControlList(const std::string& policy);

        /** Takes a comma-separated list of policies in the form
            "domain:policy" and sorts them, producing the "canonical"
            string representation.
         */
        static std::string canonicalizeName(const std::string& policy);

        /** @return a comma-separated list of policies in the form
            "domain:policy" that identify this ACL
        */
        std::string getPolicyName() const;

        /** @return the Vobjects the make up this list, of type either Identity or
            Group, use meta_cast
        */
        VobjectIterator getMembers() const;

        /** Return the policy for a specific domain. */
        std::string getPolicy(const std::string& domain);

        /** Add an identity to the list. */
        void add(Identity*);

        /** Add a group to the list. */
        void add(Group*);

        /** Remove an identity from the list. */
        void remove(Identity*);

        /** Remove a group from the list. */
        void remove(Group*);

        /** @return true if this identity appears in this list */
        bool hasIdentity(Identity*) const;

        /** @return true if this group appears in this list */
        bool hasGroup(Group*) const;

        /** @return true if this identity is a member of a group that
           is in this list */
        bool hasGroupWith(Identity* id) const;

        static std::string mapToString(const std::map<std::string, std::string>& policies);
        static void stringToMap(const std::string& aclname, std::map<std::string, std::string>& policies);
    };
}

namespace VUtil {
    template<> inline void iteratorReleaseItem(VOS::AccessControlList** v)
    {
        (*v)->release();
    }
}

namespace VOS {
    /** @class ACLIterator acl.hh vos/vos/acl.hh
        @ingroup libvos
    */
    class VOS_API ACLIterator : public VUtil::Iterator<AccessControlList*>
    {
    public:
        ACLIterator() : VUtil::Iterator<AccessControlList*>() { }
        ACLIterator(const ACLIterator& i) : VUtil::Iterator<AccessControlList*>(i) { }
        ACLIterator(const std::map<std::string, AccessControlList*>& aclset) {
            items->resize(aclset.size());
            int c = 0;
            for(std::map<std::string, AccessControlList*>::const_iterator i = aclset.begin();
                i != aclset.end();
                i++)
            {
                (*items)[c] = (*i).second;
                                (*items)[c]->acquire();
                c++;
            }
        }
        ACLIterator(const std::vector<AccessControlList*>& aclset) {
            items->resize(aclset.size());
            for(unsigned int i = 0; i < aclset.size(); i++) {
                (*items)[i] = aclset[i];
                                (*items)[i]->acquire();
            }
        }

                VUtil::vRef<AccessControlList> operator*() {
                    if(pos < items->size())
                        return VUtil::vRef<AccessControlList>((*items)[pos], true);
            else return VUtil::vRef<AccessControlList>();
        }
    };
};

#endif