platform/server/UserManager.hpp

// ------------------------------------------------------------------------
// Pion is a development platform for building Reactors that process Events
// ------------------------------------------------------------------------
// Copyright (C) 2007-2008 Atomic Labs, Inc.  (http://www.atomiclabs.com)
//
// Pion is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// Pion 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 Affero General Public License for
// more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with Pion.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef __PION_USERMANAGER_HEADER__
#define __PION_USERMANAGER_HEADER__

#include <string>
#include <libxml/tree.h>
#include <boost/bind.hpp>
#include <boost/signal.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/net/PionUser.hpp>
#include <pion/platform/ConfigManager.hpp>
#include "PlatformService.hpp"


namespace pion {        // begin namespace pion
namespace server {  // begin namespace server (Pion Server)


class PION_SERVER_API UserManager :
    public pion::platform::ConfigManager,
    public pion::net::PionUserManager
{
public:

    class MissingOpenSSLException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Missing OpenSSL library: User management is disabled!";
        }
    };
    
    class MissingUserIdInConfigFileException : public PionException {
    public:
        MissingUserIdInConfigFileException(const std::string& config_file)
            : PionException("Users configuration file includes a User without a unique identifier: ", config_file) {}
    };

    class EmptyUserIdException : public PionException {
    public:
        EmptyUserIdException()
            : PionException("The specified User identifier is empty.") {}
    };

    class NoPasswordException : public PionException {
    public:
        NoPasswordException(const std::string& user_id)
            : PionException("The specified User configuration has an empty or missing password.  Specified User identifier: ", user_id) {}
    };

    class DuplicateUserException : public PionException {
    public:
        DuplicateUserException(const std::string& user_id)
            : PionException("A User already exists with the specified ID: ", user_id) {}
    };

    class UserNotFoundException : public PionException {
    public:
        UserNotFoundException(const std::string& user_id)
            : PionException("No User found for identifier: ", user_id) {}
    };

    class AddUserConfigException : public PionException {
    public:
        AddUserConfigException(const std::string& config_file)
            : PionException("Unable to add a User to the configuration file: ", config_file) {}
    };
    
    class UpdateUserConfigException : public PionException {
    public:
        UpdateUserConfigException(const std::string& config_file)
            : PionException("Unable to update a User in the configuration file: ", config_file) {}
    };

    class UserUpdateFailedException : public PionException {
    public:
        UserUpdateFailedException(const std::string& user_id)
            : PionException("Unable to update User with identifier: ", user_id) {}
    };

public:

    UserManager();

    virtual ~UserManager() {}

    virtual void openConfigFile(void);

    virtual void writeConfigXML(std::ostream& out) const;

    bool writeConfigXML(std::ostream& out, const std::string& user_id) const;

    bool writePermissionsXML(std::ostream& out, const std::string& user_id) const;

    static xmlNodePtr createUserConfig(std::string& user_id, const char *buf, std::size_t len);

    std::string addUser(const std::string& user_id, xmlNodePtr config_ptr);

    void setUserConfig(const std::string& user_id, xmlNodePtr config_ptr);

    virtual bool removeUser(const std::string& user_id);

    bool creationAllowed(
        const pion::net::PionUserPtr& user_from_request, 
        const pion::platform::ConfigManager& config_manager,
        const xmlNodePtr& config_ptr) const;

    bool updateAllowed(
        const pion::net::PionUserPtr& user_from_request, 
        const pion::platform::ConfigManager& config_manager,
        const std::string& id,
        const xmlNodePtr& config_ptr) const;

    bool removalAllowed(
        const pion::net::PionUserPtr& user_from_request, 
        const pion::platform::ConfigManager& config_manager,
        const std::string& id) const;

    bool accessAllowed(
        const pion::net::PionUserPtr& user_from_request, 
        const pion::platform::ConfigManager& config_manager,
        const std::string& plugin_id) const;

    bool accessAllowed(
        const pion::net::PionUserPtr& user_from_request, 
        const PlatformService& service,
        const std::string& id = "") const;


private:

    bool updateUserManager(const std::string& user_id, xmlNodePtr config_ptr,
        bool password_encrypted, bool new_user);

    bool setUserConfig(xmlNodePtr user_node_ptr, xmlNodePtr config_ptr);

    bool isAdmin(const pion::net::PionUserPtr user_ptr) const;

    xmlNodePtr getPermissionNode(pion::net::PionUserPtr user_ptr, const std::string& permission_type) const;


private:

    static const std::string            DEFAULT_CONFIG_FILE;

    static const std::string            USER_ELEMENT_NAME;

    static const std::string            PASSWORD_ELEMENT_NAME;

    static const std::string            USER_PERMISSION_ELEMENT_NAME;

    static const std::string            PERMISSION_TYPE_ATTRIBUTE_NAME;

    static const std::string            ADMIN_PERMISSION_TYPE;

    mutable boost::mutex                m_mutex;
};

typedef boost::shared_ptr<UserManager>  UserManagerPtr;


}   // end namespace server
}   // end namespace pion

#endif //__PION_USERMANAGER_HEADER__

---