a/ald/ald-doc_1.7.85_all.deb

#ifndef ALD_CORE

#define ALD_CORE


#include "common.h"

#include "ALDCommand.h"

#include "ALDLogProvider.h"

#include <map>

#include <memory>


using namespace std;


namespace ALD

{

enum ALDAuthType {

    aatSimple,

    aatLocal,

    aatGSS,

    aatGSSKeytab,

    aatUser

};


struct ald_module_info {

    // cppcheck-suppress unusedStructMember

    int        api_version;

    const char *name;

    const char *version;

    // cppcheck-suppress unusedStructMember

    int        type;

    const char *desc;

    // cppcheck-suppress unusedStructMember

    void       *extra;

};


#define ALD_API_VERSION          1*0x10000+7*0x100+37


#define ALD_MODULE_VERSION      "1.7.37"


#define ALD_MODULE_TYPE_HOST     0

#define ALD_MODULE_TYPE_ITF      1

#define ALD_MODULE_TYPE_CFG      2

#define ALD_MODULE_TYPE_PLUGIN   3


typedef ald_module_info* (ald_get_module_info_ft)(const ald_module_info &host);


#define ALD_MODE_UNDEFINED        ""

#define ALD_MODE_CLIENT           "client"

#define ALD_MODE_SERVER           "server"

#define ALD_MODE_ADMIN            "admin"


typedef bool (ald_module_init_ft)(ALD::IALDCore &Core, const string &mode);


typedef void (ald_module_done_ft)(ALD::IALDCore &Core);


class CALDInterface

{

protected:

    string m_strName;

    IALDCore* m_pCore;

public:

    inline const string &name() const {return m_strName;}

    CALDInterface(const string &Name, IALDCore &Core):m_strName(Name),m_pCore(&Core){}

    virtual ~CALDInterface(){}

};


typedef shared_ptr<CALDInterface> CALDInterfacePtr;


typedef map<string, CALDInterfacePtr> ald_interface_map;


#define ALD_OPR_CFG_INSTALL   "install"

#define ALD_OPR_CFG_CONFIGURE "configure"

#define ALD_OPR_CFG_ON        "on"

#define ALD_OPR_CFG_OFF       "off"

#define ALD_OPR_CFG_UNINSTALL "uninstall"

class IALDConfigurator: public CALDInterface

{

public:

    IALDConfigurator(const string &Name, IALDCore &Core):CALDInterface(Name, Core){}

    virtual int OperationConfig(const string &mode, const string &operation) = 0;

};


typedef shared_ptr<IALDConfigurator> CALDConfiguratorPtr;


typedef map<string, CALDConfiguratorPtr> ald_configurator_map;


class CALDValidator

{

protected:

    string m_strName;

    IALDCore* m_pCore;

    string m_strError;

    void ClearError();

public:

    inline const string &name() const {return m_strName;}

    inline const string &error() const {return m_strError;}


    CALDValidator(const string &Name, IALDCore &Core):m_strName(Name),m_pCore(&Core){}


    virtual bool Validate(const void *value, const void *tag, void *result);


    virtual ~CALDValidator(){}

};


typedef shared_ptr<CALDValidator> CALDValidatorPtr;


typedef map<string, CALDValidatorPtr> ald_validator_map;


enum asmSigIntMode {

    asmSigIntOn,

    asmSigIntOff

};


typedef bool ald_action_trigger_func(IALDCore* Core, const string &action, const string &object,

                                     CALDCommand *cmd, void* extra);

struct ald_action_trigger {

    string name;

    // cppcheck-suppress unusedStructMember

    ald_action_trigger_func* trigger;

};


struct ald_test_integrity_extra {

    // cppcheck-suppress unusedStructMember

    bool fixit;

    unsigned int errcnt;

    ald_string_list &errlist;

    // cppcheck-suppress unusedStructMember

    void* extra;

};


struct ald_ldap_consistency_extra {

    // cppcheck-suppress unusedStructMember

    ald_string_list &modules;

    ald_string_list &indexes;

    ald_string_list &uniqueness;

    // cppcheck-suppress unusedStructMember

    void* extra;

};


typedef pair<string, ald_action_trigger> ald_trigger_pair;


typedef multimap<string, ald_action_trigger> ald_triggers_map;


struct ald_file_perm {

    string  filename;

    string  owner;

    string  group;

    // cppcheck-suppress unusedStructMember

    int     perm;

};


typedef list<ald_file_perm> ald_file_perm_list;


struct ald_backup_extra {

    ald_file_perm_list lst_keys;

    ald_file_perm_list lst_bases;

    ald_file_perm_list lst_perms;

    // cppcheck-suppress unusedStructMember

    void* extra;

};


class IALDCore

{

public:

    // Properties

    virtual CALDLogProvider* LogProvider() = 0;


    virtual const string &domain() = 0;

    virtual const string &serverName() = 0;

    virtual const string &hostName() = 0;

    virtual const string &compatibilityVersion() = 0;

    virtual const string &ApplicationName() = 0;

    virtual void SetApplicationName(const string& name) = 0;


    virtual const ald_string_list &HiddenPrincipals() = 0;      // ALD hidden Principals

    virtual const ald_string_list &ServicesGroups() = 0;        // ALD groups of services

    virtual const ald_string_list &SupportedFS() = 0;           // Supported fs types

    virtual const ald_string_list &DefaultLocalGroups() = 0;    // Default local groups

    virtual const ald_string_list &AllowedLocalGroups() = 0;    // Allowed local groups

    virtual ald_string_map &Tags() = 0;                // Tags

    virtual string ALDSubdir() = 0;


    // States and conditions

    virtual bool IfForce() = 0;

    virtual bool IfVerbose() = 0;

    virtual bool Ifrfc2822() = 0;

    virtual bool IfServer() = 0;

    virtual bool IfServerOn() = 0;

    virtual bool IfClientOn() = 0;

    virtual bool IfUseFS(const string &fs) = 0;

    virtual bool IfNotUseFS() = 0;

    virtual bool IfConfigured() = 0;

    virtual bool IfUseDNS() = 0;

    virtual bool isServerHost() = 0;


    // modules (configurators, interfaces, plugins)

    virtual void ReloadExtensions() = 0;

    virtual void InitPlugins(const string &mode) = 0;

    virtual const ald_module_info &HostModuleInfo() = 0;

    virtual void SetHostModuleInfo(const string &name, const string &desc) = 0;

    virtual void EnumerateModules(int module_type, ald_string_map &mods) = 0;

    virtual bool IfModuleLoaded(const string &name) = 0;


    // configurators

    virtual void EnumerateConfigurators(ald_string_list &cfgs) = 0;

    virtual void AddConfigurator(CALDConfiguratorPtr cfgr) = 0;

    virtual void RemoveConfigurator(const string &name) = 0;

    virtual void UseConfigurators(const string &mode) = 0;

    virtual void OperationConfig(const string &mode, const string &operation) = 0;


    // interfaces

    virtual void EnumerateInterfaces(ald_string_list &itfs) = 0;

    virtual void AddInterface(CALDInterfacePtr itf) = 0;

    virtual CALDInterfacePtr GetInterface(const string &name) = 0;

    virtual void RemoveInterface(const string &name) = 0;

    virtual void UseInterface(const string &name, const string &mode) = 0;


    // validators

    virtual void EnumerateValidators(ald_string_list &vlds) = 0;

    virtual void AddValidator(CALDValidatorPtr vld) = 0;

    virtual CALDValidatorPtr GetValidator(const string &name) = 0;

    virtual void RemoveValidator(const string &name) = 0;

    virtual bool ValidateValue(const string &validator, const void *value, const void *tag, void *result, string *err) = 0;


    // triggers

    virtual void EnumerateTriggers(const string &action, ald_string_map &trgs) = 0;

    virtual void RegisterTrigger(const string &action, const string &name, ald_action_trigger_func &trigger) = 0;

    virtual void UnregisterTrigger(const string &action, const string &name, ald_action_trigger_func &trigger) = 0;

    virtual bool TriggerAction(const string &action, const string &object, CALDCommand *cmd, void* extra) = 0;


    // Admin, Secrets, Login

    virtual string admin() const = 0;

    virtual ALDAuthType authType() const = 0;

    virtual bool IfKadmin() const = 0;

    virtual bool IfCCache() const = 0;

    virtual void SetCCache(bool ccache) = 0;

    virtual bool GetSecret(const string &user, string &secret, const string &prompt = "") = 0;

    virtual bool NewSecret(const string &user, string &secret, const string &prompt = "") = 0;

    virtual void SetSecret(const string &user, const string &secret) = 0;

    virtual void LoginAdmin(const string &user, ALDAuthType at, bool kadmin = true) = 0;

    virtual void ForgetAdmin() = 0;


    // Signals

    virtual void UseSigInt() = 0;

    virtual void SetSigIntMode(asmSigIntMode mode) = 0;

    virtual asmSigIntMode GetSigIntMode() = 0;

    virtual bool IfSigInt() = 0;

    virtual bool IfSigPipe() = 0;

    virtual bool IfSigTerm() = 0;

    virtual bool IfSigHup() = 0;

    virtual void ClearSignal(int sig) = 0;


    // Settings

    virtual void LoadSettings() = 0;

    virtual string SettingsValue(const string &p) = 0;

    virtual bool SettingsValueExists(const string &p) = 0;

    virtual void SetSettingsValue(const string &p, const string &v) = 0;


    // Commands and options

    virtual CALDCommands &CLCommands() = 0;

    virtual CALDCommandOptions &CommonCLOptions() = 0;

    virtual void OnBeforeCommand() = 0;

    virtual void OnAfterCommand() = 0;

    virtual int ExecALDCommand(const string &command, const string &argument, const ald_string_multimap &mapOptions) = 0;

    virtual int ExecALDCommand(const string &command, const ald_string_list &args, const ald_string_multimap &mapOptions) = 0;


    // Utils

    virtual bool RE_match(const string &pattern, const string &value, const int optc = 0, const int opte = 0) = 0;


    virtual void CheckNameResolution() = 0;


    virtual void SetKadmLocal(bool kadmlocal) = 0;


    virtual void ShowSettings(ostream &out) = 0;

    virtual void ShowInternals(ostream &out) = 0;

    virtual void ShowStatus(ostream &out) = 0;


    // lists

    virtual bool ServiceGroupsMod(const string &sgroup, bool remove = false) = 0;

    virtual bool SupportedFSMod(const string &fs, bool remove = false) = 0;


    // Maintenance

    virtual bool MaintenanceMode() = 0;

};


#define ALD_USER_NAME_MAX_SIZE      31

#define ALD_GROUP_NAME_MAX_SIZE     ALD_USER_NAME_MAX_SIZE

#define ALD_PWD_MAX_SIZE            40

#define ALD_DESC_MAX_SIZE           1000

#define ADM_USER_NAME             "admin/admin"

#define ADM_ALDD_USER_NAME        "aldd"

#define ADM_DEF_USER_NAME         "default/user"

#define ALD_DEF_POLICY_NAME       "default"


#define ALD_FS_LOCAL              "local"

#define ALD_FS_NFS                "nfs"

#define ALD_FS_CIFS               "cifs"


#define ALD_PRM_VERSION           "VERSION"

#define ALD_PRM_SERVER            "SERVER"

#define ALD_PRM_DOMAIN            "DOMAIN"

#define ALD_PRM_DOMAIN_DN         "DOMAIN_DN"

#define ALD_PRM_REALM             "REALM"

#define ALD_PRM_NETWORK_FS_TYPE   "NETWORK_FS_TYPE"

#define ALD_PRM_MINIMUM_UID       "MINIMUM_UID"

#define ALD_PRM_MINIMUM_GID       "MINIMUM_GID"

#define ALD_PRM_DEF_LOGIN_SHELL   "DEFAULT_LOGIN_SHELL"

#define ALD_PRM_TICKET_MAX_LIFE   "TICKET_MAX_LIFE"

#define ALD_PRM_TICKET_MAX_R_LIFE "TICKET_MAX_RENEWABLE_LIFE"

#define ALD_PRM_DESC              "DESCRIPTION"

#define ALD_PRM_RPC_PORT          "RPC_PORT"

#define ALD_PRM_USE_RPC           "USE_RPC"

#define ALD_PRM_ALDD_USER         "ALDD_USER"

#define ALD_PRM_USE_DNS           "USE_DNS"

#define ALD_PRM_USER_GROUPS       "USER_GROUPS"

#define ALD_PRM_USE_DOCUMENTS     "USE_DOCUMENTS"

#define ALD_PRM_PREF_SERVERS      "PREFERRED_SERVERS"

#define ALD_PRM_AUTORECONF        "AUTORECONFIGURE"

#define ALD_PRM_VALID_USER_NAMES  "VALID_USER_NAMES"

#define ALD_PRM_VALID_GROUP_NAMES "VALID_GROUP_NAMES"

#define ALD_PRM_ALD_HOSTNAME      "ALD_HOSTNAME"


#define ALD_PRM_CLIENT_MOUNT_DIR      "CLIENT_MOUNT_DIR"

#define ALD_PRM_CLIENT_ON             "CLIENT_ON"

#define ALD_PRM_CLIENT_FS_KRB_MODE    "CLIENT_FS_KRB_MODE"

#define ALD_PRM_CLIENT_SMB_VERSION    "CLIENT_SMB_VERSION"

#define ALD_PRM_ALLOWED_LOCAL_GROUPS  "ALLOWED_LOCAL_GROUPS"

#define ALD_PRM_CACHE_REFRESH_PERIOD  "CACHE_REFRESH_PERIOD"

#define ALD_PRM_CACHE_ACCESS_USERS    "CACHE_ACCESS_USERS"

#define ALD_PRM_LOCAL_SOCKET_PATH     "LOCAL_SOCKET_PATH"


#define ALD_PRM_SERVER_ON               "SERVER_ON"

#define ALD_PRM_SERVER_EXPORT_DIR       "SERVER_EXPORT_DIR"

#define ALD_PRM_SERVER_ARCHIVE_DIR      "SERVER_ARCHIVE_DIR"

#define ALD_PRM_SERVER_FS_KRB_MODES     "SERVER_FS_KRB_MODES"

#define ALD_PRM_SERVER_POLLING_PERIOD   "SERVER_POLLING_PERIOD"

#define ALD_PRM_UTF8_GECOS              "UTF8_GECOS"

#define ALD_PRM_DEFAULT_LOCAL_GROUPS    "DEFAULT_LOCAL_GROUPS"

#define ALD_PRM_SERVER_ID               "SERVER_ID"

#define ALD_PRM_SERVER_RPC_RESTRICTED   "RPC_RESTRICTED"

#define ALD_PRM_SERVER_KEYTAB           "SERVER_KEYTAB"

#define ALD_PRM_SERVER_KADM_RELOAD      "SERVER_KADM_RELOAD"


#define ALD_PRM_SUB_DIR           "ALD_SUB_DIR"

#define ALD_PRM_CC_PREFIX         "ALD_CC_PREFIX"

#define ALD_PRM_VAR_LIB_DIR       "ALD_VAR_LIB_DIR"

#define ALD_PRM_COMMON_KEYTAB     "ALD_COMMON_KEYTAB"

#define ALD_PRM_CFG_TEMPL_DIR     "ALD_CFG_TEMPL_DIR"

#define ALD_PRM_CFG_DIR           "ALD_CFG_DIR"

#define ALD_PRM_ITFS_DIR          "ALD_ITFS_DIR"

#define ALD_PRM_PLUGINS_DIR       "ALD_PLUGINS_DIR"

#define ALD_PRM_CFG_MODULES_DIR   "ALD_CFG_MODULES_DIR"

#define ALD_PRM_CFG               "ALD_CFG"

#define ALD_PRM_CFG_ROOT_DIR      "ALD_CFG_ROOT_DIR"

#define ALD_PRM_USR_SHARE_DIR     "ALD_USR_SHARE_DIR"

#define ALD_PRM_LDAP_SCHEMA_DIR   "ALD_LDAP_SCHEMA_DIR"

#define ALD_PRM_CACHE_DIR         "ALD_PRM_CACHE_DIR"

#define ALD_PRM_DOMAIN_USERS_GID  "ALD_DOMAIN_USERS_GID"

#define ALD_PRM_DOCS_DIR          "ALD_PRM_DOCS_DIR"

#define ALD_PRM_LDAP_URIS         "ALD_PRM_LDAP_URIS"

#define ALD_PRM_CONN_LOCK_FILE    "ALD_PRM_CONN_LOCK_FILE"


#define ALD_VALIDATOR_USER_NAME         "UserName"

#define ALD_VALIDATOR_GROUP_NAME        "GroupName"

#define ALD_VALIDATOR_PATH              "Path"

#define ALD_VALIDATOR_GECOS             "Gecos"

#define ALD_VALIDATOR_POLICY_NAME       "PolicyName"

#define ALD_VALIDATOR_POLICY_LIFETIME   "PolicyLifeTime"

#define ALD_VALIDATOR_TASK_HISTORY      "TaskHistory"

#define ALD_VALIDATOR_SERVICE_NAME      "ServiceName"

#define ALD_VALIDATOR_HIDDEN_PRINCIPALS "HiddenPrincipals"

#define ALD_VALIDATOR_HOST_NAME         "HostName"

#define ALD_VALIDATOR_DOMAIN_NAME       "DomainName"

#define ALD_VALIDATOR_HOST_FLAGS        "HostFlags"

#define ALD_VALIDATOR_SGROUP_NAME       "SvcGroupName"

#define ALD_VALIDATOR_HGROUP_NAME       "HostGroupName"

#define ALD_VALIDATOR_DNS_NAME          "DNSName"

#define ALD_VALIDATOR_DOC_NAME          "DocumentName"


#define ALD_CMD_SECTION     "ALD Common API"


#define ALD_DOMAIN_USERS        "Domain Users"

#define ALD_DOMAIN_COMPUTERS    "Domain Computers"

#define ALD_DOMAIN_CONTROLLERS  "Domain Controllers"

#define ALD_DOMAIN_FILESERVERS  "Domain File Servers"


} // ALD


#endif //ALD_CORE