base_classes.h

Go to the documentation of this file.

/* IBM Source Code */
/* (C) Copyright IBM Corp. 2009, 2012 */
/* Licensed Materials - Property of IBM */
/* US Government Users Restricted Rights - Use duplication or disclosure restricted by GSA Schedule Contract with IBM Corp. */
 
#ifndef BASE_CLASSES_H
#define BASE_CLASSES_H
 
#include <string>
#include <map>
 
namespace dca {
 
        extern const int ERR_NOT_INITIALIZED;
        extern const int ERR_CREATION;
        extern const int ERR_PARAMS;
        extern const int ERR_CONNECTION;
        extern const int ERR_CONNECTION_PROXY;
        extern const int ERR_CONNECTION_TIMEOUT;
        extern const int ERR_MEMORY_SHORTAGE;
        extern const int ERR_SIG_ABORT_DETECTED;
        extern const int ERR_NOT_LICENSED;
        extern const int ERR_UNEXPECTED;
        extern const int ERR_WRAPPER_UNEXPECTED;
 
        class ExDca;
        class funcresult_p;
 
        class FunctionResult
        {
        public:
                FunctionResult();
                FunctionResult( const ExDca& aExDca );
                FunctionResult( const FunctionResult& rhi );
                FunctionResult& operator = ( const FunctionResult& rhi );
                virtual ~FunctionResult();
 
                void setReturnCode( DCA_RESULT_TYPE value );
 
                operator bool() const;
 
                std::string getDescription() const;
 
                DCA_RESULT_TYPE getReturnCode() const;
 
                PRIVATE_PTR funcresult_p *_p;
        };
 
        class exdca_p;
        class FunctionResult;
 
 
        enum LogLevel {
           LOG_Initial          = -1,   
           LOG_Critical         = 0,    
           LOG_Error            = 1,    
           LOG_Warning          = 2,    
           LOG_Notice           = 3,    
           LOG_Info                     = 4,    
           LOG_Extensive        = 5,    
           LOG_Debug            = 6             
        };
 
        class ExDca
        {
        public:
                ExDca();
                ExDca( const ExDca& rhi );
                ExDca& operator = ( const ExDca& rhi );
                virtual ~ExDca() throw();
 
                std::string getDescription() const throw();
 
                DCA_RESULT_TYPE getReturnCode() const;
 
                PRIVATE_PTR exdca_p *_p;
        };
 
        struct InitData {
                std::string binDir;             
                std::string initDir;    
                std::string logDir;             
        };
 
        struct ProxySettings {
                ProxySettings();
 
                std::string user;                       
                std::string password;           
                std::string proxyServer;        
                unsigned int proxyPort;         
        };
 
        struct LicenseData;
        class License;
        struct DbConnectionData;
        class DbConnection;
        class UpdateModule;
        class CategoriesInfo;
        class ScheduleEventSubscriberIntf;
        class dcainst_p;
        
        class DcaInstance
        {
        public:
 
                static DcaInstance create( const InitData& initData );
 
                DcaInstance();
                DcaInstance( const DcaInstance& aDcaInstance );
                DcaInstance& operator = ( const DcaInstance& aDcaInstance );
                virtual ~DcaInstance();
 
                FunctionResult setDefaultProxySettings( const ProxySettings& newProxySettings );
 
                License createLicense( const LicenseData& licData, const ProxySettings& proxySettings = ProxySettings(), LogLevel aLogLevel = LOG_Initial ) const;
 
                DbConnection createDbConnection( const License& aLicense, const DbConnectionData& dbcData, const ProxySettings& proxySettings = ProxySettings(), LogLevel aLogLevel = LOG_Initial ) const;
 
                CategoriesInfo getCategoriesInfo( DCA_CATEGORIES_INFO_TYPE categoryType ) const;
 
                
                VersionInfoResults getVersionInfo() const;
        
                bool signal( unsigned int signal ) const;
 
                FunctionResult schedule( ScheduleEventSubscriberIntf* pScheduleEventSubscriber = NULL ) const;
 
                PRIVATE_PTR dcainst_p *_p;
        };
 
        enum ScheduleActionType
        {
                SAT_StartDbDownload = 0,        
                SAT_ProgressDbDownload,         
                SAT_StopDbDownload,                     
                SAT_ErrorDbDownload,            
                SAT_StartDbMerge,                       
                SAT_StopDbMerge,                        
                SAT_ErrorDbMerge,                       
                SAT_UserCancel,                         
        };
 
        enum ScheduleModuleId
        {
                SMI_UrlDb = 0,  
                SMI_MailDb,             
                SMI_CustomDb,   
                SMI_WacDb,              
                SMI_IprDb,              
                SMI_MalwareDb   
        };
 
        class ScheduleEventSubscriberIntf {
        public:
                virtual ~ScheduleEventSubscriberIntf() {}
                
                virtual void onEvent( ScheduleActionType actionType, ScheduleModuleId moduleId, const std::string& version, const std::string& text ) = 0;
        };
 
        struct LicenseData
        {
                std::string ticket;                             
                std::string product;                    
        };
 
        class license_p;
 
        class License
        {
        public:
                License();
                License( const License& aLicense );
                License& operator = ( const License& aLicense );
                virtual ~License();
 
                bool isLicensed( DCA_MODULE_ID_TYPE id = 0, bool force = false ) const;
 
                int getMaxSessions() const;
 
                int getMaxUsers() const;
 
                LogLevel setLogLevel( LogLevel newLevel );
 
                std::string getTicket() const;
 
                std::string getSession() const;
                
                bool getCustomData( std::string& customData ) const;
 
                time_t getExpirationDate() const;
 
                std::string getLastMessage() const;
 
                PRIVATE_PTR license_p *_p;
        };
 
        struct DbConnectionLocalData {
                DbConnectionLocalData();
                unsigned int dbUpdateIntervalMinutes;   
                time_t           dbUpdateStartLocalTime;        
        };
 
        struct DbConnectionCustomData {
                DbConnectionCustomData();
 
                unsigned int cacheMaxEntries;                            
                unsigned int cacheEntryExpirationMinutes;        
                unsigned int updateFileWriteIntervalMinutes;
                unsigned int dbUpdateIntervalMinutes;            
                time_t dbUpdateStartLocalTime;                          
                std::string configDir;                                           
                unsigned int updateFileWriteMaxEntries;
        };
 
        struct DbConnectionRemoteServerData {
                DbConnectionRemoteServerData();
                std::string encryptionData;             
                unsigned int encryptionKey;             
        };
 
        extern const DbType DBT_Url; 
        extern const DbType DBT_Mail;
        extern const DbType DBT_Custom;         
 
        struct DbConnectionData {
                DbConnectionData();
 
                DbType dbType;                                          
                bool useLocalDatabase;                          
                DbConnectionLocalData localData;        
                DbConnectionCustomData customData;      
                DbConnectionRemoteServerData remoteServerData; 
        };
 
        struct DatabaseInformation {
                DatabaseInformation();
                unsigned int majorVersion;              
                unsigned int minorVersion;              
                std::string versionString;              
                std::string creationDateUTC;    
        };
 
        class dbconnection_p;
 
        class DbConnection
        {
        public:
                DbConnection();
                DbConnection( const DbConnection& aDbConnection );
                DbConnection& operator = ( const DbConnection& aDbConnection );
                virtual ~DbConnection();
 
                std::string getDatabaseVersion() const;
 
                DatabaseInformation getDatabaseInformation() const;
 
                LogLevel setLogLevel( LogLevel newLevel );
 
                PRIVATE_PTR dbconnection_p *_p;
        };
 
        class updatemodule_p;
        class UpdateResults;
 
        class UpdateModule
        {
        public:
                static DCA_MODULE_ID_TYPE ID;
 
                static UpdateModule create( const DcaInstance& aDcaInstance, const License& aLicense,
                        const ProxySettings& proxySettings = ProxySettings() );
 
                UpdateModule();
                UpdateModule( const UpdateModule& );
                UpdateModule& operator = ( const UpdateModule& );
                virtual ~UpdateModule();
 
                FunctionResult performUpdate( bool force, UpdateResults& results ) const;
                bool cancelUpdate() const;
 
 
                LogLevel setLogLevel( LogLevel newLevel );
 
                PRIVATE_PTR updatemodule_p *_p;
        };
 
        class UpdateResult;
        class updateresults_p;
 
        class UpdateResults
        {
        public:
                UpdateResults();
                UpdateResults( const UpdateResults& );
                UpdateResults& operator = ( const UpdateResults& );
                virtual ~UpdateResults();
 
                UpdateResult at( DCA_INDEX_TYPE index ) const;
                UpdateResult operator [] ( DCA_INDEX_TYPE index ) const;
                DCA_SIZE_TYPE size() const;
 
                bool restartRequired() const;
 
                PRIVATE_PTR updateresults_p *_p;
        };
 
        class updateresult_p;
        class UpdateResultDetail;
 
        class UpdateResult
        {
        public:
                UpdateResult();
                UpdateResult( const UpdateResult& );
                UpdateResult& operator = ( const UpdateResult& );
                virtual ~UpdateResult();
 
                UpdateResultDetail at( DCA_INDEX_TYPE index ) const;
                UpdateResultDetail operator [] ( DCA_INDEX_TYPE index ) const;
                DCA_SIZE_TYPE size() const;
 
                std::string name() const;
 
                DCA_MODULE_ID_TYPE id() const;
                bool contentUpdated() const;
                bool engineUpdated() const;
 
                PRIVATE_PTR updateresult_p *_p;
        };
 
        class updateresult_detail_p;
 
        class UpdateResultDetail
        {
        public:
                UpdateResultDetail();
                UpdateResultDetail( const UpdateResultDetail& );
                UpdateResultDetail& operator = ( const UpdateResultDetail& );
                virtual ~UpdateResultDetail();
 
                std::string component() const;
                std::string oldVersion() const;
                std::string newVersion() const;
                bool available() const;
                bool downloaded() const;
                bool installed() const;
                int returnCode() const;
 
                PRIVATE_PTR updateresult_detail_p *_p;
        };
 
        // Error codes of this package
 
        extern const int ERR_INVALID_DATABASE;
 
        extern const int ERR_INVALID_FOLDER;
 
        extern const int ERR_INVALID_XML_FILES;
 
        extern const int ERR_DB_UPDATE_ABORTED;
 
        extern const int ERR_DB_DOWNLOAD_ABORTED;
 
        extern const int ERR_DATABASE_ALREADY_EXISTING;
 
        extern const int ERR_URL_INVALID;
        
        extern const int ERR_URL_UNSUPPORTED_PROTOCOL;
 
        extern const int ERR_CUSTOMDB_INVALID_CATEGORIES;
 
        extern const int DCA_SUCCESS;
 
        extern const unsigned int DCA_SIG_ABORT;
 
        extern const int DCA_UPDATE_DOWNLOAD_SCHEDULED;
}
 
#endif