ALDObjects.h

См. документацию.

 
#ifndef ALD_OBJECTS
#define ALD_OBJECTS
 
#include "common.h"
#include "ALDCore.h"
#include "ALDCoreUtils.h"
#include "ALDLogProvider.h"
#include "ldap-wrapper.h"
#include <string>
#include <memory>
 
using namespace std;
 
namespace ALD
{
 
#define ALD_INVALID_ID    0
 
// ALD Object types
#define ALD_OT_DUMMY        "ALD_DUMMY"
#define ALD_OT_DOMAIN       "ALD_DOMAIN"
#define ALD_OT_USER         "ALD_DOMAIN_USER"
#define ALD_OT_GROUP        "ALD_DOMAIN_GROUP"
#define ALD_OT_TASK         "ALD_TASK"
#define ALD_OT_EVTASK       "ALD_EVTASK"
#define ALD_OT_POLICY       "ALD_DOMAIN_POLICY"
#define ALD_OT_SERVICE      "ALD_DOMAIN_SERVICE"
#define ALD_OT_SVCGROUP     "ALD_DOMAIN_SERVICE_GROUP"
#define ALD_OT_HOST         "ALD_HOST"
#define ALD_OT_HOSTGROUP    "ALD_HOST_GROUP"
#define ALD_OT_ADMGROUP     "ALD_DOMAIN_ADM_GROUP"
#define ALD_OT_LOG_CFG      "ALD_DOMAIN_LOG_CFG"
#define ALD_OT_TD           "ALD_TRUSTED_DOMAIN"
#define ALD_OT_DOCUMENT     "ALD_DOCUMENT"
 
// ALD save marks
#define ALD_PBK_HEAD         "<<{ ALD Portable Backup File }>>"
 
#define ALD_PBK_PREFIX       "<<{ ALDObject: "
 
#define ALD_PBK_SUFFIX       ">>}"
 
#define ALD_PBK_SIGN(type)   string(ALD_PBK_PREFIX)+type
 
// ALD save stages
#define ALD_SS_START        "ALD_SS_START"
#define ALD_SS_POLICIES     "ALD_SS_POLICIES"
#define ALD_SS_HOSTS        "ALD_SS_HOSTS"
#define ALD_SS_HOSTGROUPS   "ALD_SS_HOSTGROUPS"
#define ALD_SS_USERS        "ALD_SS_USERS"
#define ALD_SS_GROUPS       "ALD_SS_GROUPS"
#define ALD_SS_SERVICES     "ALD_SS_SERVICES"
#define ALD_SS_SVCGROUPS    "ALD_SS_SVCGROUPS"
#define ALD_SS_DOCUMENTS    "ALD_SS_DOCUMENTS"
#define ALD_SS_ADMGROUP     "ALD_SS_ADMGROUP"
#define ALD_SS_LOG_CFG      "ALD_SS_LOGCFG"
#define ALD_SS_FINISH       "ALD_SS_FINISH"
 
enum aoLoadStatus{
    aolsLoaded,     
    aolsContinue,   
    aolsError       
};
 
enum aoLoadFieldStatus{
    aolfsLoaded,    
    aolfsUnexpected,
    aolfsEnd,       
    aolfsError      
};
 
enum aoOperation{
    aooGet,     
    aooCreate,  
    aooModify,  
    aooRemove   
};
 
enum aoTriggerActionType{
    aotatAction,    
    aotatCheck      
};
 
typedef int ald_info_level;
 
#define ALD_INFO_UNCHANGED  -1
 
#define ALD_INFO_DEFAULT  0
 
#define ALD_OBJECT_ACTION(object, action) string(object)+":"+action
 
#define ALD_OBJECT_ADDED        "ADDED"
#define ALD_OBJECT_CK_REMOVAL   "CHECK_REMOVAL"
#define ALD_OBJECT_DO_REMOVING  "DO_REMOVING"
#define ALD_OBJECT_REMOVED      "REMOVED"
#define ALD_OBJECT_MODIFIED     "MODIFIED"
 
class CALDObject
{
protected:
    ald_info_level m_InfoLevel;
    string m_strName;           
    string m_strBase;           
    bool m_bValid;              
    bool m_bSystem;             
    string m_strOType;          
    IALDCore *m_pCore;          
    CALDConnectionPtr m_Conn;   
    CALDLdapEntPtr m_Entity;    
 
    // abstract !!! must be overloaded in derived classes for saving specific fields
    virtual void InternalSave(ostream &os, bool verbose = false) = 0;
 
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line,
                                      bool verbose = false);
 
    static aoLoadFieldStatus LoadField(istream &is, size_t &nline, string &line,
                                const string &field, string &value, bool fuzzy = false);
 
    static aoLoadFieldStatus LoadFields(istream &is, size_t &nline, string &line,
                                 const string &field, ald_string_list &values);
 
#define LOAD_FIELD(is, nline, line, field, value) {if(LoadField(is, nline, line, field, value) != aolfsLoaded) return aolsError;}
 
#define LOAD_FIELDS(is, nline, line, field, values) {if(LoadFields(is, nline, line, field, values) == aolfsError) return aolsError;}
 
    // abstract !!! must be overloaded in derived classes, typically fill m_Entity,
    // m_bValid must be set here if m_Entity is not used
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false) = 0;
 
    virtual bool ProcessEntity(bool quiet = false);
 
    virtual void EnsureInfoLevel(ald_info_level level);
 
    virtual void EnsureEntity();
 
    virtual void InternalRemove(bool force, void *extra = NULL);
 
    virtual void InternalCreate(void *extra = NULL);
 
    virtual void InternalUpdate(unsigned int setmask, ald_string_multimap &attrs, void *extra = NULL);
 
    // abstract !!! must be overloaded in derived classes, typically MSG_*_OBJECT is used
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail) = 0;
 
    virtual bool StartOperation(const string &object, aoOperation op, const string &arg,
                                const string &detail, bool force = false);
 
    virtual void CommitOperation(const string &object, aoOperation op, bool process = false, bool quiet = false);
 
    bool TriggerAction(const string &action, aoTriggerActionType atype, bool quiet = false);
public:
    explicit CALDObject(const string &type, CALDConnectionPtr Conn);
 
    CALDConnectionPtr conn()  const {return m_Conn;}
    CALDLdapEntPtr entity() const {return m_Entity;}
    ald_info_level infolevel() const {return m_InfoLevel;}
    string const &name() const;
    string const &base() const;
    const string &otype() const {return m_strOType;}
    bool IsValid() const {return m_bValid;}
    virtual bool IsSystemObject() {return false;}
 
    virtual void Clear();
 
    // must be overloaded if some restriction exists
    virtual bool CheckRemoval(bool quiet = false);
 
    virtual bool Refresh(ald_info_level level = ALD_INFO_UNCHANGED, bool quiet = false);
 
    virtual void Save(ostream &os, bool verbose = false);
 
    virtual void Load(istream &is, size_t &nline, bool verbose = false);
 
    virtual bool CheckConsistency(string &msg);
 
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
 
    // abstract !!! must be overloaded in derived classes, common structure:
    virtual void Remove(bool force = false) = 0;
 
    // abstract !!! must be overloaded in derived classes, common structure
    virtual bool Get(const string &oname, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false) = 0;
 
    virtual ~CALDObject();
};
 
typedef shared_ptr<CALDObject> CALDObjPtr;
 
#define ALD_SET_NAME        0x00001
#define ALD_SET_GID         0x00002
#define ALD_SET_DESC        0x00004
#define ALD_SET_MEMBERS     0x00008
#define ALD_SET_UID         0x00010
#define ALD_SET_HOME        0x00020
#define ALD_SET_SHELL       0x00040
#define ALD_SET_FULL_NAME   0x00080
#define ALD_SET_GECOS       0x00100
#define ALD_SET_POLICY      0x00200
#define ALD_SET_PWCHANGE    0x00400
#define ALD_SET_HOME_TYPE   0x00800
#define ALD_SET_CAPS        0x01000
#define ALD_SET_STATE       0x02000
#define ALD_SET_HOME_SRV    0x04000
#define ALD_SET_LGROUPS     0x08000
#define ALD_SET_FLAGS       0x10000
#define ALD_CLR_FAILCNT     0x20000
 
typedef unsigned int ald_user_caps;
 
#define ALD_CAP_ADMIN           0x80000000
#define ALD_CAP_LOCKED          0x40000000
#define ALD_CAP_USER            0x0
#define ALD_CAP_HOST_ADDER      0x1
#define ALD_CAP_ALL_HOST_ADDER  0x2
#define ALD_CAP_ADM_USER        0x4
#define ALD_CAP_LOGIN_MASK      (ALD_CAP_ADMIN | ALD_CAP_HOST_ADDER | ALD_CAP_ALL_HOST_ADDER | ALD_CAP_ADM_USER)
#define ALD_CAP_FULL_MASK       (ALD_CAP_USER | ALD_CAP_ADMIN | ALD_CAP_LOCKED | \
    ALD_CAP_HOST_ADDER | ALD_CAP_ALL_HOST_ADDER | ALD_CAP_ADM_USER)
 
#define ALD_USER_INFO_0   0
#define ALD_USER_INFO_1   1
#define ALD_USER_INFO_2   2
#define ALD_USER_INFO_3   3
#define ALD_USER_INFO_4   4
 
#define ALD_USER_PROP_NAME        0  // ALD_SET_NAME
#define ALD_USER_PROP_UID         1  // ALD_SET_UID
#define ALD_USER_PROP_GID         2  // ALD_SET_GID
#define ALD_USER_PROP_CAPS        3  // ALD_SET_CAPS
#define ALD_USER_PROP_HOME        4  // ALD_SET_HOME
#define ALD_USER_PROP_HOMETYPE    5  // ALD_SET_HOME_TYPE
#define ALD_USER_PROP_GECOS       6  // ALD_SET_GECOS
#define ALD_USER_PROP_SHELL       7  // ALD_SET_SHELL
#define ALD_USER_PROP_DESC        8  // ALD_SET_DESC
#define ALD_USER_PROP_FULLNAME    9  // ALD_SET_FULL_NAME
#define ALD_USER_PROP_POLICY     10  // ALD_SET_POLICY
#define ALD_USER_PROP_HOMESRV    11  // ALD_SET_HOME_SRV
#define ALD_USER_PROP_LGROUPS    12  // ALD_SET_LGROUPS
 
class CALDUser: public CALDObject
{
protected:    
    CALDKrbPrincipalPtr m_krbPrinc; 
    string m_strUID;                
    uid_t m_UID;                    
    string m_strGID;                
    gid_t m_GID;                    
    ald_user_caps m_Caps;           
 
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual void EnsureEntity();
    virtual bool ProcessEntity(bool quiet = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalRemove(bool force, void *extra = NULL);
    virtual void InternalCreate(void *extra = NULL);
    virtual void InternalUpdate(unsigned int setmask, ald_string_multimap& attrs, void *extra);
public:
    explicit CALDUser(CALDConnectionPtr Conn);
    string const &strUID();
    uid_t uid();
    string const &strGID();
    gid_t gid();
    ald_user_caps caps();
    ald_linux_caps linuxCaps();
 
    bool IsAdm();
    bool IsHostAdder();
    bool IsAllHostAdder();
    bool IsAdmUser();
    bool IsLocked();
    bool IsFailLocked();
    bool CanLogin();
 
    void AllowedHosts(ald_string_list &hostlist);
 
    void AllowedHostGroups(ald_string_list &hgrouplist);
 
    string home();
    string hometype();
    string homeserver();
    string gecos();
    string shell();
 
    string desc();
    string policy();
    string pgroup();
    void sgroups(ald_string_list &sgrouplist);
    void lgroups(ald_string_list &lgrouplist);
    string fullname();
    CALDKrbPrincipalPtr princ();
    unsigned int miclevel();
    virtual void Clear();
    virtual void Create(const string &newname, const string &newpwd, const string &newhometype,
                        const string &newhome, const string &newhomesrv, const string &newshell,
                        const string &newgecos, const string &newdesc, const string &newfull_name,
                        const string &newpolicy, const string &newlgroups, gid_t newgid,
                        uid_t newuid, bool needpwchange = false);
    virtual bool Get(const string &user, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Update(unsigned int setmask, const string &newhometype, const string &newhome,
                        const string &newhomesrv, const string &newshell, const string &newgecos,
                        const string &newdesc, const string &newfull_name, const string &newpolicy,
                        const string &newlgroups, gid_t newgid, uid_t newuid, bool needpwchange);
    virtual void ChangePwd(const string &pwd);
    virtual void Remove(bool force = false);
    void SetCaps(ald_user_caps newcaps);
    void SetLinuxCaps(ald_linux_caps newcaps);
    void SetAllowedHosts(const ald_string_list &hosts, const ald_string_list &hgroups);
    void SetMICLevel(unsigned int level);
    void SetPhoto(const char* buff, unsigned long len);
    void* GetPhoto(unsigned long &len); // result must be freed
    virtual bool CheckConsistency(string &msg);
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
    virtual ~CALDUser();
};
 
typedef shared_ptr<CALDUser> CALDUserPtr;
 
#define ALD_GROUP_INFO_0   0
#define ALD_GROUP_INFO_1   1
 
#define ALD_GROUP_PROP_NAME        0  // ALD_SET_NAME
#define ALD_GROUP_PROP_GID         1  // ALD_SET_GID
#define ALD_GROUP_PROP_MEMBER      2  // ALD_SET_MEMBERS
#define ALD_GROUP_PROP_DESC        3  // ALD_SET_DESC
 
class CALDGroup: public CALDObject
{
protected:
    string m_strGID;        
    gid_t m_GID;            
 
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual bool ProcessEntity(bool quiet = false);
    virtual void InternalUpdate(unsigned int setmask, ald_string_multimap& attrs, void *extra);
public:
    explicit CALDGroup(CALDConnectionPtr Conn);
 
    gid_t gid();
    string strGID();
 
    string desc();
    void members(ald_string_list &memlist);
    void pmembers(ald_string_list &pmemlist);
    bool empty();
    virtual void Clear();
    virtual void Create(const string &newname, const string &newdesc, const ald_string_list &newusers, gid_t newgid);
    virtual bool Get(const string &group, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Update(unsigned int setmask, const string &newname, gid_t newgid,
                        const string &newdesc, const ald_string_list &newusers);
    virtual bool CheckRemoval(bool quiet = false);
    virtual void Remove(bool force = false);
    void AddMember(const string &user);
    void RmMember(const string &user);
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
    virtual bool IsSystemObject();
    virtual ~CALDGroup();
};
 
typedef shared_ptr<CALDGroup> CALDGroupPtr;
 
typedef int ald_task_status;
 
#define ALD_TASK_STATUS_PENDING   0
#define ALD_TASK_STATUS_OK        1
#define ALD_TASK_STATUS_ERROR     -1
 
#define ALD_TASK_STATUS_FILTER_PENDING  0x01
#define ALD_TASK_STATUS_FILTER_OK       0x02
#define ALD_TASK_STATUS_FILTER_ERROR    0x04
#define ALD_TASK_STATUS_FILTER_ALL      0x07
 
#define ALD_TASK_INFO_1   1
#define ALD_TASK_INFO_2   2
 
class CALDTask: public CALDObject
{
protected:
    string m_strType;           
    ald_task_status m_Status;   
 
    virtual void InternalSave(ostream &os, bool verbose = false){/* not saved ? */}
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual bool ProcessEntity(bool quiet = false);
public:
    explicit CALDTask(CALDConnectionPtr Conn);
    string const &id() const;
    string const &type() const;
    string timestamp();
    string err() const;
    string data();
    ald_task_status status() const;
    string strStatus() const;
    virtual void Create(unsigned int ID, const string &TaskType, const string &TaskData);
    virtual void Clear();
    virtual bool Get(const string &ID, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Remove(bool force = false);
    virtual void SetOkState();
    virtual void SetErrorState(const string &e);
    virtual ~CALDTask();
};
 
typedef shared_ptr<CALDTask> CALDTaskPtr;
 
class CALDEvTask: public CALDTask
{
protected:
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
public:
    explicit CALDEvTask(CALDConnectionPtr Conn);
    virtual void Create(unsigned int ID, const string &TaskType, const string &TaskData);
    virtual bool Get(const string &ID, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Remove(bool force = false);
    virtual void SetOkState();
    virtual void SetErrorState(const string &e);
    virtual ~CALDEvTask();
};
 
typedef shared_ptr<CALDEvTask> CALDEvTaskPtr;
 
// Policy properties ALD_KRB_* from krb5-wrapper.h
// setmask ALD_KRB_* from krb5-wrapper.h
 
class CALDPolicy: public CALDObject
{
protected:
    unsigned int m_MinLife;         
    unsigned int m_MaxLife;         
    unsigned int m_MinLength;       
    unsigned int m_MinClasses;      
    unsigned int m_HistoryNum;      
    CALDKrbPolicyPtr m_krbPolicy;   
 
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual void EnsureEntity();
    virtual bool ProcessEntity(bool quiet = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalRemove(bool force, void *extra = NULL);
    virtual void InternalCreate(void *extra = NULL);
    virtual void InternalUpdate(unsigned int setmask, ald_string_multimap &attrs, void *extra = NULL);
public:
    CALDKrbPolicyPtr krbpolicy() const;
    unsigned int min_life() const;
    unsigned int max_life() const;
    unsigned int min_length() const;
    unsigned int min_classes() const;
    unsigned int history_num() const;
    unsigned int max_fail() const;
    unsigned int failcnt_interval() const;
    unsigned int lockout_duration() const;
    void users(ald_string_list &userlist);
    explicit CALDPolicy(CALDConnectionPtr Conn);
    virtual void Clear();
    virtual void Create(const string &newname, unsigned int newminlife,
                        unsigned int newmaxlife, unsigned int newminlength,
                        unsigned int newminclasses, unsigned int newhistorynum,
                        unsigned int newmaxfail, unsigned int newfailcntinterval,
                        unsigned int newlockoutduration);
    virtual bool Get(const string &policy, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Update(unsigned int setmask, unsigned int newminlife,
                        unsigned int newmaxlife, unsigned int newminlength,
                        unsigned int newminclasses, unsigned int newhistorynum,
                        unsigned int newmaxfail, unsigned int newfailcntinterval,
                        unsigned int newlockoutduration);
    virtual bool CheckRemoval(bool quiet = false);
    virtual void Remove(bool force = false);
    virtual bool CheckConsistency(string &msg);
    virtual void Recreate(const string &polname);
    virtual bool IsSystemObject();
 
    virtual ~CALDPolicy();
};
 
typedef shared_ptr<CALDPolicy> CALDPolicyPtr;
 
class CALDService: public CALDObject
{
protected:
    CALDKrbPrincipalPtr m_krbPrinc; 
 
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalCreate(void *extra = NULL);
    virtual void EnsureEntity();
    virtual bool ProcessEntity(bool quiet = false);
    virtual void InternalRemove(bool force, void *extra = NULL);
public:
    explicit CALDService(CALDConnectionPtr Conn);
    CALDKrbPrincipalPtr princ() const {return m_krbPrinc;}
    virtual void Clear();
    virtual void Create(const string &newname);
    virtual bool Get(const string &service, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    void sgroups(ald_string_list &svcgrouplist);
    virtual void Remove(bool force = false);
    virtual ~CALDService();
};
 
typedef shared_ptr<CALDService> CALDServicePtr;
 
#define ALD_SGROUP_PROP_NAME        0
#define ALD_SGROUP_PROP_MEMBER      1
 
class CALDSvcGroup: public CALDObject
{
protected:
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual bool ProcessEntity(bool quiet = false);
public:
    explicit CALDSvcGroup(CALDConnectionPtr Conn);
    void members(ald_string_list &memlist);
    void services(ald_string_list &svclist);
    virtual bool Get(const string &sgroup, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    void AddService(const string &service);
    void RmService(const string &service);
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
    virtual bool CheckRemoval(bool quiet = false);
    void Remove(bool force);
    virtual ~CALDSvcGroup();
};
 
typedef shared_ptr<CALDSvcGroup> CALDSvcGroupPtr;
 
#define ALD_HGROUP_INFO_0   0
#define ALD_HGROUP_INFO_1   1
 
#define ALD_HGROUP_PROP_NAME        0
#define ALD_HGROUP_PROP_HOST        1
#define ALD_HGROUP_PROP_DESC        2
 
class CALDHostGroup: public CALDObject
{
protected:
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual void InternalUpdate(unsigned int setmask, ald_string_multimap& attrs, void *extra);
    virtual bool ProcessEntity(bool quiet = false);
public:
    explicit CALDHostGroup(CALDConnectionPtr Conn);
 
    string desc();
    void members(ald_string_list &memlist);
    void hosts(ald_string_list &hlist);
    virtual void Create(const string &newname, const string &newdesc);
    virtual bool Get(const string &hgroup, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Update(unsigned int setmask, const string &newname,
                         const string &newdesc, const ald_string_list &newhosts);
    void AddHost(const string &host);
    void RmHost(const string &host);
    virtual bool IsSystemObject();
    virtual void Remove(bool force = false);
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
    virtual ~CALDHostGroup();
};
 
typedef shared_ptr<CALDHostGroup> CALDHostGroupPtr;
 
#define ALD_HOST_INFO_0   0
#define ALD_HOST_INFO_1   1
 
#define ALD_HOST_PROP_NAME        0
#define ALD_HOST_PROP_DESC        1
#define ALD_HOST_PROP_FLAGS       2
#define ALD_HOST_PROP_ID          3
 
#define ALD_HOST_DC         'C'
#define ALD_HOST_PRIMARY    'P'
#define ALD_HOST_FS         'F'
#define ALD_HOST_DISABLED   'D'
 
#define ALD_HOST_EMPTY      "[]"
#define ALD_HOST_PDC        "[PCF]"
#define ALD_HOST_BDC        "[CF]"
#define ALD_OLD_SRV         "[PCF]"
 
class CALDHost: public CALDObject
{
protected:
    string m_strFlags;              
    unsigned int m_serverID;        
    CALDKrbPrincipalPtr m_krbPrinc; 
 
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual void EnsureEntity();
    virtual bool ProcessEntity(bool quiet = false);
    virtual void InternalCreate(void *extra = NULL);
    virtual void InternalRemove(bool force, void *extra = NULL);
public:
    CALDKrbPrincipalPtr princ();
 
    explicit CALDHost(CALDConnectionPtr Conn);
 
    string desc();
    string const flags() const;
    unsigned int serverID();
    bool IsPDC();
    bool IsBDC();
    bool IsFS();
    bool IsDisabled();
    void hgroups(ald_string_list &hgrouplist);
    void hservices(ald_string_list &svclist);
    virtual void Clear();
    virtual void Create(const string &newhost, const string &newdesc);
    virtual bool Get(const string &host, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Update(const string &hostdesc);
    virtual void SetFlags(const string &newflags, unsigned int newID);
    virtual void Remove(bool force = false);
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
    virtual bool CheckRemoval(bool quiet = false);
    virtual ~CALDHost();
};
 
string ModHostFlags(const string &flags, char flag, bool op);
 
typedef shared_ptr<CALDHost> CALDHostPtr;
 
class CALDAdmGroup: public CALDObject
{
protected:
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual bool ProcessEntity(bool quiet = false);
    void GetLDAPMembers(ald_string_list &memblist);
public:
    explicit CALDAdmGroup(CALDConnectionPtr Conn);
    void members(ald_string_list &userlist);
    bool IsMember(const string &user);
    virtual bool Get(const string &agroup, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    void AddMember(const string &user);
    void RmMember(const string &user);
    virtual bool CheckRemoval(bool quiet = false);
    void Remove(bool force);
    virtual ~CALDAdmGroup();
};
 
typedef shared_ptr<CALDAdmGroup>CALDAdmGroupPtr;
 
#define ALD_LOG_CFG_DEST        0
#define ALD_LOG_CFG_TPL         1
 
class CALDDomainLogCfg: public CALDObject
{
protected:
    string m_strLogDest;    
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual bool ProcessEntity(bool quiet = false);
public:
    explicit CALDDomainLogCfg(CALDConnectionPtr Conn);
    string log_dest() const;
    void templates(ald_string_list &tpllist);
    string GetTemplate(const string &tpl_name);
    void ModTemplate(unsigned int setmask, const string &tpl_name, const string &suffix,
                     const string &mode);
    void RmTemplate(const string &tpl_name);
    virtual void Update(const string &newdest);
    virtual bool Get(const string &oname = "", ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
    virtual bool CheckRemoval(bool quiet = false);
    void Remove(bool force);
    virtual ~CALDDomainLogCfg();
};
 
typedef shared_ptr<CALDDomainLogCfg>CALDDomainLogCfgPtr;
 
// name, kdc, desc
#define ALD_TD_INFO_0   0
// krb
#define ALD_TD_INFO_1   1
 
#define ALD_TD_PROP_NAME        0
#define ALD_TD_PROP_KDC         1   // ALD_SET_NAME
#define ALD_TD_PROP_DESC        2   // ALD_SET_DESC
#define ALD_TD_PROP_DIR         3   // ALD_SET_FLAGS
 
#define ALD_TD_DISABLED     0
#define ALD_TD_INBOUND      0x1 // Reserved
#define ALD_TD_OUTBOUND     0x2 // Reserved
#define ALD_TD_BIDIRECTIONAL (ALD_TD_INBOUND|ALD_TD_OUTBOUND) // default
 
class CALDTrustedDomain: public CALDObject
{
protected:
    string m_strKDC;                
    unsigned int m_uDirection;      
    CALDKrbPrincipalPtr m_krbInTGT; 
    CALDKrbPrincipalPtr m_krbOutTGT;
    string m_strInTGT;              
    string m_strOutTGT;             
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual void InternalCreate(void *extra = NULL);
    virtual void InternalRemove(bool force, void *extra = NULL);
 
    virtual void InternalSave(ostream &os, bool verbose = false){ /*dont save, must be recreate */ }
    virtual void EnsureEntity();
    virtual bool ProcessEntity(bool quiet = false);
    void InternalSetName(const string &domain); 
    virtual void InternalUpdate(unsigned int setmask, ald_string_multimap &attrs, void *extra = NULL);
public:
    explicit CALDTrustedDomain(CALDConnectionPtr Conn);
 
    string desc();
    string const &kdc() const;
    string const &strInTGT();
    string const &strOutTGT();
    unsigned int direction() const;
    string strDirection() const;
    CALDKrbPrincipalPtr inTGT();
    CALDKrbPrincipalPtr outTGT();
    virtual void Clear();
    virtual void Create(const string &domain, const string &newkdc, const string &newdesc,
                        unsigned int newdir, const string &newpwd);
    virtual bool Get(const string &domain, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Update(unsigned int setmask, const string &newkdc, const string &newdesc,
                        unsigned int newdir);
    virtual void Remove(bool force = false);
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
    virtual ~CALDTrustedDomain();
};
 
typedef shared_ptr<CALDTrustedDomain> CALDTrustedDomainPtr;
 
#define ALD_DOCUMENT_INFO_0   0
#define ALD_DOCUMENT_INFO_1   1
 
#define ALD_DOCUMENT_PROP_NAME      0  // ALD_SET_NAME
#define ALD_DOCUMENT_PROP_VER       1  // ALD_SET_STATE
#define ALD_DOCUMENT_PROP_TITLE     2  // ALD_SET_GECOS
#define ALD_DOCUMENT_PROP_LOCATION  3  // ALD_SET_FULL_NAME
#define ALD_DOCUMENT_PROP_DESC      4  // ALD_SET_DESC
 
#define ALD_INTDOC_UID  "ALD/DOMAIN/NextUID"
#define ALD_INTDOC_GID  "ALD/DOMAIN/NextGID"
#define ALD_INTDOC_TID  "ALD/DOMAIN/NextTID"
#define ALD_INTDOC_EID  "ALD/DOMAIN/NextEID"
 
class CALDDocument: public CALDObject
{
protected:
    string m_strVersion;    
    string m_strLocation;   
 
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false);
    virtual bool ProcessEntity(bool quiet = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
public:
    explicit CALDDocument(CALDConnectionPtr Conn);
    string const &version();
    string const &location();
    string title();
 
    string desc();
    bool IsInternal();
    virtual void Clear();
    virtual void Create(const string &newname, const string &newtitle, const string &newlocation,
                        const string &newver, const string &newdesc);
    virtual bool Get(const string &name, ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Update(unsigned int setmask, const string &newtitle, const string &newlocation,
                        const string &newver, const string &newdesc);
    virtual bool CheckRemoval(bool quiet = false);
    virtual void Remove(bool force = false);
    virtual bool ValidateProperty(int property, const void *value, string *msg, bool quiet);
    virtual void Upload(const string &filename, bool overwrite);
    virtual void Download(const string &filename = "");
    virtual ~CALDDocument();
};
 
typedef shared_ptr<CALDDocument> CALDDocumentPtr;
 
#define ALD_DOMAIN_PROP_ORG      0  // ALD_SET_NAME
#define ALD_DOMAIN_PROP_STATE    0  // ALD_SET_STATE
#define ALD_DOMAIN_PROP_TEL      0  // ALD_SET_GECOS
#define ALD_DOMAIN_PROP_ADDR     0  // ALD_SET_FULL_NAME
#define ALD_DOMAIN_PROP_DESC     0  // ALD_SET_DESC
 
class CALDDomain: public CALDObject
{
protected:
    string m_strVersion; 
 
    virtual void InternalSave(ostream &os, bool verbose = false);
    virtual aoLoadStatus InternalLoad(istream &is, size_t &nline, string &line, bool verbose = false);
    virtual void InternalNotice(aoOperation op, const string &arg, const string &detail);
    virtual void InternalGet(string object, ald_info_level level, bool quiet = false){ /* nothing to do */}
public:
    explicit CALDDomain(CALDConnectionPtr Conn);
 
    string const &version() const;
 
    string org();
 
    string state();
 
    string telephon();
 
    string address();
 
    string desc();
 
    virtual void Clear();
    virtual bool Get(const string &domain = "", ald_info_level level = ALD_INFO_DEFAULT, bool quiet = false);
    virtual void Update(unsigned int setmask, const string &neworg, const string &newstate,
                        const string &newtel, const string &newaddr, const string &newdesc);
    // ----- groups
    void EnumerateGroups(ald_string_list &groups);
    gid_t NextGID(bool generate);
 
    void AddGroup(const string &group, const string &desc, const ald_string_list &users, gid_t gid = ALD_INVALID_ID);
 
    bool ResolveGroup(const string &group, string &groupname, string &gid, bool quiet = false);
 
    // ----- users
    void EnumerateUsers(ald_string_list &users);
    uid_t NextUID(bool generate);
 
    void AddUser(const string &user, const string &pwd, const string &hometype, const string &home,
                 const string &homesrv, const string &shell, const string &gecos, const string &desc,
                 const string &full_name, const string &policy,  const string &lgroups,
                 gid_t gid = ALD_INVALID_ID, uid_t uid = ALD_INVALID_ID, bool needpwchange = false);
 
    bool ResolveUser(const string &user, string &username, string &uid, bool quiet = false);
    // ------ privileged users
    void EnumeratePrivilegedUsers(ald_string_list &users);
 
    // ----- tasks
    void EnumerateTasks(ald_string_list &tasks, unsigned int status_filter);
 
    void EnumerateTasksSince(ald_string_list &tasks, unsigned int status_filter, time_t since);
 
    unsigned int NextTID(bool generate);
 
    string CreateTask(const string &TaskType, const string &TaskData);
 
    void RotateTasks();
 
    // ----- events
    void EnumerateEvents(ald_string_list &events);
 
    void EnumerateEventsSince(ald_string_list &events, time_t since);
 
    unsigned int NextEID(bool generate);
 
    string RaiseEvent(const string &TaskType, const string &TaskData);
 
    void RotateEvents();
 
    // ----- policies
    void EnumeratePolicies(ald_string_list &policies);
 
    void AddPolicy(const string &policy, unsigned int minlife, unsigned int maxlife, unsigned int minlength,
                   unsigned int minclasses, unsigned int historynum, unsigned int newmaxfail,
                   unsigned int newfailcntinterval, unsigned int newlockoutduration);
 
    bool ResolvePolicy(const string &policy, bool quiet = false);
 
    // ----- Services
    void EnumerateServices(ald_string_list &services);
 
    void AddService(const string &service);
 
    bool ResolveService(const string &service, bool quiet = false);
 
    // ----- Services groups
    void EnumerateServicesGroups(ald_string_list &sgroups);
 
    bool ResolveServicesGroup(const string &sgroup, bool quiet = false);
 
    // ----- Hosts
    // ----- Services groups
    void EnumerateHosts(ald_string_list &hosts);
 
    void AddHost(const string &host, const string &desc);
 
    bool ResolveHost(const string &host, string &hostname, bool quiet = false);
 
    // ----- Hosts groups
    void EnumerateHostsGroups(ald_string_list &hgroups);
 
    void AddHostsGroup(const string &hgroup, const string &hgroupdesc);
 
    bool ResolveHostsGroup(const string &hgroup, bool quiet = false);
 
    // ----- Tasks
    unsigned int taskHistory();
 
    void SetTaskHistory(unsigned int value);
 
    void UpdateServerTimestamp();
 
    string server_timestamp();
 
    // ----- FileServers
    void EnumerateFileServers(ald_string_list &fileservers);
 
    void EnumerateHomeServers(ald_string_list &homeservers);
 
    // --------------------
    void EnumerateALDServers(ald_string_list &servers);
 
    bool ResolveALDServer(string &host, unsigned int &server_id, bool quiet = false);
 
    // ----- TrustedDomains
    void EnumerateTrustedDomains(ald_string_list &realms);
 
    void AddTrustedDomain(const string &realm, const string &kdc, const string &desc,
                          unsigned int newdir, const string &newpwd);
 
    bool ResolveTrustedDomain(const string &realm, string &kdc, bool quiet = false);
 
    // ----- Documents
    void EnumerateDocuments(ald_string_list &docs, bool internal_oly);
 
    void EnumerateDocumentsSince(ald_string_list &docs, time_t since);
 
    void AddDocument(const string &name, const string &title, const string &location,
                     const string &ver, const string &desc);
 
    void AddInternalDocument(const string &name, const string &ver, const string &desc);
 
    // serialization
    virtual void Save(const string &pbkfile, bool verbose = false);
    virtual void Save(ostream &os, bool verbose = false);
    virtual void Load(const string &pbkfile, bool verbose = false);
    virtual void Load(istream &is, const string &bkname, bool verbose = false);
 
    virtual bool CheckRemoval(bool quiet = false);
 
    void Remove(bool force);
 
    // ----- Common
    virtual bool RemoveObject(const string &otype, const string &oname, bool checkonly);
 
    virtual ~CALDDomain();
};
 
typedef shared_ptr<CALDDomain> CALDDomainPtr;
 
CALDHostPtr GetServer(CALDConnectionPtr Conn);
CALDHostPtr GetHost(CALDConnectionPtr Conn);
 
bool UpdateServiceInKeytab(CALDConnectionPtr Conn, const string &keytab, const string &service, bool create);
 
void ShowLdapOperInfo(CALDObject &object, ostream &out);
 
void SetALDTimestamp(CALDObject &object, const string &tsname, time_t ts = 0); // 0 - now
 
string GetALDTimestamp(CALDObject &object, const string &tsname);
 
struct ald_object_action_extra {
    CALDConnectionPtr conn; 
    // cppcheck-suppress unusedStructMember
    bool quiet;             
    // cppcheck-suppress unusedStructMember
    void *extra;            
};
 
struct ald_pam_user_extra {
    CALDConnectionPtr conn; 
    string user;            
    string home;            
    string hometype;        
    string homeserver;      
    uid_t uid;              
    gid_t gid;              
    ald_string_list mounts; 
    unsigned int ctrls;     
    // cppcheck-suppress unusedStructMember
    void *pamh;             
    // cppcheck-suppress unusedStructMember
    void *extra;            
    //
    IALDCore* pCore;
    bool bClientOn;
    bool bLoggedInCached;
    bool bHostDisabled;
    bool bUserLocked;
    bool bUserPermittedToHost;
    int  ngids;
    gid_t *pgids;
};
 
struct ald_portable_save_extra {
    CALDConnectionPtr conn; 
    string otype;           
    ostream *os;            
    // cppcheck-suppress unusedStructMember
    bool verbose;           
    // cppcheck-suppress unusedStructMember
    void *extra;            
};
 
struct ald_portable_load_extra {
    CALDConnectionPtr conn; 
    string version;         
    istream *is;            
    // cppcheck-suppress unusedStructMember
    size_t nline;           
    // cppcheck-suppress unusedStructMember
    bool loaded;            
    // cppcheck-suppress unusedStructMember
    bool verbose;           
    // cppcheck-suppress unusedStructMember
    void *extra;            
};
 
 
struct ald_delete_object_extra {
    CALDConnectionPtr conn; 
    string otype;           
    // cppcheck-suppress unusedStructMember
    bool checkonly;         
    // cppcheck-suppress unusedStructMember
    bool deleted;           
    // cppcheck-suppress unusedStructMember
    void *extra;            
};
 
struct ald_task_extra {
    CALDConnectionPtr conn; 
    string id;              
    string type;            
    string data;            
    string error;           
    bool done;              
    bool skip;              
    void *extra;            
};
 
#define CHECK_VALID ALD_CHECK(m_bValid, ERR_INVALID_OBJECT)
#define CHECK_NAME_VALID ALD_CHECK(!m_strName.empty(), ERR_INVALID_OBJECT)
#define QLOG_WARN(warn) {if(!quiet) LOG_WARN(warn);}
#define QLOG_ERR(warn) {if(!quiet) LOG_ERR(warn);}
#define QALD_ERR(err) {if(!quiet) ALD_ERROR(err);}
 
#define ALD_OBJECT_TRIGGER_CHECK(action, quiet)  TriggerAction(ALD_OBJECT_ACTION(PFM2Name(__PRETTY_FUNCTION__), \
    it->first), aotatCheck, quite)
#define ALD_OBJECT_TRIGGER_ACTION(action, quiet)  TriggerAction(ALD_OBJECT_ACTION(PFM2Name(__PRETTY_FUNCTION__), \
    it->first), aotatAction, quite)
 
#define ALD_OBJECT_START_OPERATION(op, arg) StartOperation(PFM2Name(__PRETTY_FUNCTION__), op, arg, "", false)
#define ALD_OBJECT_START_OPERATION_FORCE(op, arg, force) StartOperation(PFM2Name(__PRETTY_FUNCTION__), op, arg, "", force)
#define ALD_OBJECT_START_OPERATION_DETAIL(op, arg, det) StartOperation(PFM2Name(__PRETTY_FUNCTION__), op, arg, det, false)
#define ALD_OBJECT_COMMIT_OPERATION(op) CommitOperation(PFM2Name(__PRETTY_FUNCTION__), op, false)
#define ALD_OBJECT_COMMIT_OPERATION_PE(op) CommitOperation(PFM2Name(__PRETTY_FUNCTION__), op, true)
#define ALD_OBJECT_COMMIT_OPERATION_PEQ(op) CommitOperation(PFM2Name(__PRETTY_FUNCTION__), op, true, quiet)
 
bool IfAdminCanManageHost(CALDConnectionPtr conn, const string& admin, const string& host);
 
bool IfAdminCanManageHostGroup(CALDConnectionPtr conn, const string& admin, const string& hostgroup);
 
} // ALD
 
#endif // ALD_OBJECTS