ALDCoreUtils.h

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

 
#ifndef ALD_CORE_UTILS
#define ALD_CORE_UTILS
 
#include <string>
#include "ALDCore.h"
#include "ldap-wrapper.h"
#include "kadm5-wrapper.h"
#include "ald-config.h"
#include "ald-rpc.h"
#include <stdint.h>
using namespace std;
 
namespace ALD
{
// ALD connection interfaces flags
#define ALD_CI_LDAP     0x1     // LDAP interface needed
#define ALD_CI_KADM5    0x2     // KADM5 interface needed
#define ALD_CI_RPC      0x4     // RPC interface needed
 
#define ALD_CI_GSS      0x100   // used GSS authentication
#define ALD_CI_LAZY     0x200   // dont establish connection immedeately
#define ALD_CI_CACHE    0x400   // try use credential cache
 
#define ALD_CI_ALL      ALD_CI_LDAP|ALD_CI_KADM5|ALD_CI_RPC|ALD_CI_GSS|ALD_CI_LAZY
#define ALD_CI_LOCAL    ALD_CI_LDAP|ALD_CI_KADM5
#define ALD_CI_CLIENT   ALD_CI_LDAP|ALD_CI_RPC|ALD_CI_GSS|ALD_CI_LAZY
 
CALDLdapConnPtr GetLdapConnection(IALDCore &Core, ALDAuthType at, unsigned int ci_flags);
CALDKadm5ConnPtr GetKadm5Connection(IALDCore &Core, ALDAuthType at, unsigned int ci_flags);
CALDRpcConnPtr GetRpcConnection(IALDCore &Core, ALDAuthType at, unsigned int ci_flags);
CALDConfigPtr GetConfig(IALDCore &Core);
 
class CALDConnection
{
protected:
    IALDCore *m_pCore;              
    ALDAuthType m_AuthType;         
    CALDLdapConnPtr m_connLdap;     
    CALDKadm5ConnPtr m_connKadm5;   
    CALDRpcConnPtr m_connRpc;       
    unsigned int m_ci_flags;        
    string m_strUserId;             
    bool m_bActive;                 
public:
    explicit CALDConnection(IALDCore &Core, ALDAuthType at,
                            unsigned int flags = ALD_CI_ALL);
    ALDAuthType AuthType() const;
    IALDCore *pCore() const;
    CALDLdapConnPtr &ldap();
    CALDKadm5ConnPtr &kadm5();
    CALDRpcConnPtr &rpc();
    const string& userId() const {return m_strUserId;}
 
    bool Check(unsigned int timeout, unsigned int delay);
    bool IsConnected();
    void Connect(ALDAuthType at, unsigned int ci_flags = 0);
    void Connect(const string &userId, ALDAuthType at, unsigned int ci_flags = 0);
    void Disconnect();
    void EnsureConnection();
    unsigned int flags() const;
    bool IsLdap() const;
    bool IsKadm() const;
    bool IsRpc() const;
    virtual ~CALDConnection();
};
 
typedef shared_ptr<CALDConnection> CALDConnectionPtr;
 
void RegisterLdapSchema(IALDCore &Core, const string &schema);
 
IALDCore* AllocateCore();
 
void FreeCore(IALDCore* &ICore);
 
bool LoginAdmin(IALDCore &Core, const string &admin = "");
 
bool LoginAdmin(IALDCore &Core, const string &admin, const string &pwd);
 
void Logout(IALDCore &Core, bool keep_cred = false);
 
void InitCore(IALDCore &Core);
 
class CALDUserNameValidator: public CALDValidator
{
//#define ALD_RE_USER_NAME "[a-z][a-z0-9\\_\\-]*" now in ALD_PRM_VALID_USER_NAMES
public:
    CALDUserNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_USER_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDGroupNameValidator: public CALDValidator
{
//#define ALD_RE_GROUP_NAME "[A-Za-z][A-Za-z0-9\\_\\-\\ ]*" now in ALD_PRM_VALID_GROUP_NAMES
public:
    CALDGroupNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_GROUP_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDServiceNameValidator: public CALDValidator
{
#define ALD_RE_SERVICE_NAME "[A-Za-z][A-Za-z0-9\\_\\-]*"
public:
    CALDServiceNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_SERVICE_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDPathValidator: public CALDValidator
{
#define ALD_RE_PATH "[\\/0-9A-Za-zА-Яа-я\\.\\-\\_]+"
public:
    CALDPathValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_PATH, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDGecosValidator: public CALDValidator
{
#define ALD_RE_UTF8_GECOS_FIELD  "[^\\:]*"
//#define ALD_RE_UTF8_GECOS_FIELD  "[0-9A-Za-zА-Яа-рс-я \\@\\#\\$\\-\\.\\+\\‍(\\‍)\\_]*"
#define ALD_RE_GECOS_FIELD  "[^А-Яа-рс-я\\:]*"
//#define ALD_RE_GECOS_FIELD  "[0-9A-Za-z \\@\\#\\$\\-\\.\\+\\‍(\\‍)\\_]*"
public:
    CALDGecosValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_GECOS, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDPolicyNameValidator: public CALDValidator
{
#define ALD_RE_POLICY_NAME "[0-9A-Za-z\\_\\-]+"
public:
    CALDPolicyNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_POLICY_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDPolicyLifeTimeValidator: public CALDValidator
{
#define ALD_RE_LIFETIME "\\d+(d|h|m|s)"
public:
    CALDPolicyLifeTimeValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_POLICY_LIFETIME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDTaskHistoryValidator: public CALDValidator
{
public:
    CALDTaskHistoryValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_TASK_HISTORY, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDHiddenPrincipalsValidator: public CALDValidator
{
public:
    CALDHiddenPrincipalsValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_HIDDEN_PRINCIPALS, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDHostNameValidator: public CALDValidator
{
#define ALD_RE_HOST_NAME "[a-z0-9\\-][\\.a-z0-9\\-]*"
#define ALD_RE_HOST_DOMAIN_NAME "[a-z0-9\\-]+%s"
public:
    CALDHostNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_HOST_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDDomainNameValidator: public CALDValidator
{
#define ALD_RE_DOMAIN_NAME "^\\.[a-z0-9\\-][a-z0-9\\-\\.]*"
public:
    CALDDomainNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_DOMAIN_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDDNSNameValidator: public CALDValidator
{
public:
    CALDDNSNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_DNS_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDHostFlagsValidator: public CALDValidator
{
#define ALD_RE_HOST_FLAGS "\\[P?C?F?D?\\]"
public:
    CALDHostFlagsValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_HOST_FLAGS, Core){}
    //  tag ignored, result ignored
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDSvcGroupNameValidator: public CALDValidator
{
#define ALD_RE_SGROUP_NAME "[A-Za-z][A-Za-z0-9\\_\\-\\ ]*"
public:
    CALDSvcGroupNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_SGROUP_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDHostGroupNameValidator: public CALDValidator
{
#define ALD_RE_HGROUP_NAME "[A-Za-z][A-Za-z0-9\\_\\-\\ ]*"
public:
    CALDHostGroupNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_HGROUP_NAME, Core){}
    //  tag ignored, result ignored
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
 
class CALDLogTemplateValidator: public CALDValidator
{
#define ALD_VALIDATOR_LOG_TEMPLATE       "LogTemplate"
public:
    CALDLogTemplateValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_LOG_TEMPLATE, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
class CALDDocNameValidator: public CALDValidator
{
public:
    CALDDocNameValidator(IALDCore &Core):CALDValidator(ALD_VALIDATOR_DOC_NAME, Core){}
    virtual bool Validate(const void *value, const void *tag, void *result);
};
 
void RegisterBaseValidators(IALDCore &Core);
 
bool UnparseHostName(IALDCore &Core, const string &host, const string &domain, string &fullname, string *perror);
bool ParseHostName(IALDCore &Core, const string &fullname, string &host, string &domain, string *perror);
 
 
void UpdatePrincipalInKeytab(CALDKadm5ConnPtr krb5, const string &keytab, const string &name, bool create);
 
string HostPrincipal(const string &name);
string UserToDN(const string &user, const string &base);
string DNToUser(const string &dn);
 
enum ALDServiceOperation {asoStop, asoStart, asoRestart, asoInstall, asoRemove, asoReload};
int ManageService(const string &service, ALDServiceOperation op, bool ignore = false);
// int ManageService(const string &service, const string &op, bool ignore = false);
 
int ExecCommand(const string &command, bool infinite = false);
int ExecCommandOut(const string &command, ald_string_list &outlist, bool infinite = false);
int ExecCommandInOut(const string &command, ald_string_list &outlist,
                     const ald_string_list &inlist, bool infinite = false);
 
void CheckValidExits(const string &command, const int exitcode, ald_int_list &validlist);
 
void RestartNSCD();
 
void InvalidateNSCD();
 
void CreateClientMountPoint(IALDCore &Core);
void UmountClientMountPoint(IALDCore &Core, const string &mode);
void MountClientMountPoint(IALDCore &Core, const string &mode);
 
void SetAllowTix(CALDKadm5ConnPtr &krb5, bool AllowTix);
 
void UpdateLifetimes(IALDCore &Core, CALDKadm5ConnPtr &krb5);
 
void FilterUserPrincipals(IALDCore &Core, ald_string_list &list);
 
void CheckConfigured(IALDCore &Core);
 
void CheckCompatibility(IALDCore &Core, const string &version);
 
string CannonicalizePrincipalName(IALDCore &Core, const string &name, const string &domain);
 
string SvcPrincipal(IALDCore &Core, const string &svc, const string &host = "", const string &realm = "");
 
string LifetimeToStr(unsigned int ltime);
 
void UseCommonCommand(IALDCore &Core, const string &cmd);
 
// serialization
string princ2str(const CALDKrbPrincipalPtr &princ);
CALDKrbPrincipalPtr str2princ(const string &name, const string &body);
 
string policy2str(const CALDKrbPolicyPtr &policy);
CALDKrbPolicyPtr str2policy(const string &name, const string &body);
 
// recheck ALD server name
bool GetActiveALDServerName(IALDCore& Core, const string& domain, string& dc);
 
 
void SetCounter(string &name, int value);
 
int GetCounter(string &name);
 
int IncrementCounter(string &name, int increment);
 
bool ReConfigureSSSD(IALDCore *pCore, CALDConnectionPtr conn);
 
void UnConfigureSSSD(IALDCore *pCore);
 
} // ALD
 
#endif // ALD_CORE_UTILS