(file) Return to UserFileHandler.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Security / UserManager

Diff for /pegasus/src/Pegasus/Security/UserManager/UserFileHandler.cpp between version 1.5 and 1.24

version 1.5, 2002/06/03 19:32:35 version 1.24, 2007/07/31 19:13:50
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 21 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Sushma Fernandes, Hewlett Packard Company (sushma_fernandes@hp.com)  
 //  
 // Modified By:  
 //  
 //%//////////////////////////////////////////////////////////////////////////// //%////////////////////////////////////////////////////////////////////////////
  
  
Line 35 
Line 39 
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Destroyer.h>  
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/IPCExceptions.h>
  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
 #include <Pegasus/Security/UserManager/UserFileHandler.h> #include <Pegasus/Security/UserManager/UserFileHandler.h>
 #include <Pegasus/Security/UserManager/UserExceptions.h> #include <Pegasus/Security/UserManager/UserExceptions.h>
   #include <Pegasus/Common/MessageLoader.h>
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 75 
Line 80 
     System::getCurrentTime( sec, milliSec );     System::getCurrentTime( sec, milliSec );
  
     srand( (int) sec );     srand( (int) sec );
   #ifdef PEGASUS_PLATFORM_SOLARIS_SPARC
       Unit32 seed;
       randNum = rand_r(*seed);
   #else
     randNum = rand();     randNum = rand();
   #endif
  
     //     //
     // Make sure the random number generated is between 0-63.     // Make sure the random number generated is between 0-63.
Line 85 
Line 95 
     randNum >>= 6;     randNum >>= 6;
     *salt++ = _SALT_STRING[ randNum & 0x3f ];     *salt++ = _SALT_STRING[ randNum & 0x3f ];
  
     salt[2] = '\0';      *salt = '\0';
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 107 
Line 117 
     // Get the PasswordFilePath property from the Config Manager.     // Get the PasswordFilePath property from the Config Manager.
     //     //
     String passwdFile;     String passwdFile;
     passwdFile = configManager->getCurrentValue(      passwdFile = ConfigManager::getHomedPath(
                        _PROPERTY_NAME_PASSWORD_FILEPATH);          configManager->getCurrentValue(_PROPERTY_NAME_PASSWORD_FILEPATH));
  
     //     //
     // Construct a PasswordFile object.     // Construct a PasswordFile object.
     //     //
     _passwordFile   = new PasswordFile(passwdFile);      _passwordFile.reset(new PasswordFile(passwdFile));
  
     //     //
     // Load the user information in to the cache.     // Load the user information in to the cache.
     //     //
     try  
     {  
         _loadAllUsers();         _loadAllUsers();
     }  
     catch  (Exception& e)  
     {  
         throw e;  
     }  
  
     //     //
     // Initialize the mutex, mutex lock needs to be held for any updates     // Initialize the mutex, mutex lock needs to be held for any updates
     // to the password cache and password file.     // to the password cache and password file.
     //     //
     _mutex = new Mutex;      _mutex.reset(new Mutex);
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 144 
Line 147 
 { {
     PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserFileHandler::~UserFileHandler");     PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserFileHandler::~UserFileHandler");
  
     delete _passwordFile;  
     delete _mutex;  
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
Line 162 
Line 162 
         _passwordTable.clear();         _passwordTable.clear();
         _passwordFile->load(_passwordTable);         _passwordFile->load(_passwordTable);
     }     }
     catch (CannotOpenFile cof)      catch (CannotOpenFile&)
     {     {
         _passwordTable.clear();         _passwordTable.clear();
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw cof;          throw;
     }     }
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 186 
Line 186 
  
     try     try
     {     {
         _mutex->timed_lock(_MUTEX_TIMEOUT, pegasus_thread_self());          _mutex->timed_lock(_MUTEX_TIMEOUT);
     }  
     catch (TimeOut e)  
     {  
         throw CIMException( CIM_ERR_FAILED,  
         "Timed out trying to perform requested operation."  
         "Please re-try the operation again.");  
     }     }
     catch (WaitFailed e)      catch (TimeOut&)
     {     {
         throw CIMException( CIM_ERR_FAILED,          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
         "Timed out trying to perform requested operation."              MessageLoaderParms(
         "Please re-try the operation again.");                  "Security.UserManager.UserFileHandler.TIMEOUT",
     }                  "Timed out while attempting to perform the requested "
     catch (Deadlock e)                      "operation. Try the operation again."));
     {      }
         throw CIMException( CIM_ERR_FAILED,      catch (WaitFailed&)
         "Deak lock encountered trying to perform requested operation."      {
         "Please re-try the operation again.");          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
               MessageLoaderParms(
                   "Security.UserManager.UserFileHandler.TIMEOUT",
                   "Timed out while attempting to perform the requested "
                       "operation. Try the operation again."));
       }
       catch (Deadlock&)
       {
           throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
               MessageLoaderParms(
                   "Security.UserManager.UserFileHandler.DEADLOCK",
                   "Deadlock encountered while attempting to perform the "
                       "requested operation.  Try the operation again."));
     }     }
  
     switch (operation)     switch (operation)
Line 228 
Line 234 
                 if (!_passwordTable.insert(userName,password))                 if (!_passwordTable.insert(userName,password))
                 {                 {
                     _mutex->unlock();                     _mutex->unlock();
                     Logger::put(Logger::ERROR_LOG, "UserManager",                      Logger::put_l(
                         Logger::SEVERE,                          Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                         "Error updating user information for : $0.",userName);                          "Security.UserManager.UserFileHandler."
                               "ERROR_UPDATING_USER_INFO",
                           "Error updating the user information for user $0.",
                           userName);
                     PEG_METHOD_EXIT();                     PEG_METHOD_EXIT();
                     throw PasswordCacheError();                     throw PasswordCacheError();
                 }                 }
Line 257 
Line 266 
     {     {
         _passwordFile->save(_passwordTable);         _passwordFile->save(_passwordTable);
     }     }
     catch (CannotOpenFile& e)      catch (const CannotOpenFile&)
     {     {
         _mutex->unlock();         _mutex->unlock();
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw e;          throw;
     }     }
     catch (CannotRenameFile& e)      catch (const CannotRenameFile&)
     {     {
         //         //
         // reload password hash table from file         // reload password hash table from file
Line 272 
Line 281 
  
         _mutex->unlock();         _mutex->unlock();
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw e;          throw;
     }     }
     _mutex->unlock();     _mutex->unlock();
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 287 
Line 296 
                             const String& password)                             const String& password)
 { {
     char        salt[3];     char        salt[3];
     String      encryptedPassword = String::EMPTY;      String encryptedPassword;
  
     PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserFileHandler::addUserEntry");     PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserFileHandler::addUserEntry");
  
Line 301 
Line 310 
     // encrypt password     // encrypt password
     _GetSalt(salt);     _GetSalt(salt);
  
     ArrayDestroyer<char> pw(password.allocateCString());      encryptedPassword = System::encryptPassword(password.getCString(),salt);
   
     encryptedPassword = System::encryptPassword(pw.getPointer(),salt);  
  
     // add the user to the cache and password file     // add the user to the cache and password file
     _Update(ADD_USER,userName, encryptedPassword);     _Update(ADD_USER,userName, encryptedPassword);
Line 320 
Line 327 
              const String& newPassword )              const String& newPassword )
 { {
     char        salt[3];     char        salt[3];
     String      encryptedPassword = String::EMPTY;      String encryptedPassword;
  
     PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserFileHandler::modifyUserEntry");     PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserFileHandler::modifyUserEntry");
  
     //     //
     // Check if the given password matches the passwd in the file     // Check if the given password matches the passwd in the file
     //     //
     try  
     {  
         if ( !verifyCIMUserPassword (userName,password) )         if ( !verifyCIMUserPassword (userName,password) )
         {         {
             PEG_METHOD_EXIT();             PEG_METHOD_EXIT();
             throw PasswordMismatch(userName);             throw PasswordMismatch(userName);
         }         }
     }  
     catch (Exception& e)  
     {  
         PEG_METHOD_EXIT();  
         throw e;  
     }  
  
     // encrypt new password     // encrypt new password
     _GetSalt(salt);     _GetSalt(salt);
  
     ArrayDestroyer<char> npw(newPassword.allocateCString());      encryptedPassword = System::encryptPassword(newPassword.getCString(),salt);
   
     encryptedPassword = System::encryptPassword(npw.getPointer(),salt);  
  
     _Update(MODIFY_USER, userName, encryptedPassword);     _Update(MODIFY_USER, userName, encryptedPassword);
  
Line 403 
Line 400 
                      "UserFileHandler::verifyCIMUserPassword");                      "UserFileHandler::verifyCIMUserPassword");
  
     // Check if the user's password mathches the specified password     // Check if the user's password mathches the specified password
     String curPassword          = String::EMPTY;      String curPassword;
     String encryptedPassword    = String::EMPTY;      String encryptedPassword;
     String saltStr              = String::EMPTY;      String saltStr;
  
     // Check if the user exists in the password table     // Check if the user exists in the password table
     if ( !_passwordTable.lookup(userName,curPassword) )     if ( !_passwordTable.lookup(userName,curPassword) )
Line 415 
Line 412 
     }     }
  
     saltStr = curPassword.subString(0,2);     saltStr = curPassword.subString(0,2);
     ArrayDestroyer<char> oldsalt(saltStr.allocateCString());  
     ArrayDestroyer<char> pw(password.allocateCString());  
  
     encryptedPassword =     encryptedPassword =
                 System::encryptPassword(pw.getPointer(),oldsalt.getPointer());          System::encryptPassword(password.getCString(),saltStr.getCString());
  
     if ( curPassword != encryptedPassword )     if ( curPassword != encryptedPassword )
     {     {


Legend:
Removed from v.1.5  
changed lines
  Added in v.1.24

No CVS admin address has been configured
Powered by
ViewCVS 0.9.2