(file) Return to AuditLogger.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/AuditLogger.cpp between version 1.6 and 1.16

version 1.6, 2006/10/25 22:14:36 version 1.16, 2007/09/12 21:30:58
Line 34 
Line 34 
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/Formatter.h>  #include <Pegasus/Common/AuditLogger.h>
 #include <Pegasus/Common/CIMPropertyList.h>  
 #include <Pegasus/Common/InternalException.h>  #ifdef PEGASUS_OS_DARWIN
   # include <crt_externs.h>
   #endif
  
 #ifndef PEGASUS_OS_TYPE_WINDOWS #ifndef PEGASUS_OS_TYPE_WINDOWS
 # include <unistd.h> # include <unistd.h>
 #endif #endif
  
 #include <stdlib.h>  #ifdef PEGASUS_OS_VMS
   # include <unixlib.h>
 #ifndef PEGASUS_DISABLE_AUDIT_LOGGER  #endif
  
 #include <Pegasus/Common/AuditLogger.h>  #include <stdlib.h>
  
 extern char ** environ;  #ifdef PEGASUS_ENABLE_AUDIT_LOGGER
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 static const String providerModuleStatus [] = {"Unknown", "Other", "OK", "Degraded",  static const String providerModuleStatus [] = {
       "Unknown", "Other", "OK", "Degraded",
     "Stressed", "Predictive Failure", "Error", "Non-Recoverable Error",     "Stressed", "Predictive Failure", "Error", "Non-Recoverable Error",
     "Starting", "Stopping", "Stopped", "In Service", "No Contact",     "Starting", "Stopping", "Stopped", "In Service", "No Contact",
     "Lost Communication"};     "Lost Communication"};
  
 Boolean AuditLogger::_auditLogFlag = false; Boolean AuditLogger::_auditLogFlag = false;
  
 AuditLogger::PEGASUS_AUDITLOGINITIALIZE_CALLBACK_T AuditLogger::_auditLogInitializeCallback;  AuditLogger::PEGASUS_AUDITLOGINITIALIZE_CALLBACK_T
       AuditLogger::_auditLogInitializeCallback = 0;
  
 AuditLogger::PEGASUS_AUDITLOG_CALLBACK_T AuditLogger::_writeAuditMessageToFile = AuditLogger::PEGASUS_AUDITLOG_CALLBACK_T AuditLogger::_writeAuditMessageToFile =
     AuditLogger::_writeAuditMessage;     AuditLogger::_writeAuditMessage;
Line 70 
Line 74 
     const Array<String> & propertyNames,     const Array<String> & propertyNames,
     const Array<String> & propertyValues)     const Array<String> & propertyValues)
 { {
     String properties;  
   
     for (Uint32 i = 0; i < propertyNames.size(); i++)     for (Uint32 i = 0; i < propertyNames.size(); i++)
     {     {
         properties.append(propertyNames[i]);          String propertyStr = propertyNames[i] + "=" + propertyValues[i];
         properties.append("=");  
         properties.append(propertyValues[i]);  
         properties.append("\n");  
     }  
  
     MessageLoaderParms msgParms("Common.AuditLogger.CURRENT_CONFIG",     MessageLoaderParms msgParms("Common.AuditLogger.CURRENT_CONFIG",
        "The current configuration properties are:\n$0", properties);              "cimserver configuration $0", propertyStr);
  
     _writeAuditMessageToFile(TYPE_CONFIGURATION,     _writeAuditMessageToFile(TYPE_CONFIGURATION,
         SUBTYPE_CURRENT_CONFIGURATION,         SUBTYPE_CURRENT_CONFIGURATION,
         EVENT_START_UP, Logger::INFORMATION, msgParms);         EVENT_START_UP, Logger::INFORMATION, msgParms);
       }
 } }
  
 void AuditLogger::logCurrentRegProvider( void AuditLogger::logCurrentRegProvider(
     const Array < CIMInstance > & instances)     const Array < CIMInstance > & instances)
 { {
     String moduleName, registeredModules;      String moduleName;
     Array<Uint16> moduleStatus;     Array<Uint16> moduleStatus;
     String statusValue;     String statusValue;
     Uint32 pos;     Uint32 pos;
Line 103 
Line 101 
         instances[i].getProperty(instances[i].findProperty(         instances[i].getProperty(instances[i].findProperty(
             _PROPERTY_PROVIDERMODULE_NAME)).getValue().get(moduleName);             _PROPERTY_PROVIDERMODULE_NAME)).getValue().get(moduleName);
  
         registeredModules.append(moduleName);  
         registeredModules.append("=");  
   
         pos = instances[i].findProperty(_PROPERTY_OPERATIONALSTATUS);         pos = instances[i].findProperty(_PROPERTY_OPERATIONALSTATUS);
  
         if (pos == PEG_NOT_FOUND)         if (pos == PEG_NOT_FOUND)
Line 128 
Line 123 
  
         statusValue = _getModuleStatusValue(moduleStatus);         statusValue = _getModuleStatusValue(moduleStatus);
  
         registeredModules.append(statusValue);  
         registeredModules.append("\n");  
     }  
   
     MessageLoaderParms msgParms(     MessageLoaderParms msgParms(
         "Common.AuditLogger.CURRENT_PROVIDER_REGISTRATION",         "Common.AuditLogger.CURRENT_PROVIDER_REGISTRATION",
         "The current registered provider modules are:\n$0", registeredModules);              "Provider module \"$0\" has status \"$1\".",
               moduleName, statusValue);
  
     _writeAuditMessageToFile(TYPE_CONFIGURATION,     _writeAuditMessageToFile(TYPE_CONFIGURATION,
         SUBTYPE_CURRENT_PROVIDER_REGISTRATION,         SUBTYPE_CURRENT_PROVIDER_REGISTRATION,
         EVENT_START_UP, Logger::INFORMATION, msgParms);         EVENT_START_UP, Logger::INFORMATION, msgParms);
 } }
   }
  
 void AuditLogger::logCurrentEnvironmentVar() void AuditLogger::logCurrentEnvironmentVar()
 { {
   #ifdef PEGASUS_OS_DARWIN
     String envList;      char** envp = *_NSGetEnviron();
   #else
     char ** envp = environ;     char ** envp = environ;
   #endif
  
     Uint32 i = 0;     Uint32 i = 0;
  
     while (envp[i])     while (envp[i])
     {     {
         envList.append(envp[i]);  
         envList.append("\n");  
   
         i++;  
     }  
   
     MessageLoaderParms msgParms("Common.AuditLogger.CURRENT_ENV",     MessageLoaderParms msgParms("Common.AuditLogger.CURRENT_ENV",
        "The current environment variables are:\n$0", envList);             "cimserver environment variable: $0", envp[i]);
  
     _writeAuditMessageToFile(TYPE_CONFIGURATION,     _writeAuditMessageToFile(TYPE_CONFIGURATION,
         SUBTYPE_CURRENT_ENVIRONMENT_VARIABLES,         SUBTYPE_CURRENT_ENVIRONMENT_VARIABLES,
         EVENT_START_UP, Logger::INFORMATION, msgParms);         EVENT_START_UP, Logger::INFORMATION, msgParms);
   
           i++;
       }
 } }
  
 void AuditLogger::logSetConfigProperty( void AuditLogger::logSetConfigProperty(
Line 349 
Line 341 
     }     }
 } }
  
   void AuditLogger::logUpdateProvModuleStatus(
       const String & moduleName,
       const Array<Uint16> currentModuleStatus,
       const Array<Uint16> newModuleStatus)
   {
       String currentModuleStatusValue =
           _getModuleStatusValue(currentModuleStatus);
   
       String newModuleStatusValue = _getModuleStatusValue(newModuleStatus);
   
       MessageLoaderParms msgParms(
           "Common.AuditLogger.UPDATE_PROVIDER_MODULE_STATUS",
           "The operational status of module \"$0\" has changed from \"$1\""
           " to \"$2\".",
           moduleName, currentModuleStatusValue, newModuleStatusValue);
   
       _writeAuditMessageToFile(TYPE_CONFIGURATION,
           SUBTYPE_PROVIDER_MODULE_STATUS_CHANGE,
           EVENT_UPDATE, Logger::INFORMATION, msgParms);
   }
   
   void AuditLogger::logLocalAuthentication(
       const String& userName,
       Boolean successful)
   {
       MessageLoaderParms msgParms(
           "Common.AuditLogger.LOCAL_AUTHENTICATION",
           "Local authentication attempt: "
           "successful = $0, user = $1. ",
           CIMValue(successful).toString(),
           userName);
   
       _writeAuditMessageToFile(
           TYPE_AUTHENTICATION,
           SUBTYPE_LOCAL_AUTHENTICATION,
           successful ? EVENT_AUTH_SUCCESS : EVENT_AUTH_FAILURE,
           successful ? Logger::INFORMATION : Logger::WARNING,
           msgParms);
   }
   
   void AuditLogger::logBasicAuthentication(
       const String& userName,
       const String& ipAddr,
       Boolean successful)
   {
       MessageLoaderParms msgParms(
           "Common.AuditLogger.BASIC_AUTHENTICATION",
           "Basic authentication attempt: "
           "successful = $0, user = $1, IP address = $2.",
           CIMValue(successful).toString(),
           userName,
           ipAddr);
   
       _writeAuditMessageToFile( TYPE_AUTHENTICATION,
           SUBTYPE_BASIC_AUTHENTICATION,
           successful ? EVENT_AUTH_SUCCESS : EVENT_AUTH_FAILURE,
           successful ? Logger::INFORMATION: Logger::WARNING,
           msgParms);
   }
   
   void AuditLogger::logCertificateBasedAuthentication(
       const String& issuerName,
       const String& subjectName,
       const String& serialNumber,
       const String& ipAddr,
       Boolean successful)
   {
       MessageLoaderParms msgParms(
           "Common.AuditLogger.CERTIFICATE_BASED_AUTHENTICATION",
           "Certificate based authentication attempt: "
               "successful = $0, issuer = $1, subject = $2, serialNumber = $3, "
               "IP address = $4.",
           CIMValue(successful).toString(),
           issuerName,
           subjectName,
           serialNumber,
           ipAddr);
   
       _writeAuditMessageToFile(TYPE_AUTHENTICATION,
           SUBTYPE_CERTIFICATE_BASED_AUTHENTICATION,
           successful ? EVENT_AUTH_SUCCESS : EVENT_AUTH_FAILURE,
           successful ? Logger::INFORMATION: Logger::WARNING,
           msgParms);
   }
   
   void AuditLogger::logCertificateBasedUserValidation(
       const String& userName,
       const String& issuerName,
       const String& subjectName,
       const String& serialNumber,
       const String& ipAddr,
       Boolean successful)
   {
       MessageLoaderParms msgParms(
           "Common.AuditLogger.CERTIFICATE_BASED_USER_VALIDATION",
           "Certificate based user validation attempt: "
               "successful = $0, userName = $1, issuer = $2, subject = $3, "
               "serialNumber = $4, IP address = $5.",
           CIMValue(successful).toString(),
           userName,
           issuerName,
           subjectName,
           serialNumber,
           ipAddr);
   
       _writeAuditMessageToFile( TYPE_AUTHORIZATION,
           SUBTYPE_CERTIFICATE_BASED_USER_VALIDATION,
           successful ? EVENT_AUTH_SUCCESS : EVENT_AUTH_FAILURE,
           successful ? Logger::INFORMATION: Logger::WARNING,
           msgParms);
   }
   
 void AuditLogger::setInitializeCallback( void AuditLogger::setInitializeCallback(
     PEGASUS_AUDITLOGINITIALIZE_CALLBACK_T auditLogInitializeCallback)     PEGASUS_AUDITLOGINITIALIZE_CALLBACK_T auditLogInitializeCallback)
 { {
Line 357 
Line 461 
  
 void AuditLogger::setEnabled(Boolean enabled) void AuditLogger::setEnabled(Boolean enabled)
 { {
       // Only write the enable/disable messages if we are set up to handle them
       if (_auditLogInitializeCallback != 0)
       {
     if (enabled)     if (enabled)
     {     {
         if (!_auditLogFlag)         if (!_auditLogFlag)
         {         {
             _auditLogInitializeCallback();             _auditLogInitializeCallback();
   
                   MessageLoaderParms msgParms(
                       "Common.AuditLogger.ENABLE_AUDIT_LOG",
                       "Audit logging is enabled.");
   
                   _writeAuditMessageToFile(TYPE_CONFIGURATION,
                       SUBTYPE_CONFIGURATION_CHANGE,
                       EVENT_UPDATE, Logger::INFORMATION, msgParms);
         }         }
     }     }
     else     else
Line 377 
Line 492 
                 EVENT_UPDATE, Logger::INFORMATION, msgParms);                 EVENT_UPDATE, Logger::INFORMATION, msgParms);
         }         }
     }     }
       }
  
     _auditLogFlag = enabled;     _auditLogFlag = enabled;
 } }
Line 396 
Line 512 
 { {
     String localizedMsg = MessageLoader::getMessage(msgParms);     String localizedMsg = MessageLoader::getMessage(msgParms);
  
     String identifier = "CIM Server Audit";      String identifier = "cimserver audit";
  
     Logger::put(Logger::AUDIT_LOG, identifier, logLevel, localizedMsg);     Logger::put(Logger::AUDIT_LOG, identifier, logLevel, localizedMsg);
 } }
Line 418 
Line 534 
         }         }
     }     }
  
     return (moduleStatusValue);      return moduleStatusValue;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.16
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2