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

  1 karl  1.14 //%2005////////////////////////////////////////////////////////////////////////
  2 mike  1.2  //
  3 karl  1.13 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
  4            // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
  5            // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
  6 karl  1.11 // IBM Corp.; EMC Corporation, The Open Group.
  7 karl  1.13 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
  8            // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
  9 karl  1.14 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 10            // EMC Corporation; VERITAS Software Corporation; The Open Group.
 11 mike  1.2  //
 12            // Permission is hereby granted, free of charge, to any person obtaining a copy
 13 kumpf 1.8  // of this software and associated documentation files (the "Software"), to
 14            // deal in the Software without restriction, including without limitation the
 15            // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 16 mike  1.2  // sell copies of the Software, and to permit persons to whom the Software is
 17            // furnished to do so, subject to the following conditions:
 18            // 
 19 kumpf 1.8  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 20 mike  1.2  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 21            // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 22 kumpf 1.8  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 23            // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 24            // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 25 mike  1.2  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 26            // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 27            //
 28 kumpf 1.8  //==============================================================================
 29 mike  1.2  //
 30            // Author: Sushma Fernandes, Hewlett Packard Company (sushma_fernandes@hp.com)
 31            //
 32            // Modified By: Nag Boranna, Hewlett Packard Company (nagaraja_boranna@hp.com)
 33 kumpf 1.10 //              Carol Ann Krug Graves, Hewlett-Packard Company
 34            //                (carolann_graves@hp.com)
 35 a.arora 1.12 //              Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
 36 mike    1.2  //
 37              //%////////////////////////////////////////////////////////////////////////////
 38              
 39              
 40              ///////////////////////////////////////////////////////////////////////////////
 41              // 
 42              // User Manager
 43              //
 44              ///////////////////////////////////////////////////////////////////////////////
 45              
 46              #include <Pegasus/Common/System.h>
 47              #include <Pegasus/Common/Tracer.h>
 48 kumpf   1.6  #include <Pegasus/Common/PegasusVersion.h>
 49              
 50 mike    1.2  #include <Pegasus/Security/UserManager/UserManager.h>
 51              #include <Pegasus/Security/UserManager/UserExceptions.h>
 52              
 53              
 54              PEGASUS_USING_STD;
 55              
 56              PEGASUS_NAMESPACE_BEGIN
 57              
 58              /**
 59              Initialize UserManager instance
 60              */
 61              UserManager* UserManager::_instance = 0;
 62              
 63              //
 64              // Constructor
 65              //
 66              UserManager::UserManager(CIMRepository* repository)
 67              {
 68 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::UserManager");
 69 a.arora 1.12           
 70 kumpf   1.7  #ifndef PEGASUS_NO_PASSWORDFILE
 71 a.arora 1.12     _userFileHandler.reset(new UserFileHandler());
 72 kumpf   1.7  #endif
 73 a.arora 1.12     _authHandler.reset(new AuthorizationHandler(repository));
 74                  
 75 kumpf   1.5      PEG_METHOD_EXIT();
 76 mike    1.2  }
 77              
 78              //
 79              // Destructor
 80              //
 81              UserManager::~UserManager()
 82              {
 83 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::~UserManager");
 84 mike    1.2  
 85 kumpf   1.5      PEG_METHOD_EXIT();
 86 mike    1.2  }
 87              
 88              //
 89              // Construct the singleton instance of the UserManager and return a
 90              // pointer to that instance.
 91              //
 92              UserManager* UserManager::getInstance(CIMRepository* repository)
 93              {
 94 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::getInstance");
 95 mike    1.2  
 96 kumpf   1.5      if (!_instance && !repository)
 97                  {
 98                      PEG_METHOD_EXIT();
 99                      throw CannotCreateUserManagerInstance();
100                  }
101 mike    1.2  
102 kumpf   1.4      if (!_instance)
103 mike    1.2      {
104                      _instance = new UserManager(repository);
105                  }
106              
107 kumpf   1.5      PEG_METHOD_EXIT();
108 mike    1.2  
109                  return _instance;
110              }
111              
112              // 
113              // Add a user
114              //
115              void UserManager::addUser(const String& userName, const String& password)
116              {
117 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::addUser");
118 mike    1.2  
119 kumpf   1.7  #ifndef PEGASUS_NO_PASSWORDFILE
120 mike    1.2      //
121                  // Check if the user is a valid system user
122                  //
123 kumpf   1.9      if ( !System::isSystemUser( userName.getCString() ) )
124 mike    1.2      {
125 kumpf   1.5          PEG_METHOD_EXIT();
126 mike    1.2  	throw InvalidSystemUser(userName); 
127                  }
128              
129                  // 
130                  // Add the user to the password file
131                  //
132                  try
133                  {
134                      _userFileHandler->addUserEntry(userName,password);
135                  }
136                  catch (Exception& e)
137                  {
138 kumpf   1.5          PEG_METHOD_EXIT();
139 mike    1.2  	throw e;
140                  }
141 kumpf   1.7  #endif
142 mike    1.2  
143 kumpf   1.5      PEG_METHOD_EXIT();
144 mike    1.2  }
145              
146              //
147              // Modify user's password
148              //
149              void UserManager::modifyUser(
150                             const String& userName,
151              	       const String& password,
152              	       const String& newPassword )
153              {
154 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::modifyUser");
155 mike    1.2  
156 kumpf   1.7  #ifndef PEGASUS_NO_PASSWORDFILE
157 mike    1.2      try
158                  {
159                      _userFileHandler->modifyUserEntry(userName, password, newPassword);
160                  }
161                  catch (Exception& e)
162                  {
163 kumpf   1.5          PEG_METHOD_EXIT();
164 mike    1.2  	throw e;
165                  }
166 kumpf   1.7  #endif
167              
168 kumpf   1.5      PEG_METHOD_EXIT();
169 mike    1.2  }
170              
171              // 
172              // Remove a user
173              //
174              void UserManager::removeUser(const String& userName)
175              {
176 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::removeUser");
177 kumpf   1.7  
178              #ifndef PEGASUS_NO_PASSWORDFILE
179 mike    1.2      try
180                  {
181                      _userFileHandler->removeUserEntry(userName);
182                  }
183                  catch (Exception& e)
184                  {
185 kumpf   1.5          PEG_METHOD_EXIT();
186 mike    1.2  	throw e;
187                  }
188 kumpf   1.7  #endif
189 mike    1.2  
190 kumpf   1.5      PEG_METHOD_EXIT();
191 mike    1.2  }
192              
193              
194              //
195              // Get a list of all the user names.
196              //
197              void UserManager::getAllUserNames(Array<String>& userNames)
198              {
199 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::getAllUserNames");
200 mike    1.2  
201 kumpf   1.7  #ifndef PEGASUS_NO_PASSWORDFILE
202 mike    1.2      try
203                  {
204                      _userFileHandler->getAllUserNames( userNames );
205 kumpf   1.5          PEG_METHOD_EXIT();
206 mike    1.2      }
207                  catch (Exception& e)
208                  {
209              	throw e;
210                  }
211 kumpf   1.7  #endif
212 mike    1.2  
213 kumpf   1.5      PEG_METHOD_EXIT();
214 mike    1.2  }
215              
216              //
217              // Verify whether the specified CIM user is valid
218              //
219              Boolean UserManager::verifyCIMUser (const String& userName)
220              {
221 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::verifyCIMUser");
222 mike    1.2  
223 kumpf   1.7  #ifndef PEGASUS_NO_PASSWORDFILE
224 mike    1.2      try
225                  {
226                      if ( _userFileHandler->verifyCIMUser( userName ))
227              	{
228 kumpf   1.5              PEG_METHOD_EXIT();
229 mike    1.2  	    return true;
230                      }
231              	else
232              	{
233 kumpf   1.5              PEG_METHOD_EXIT();
234 mike    1.2  	    return false;
235                      }
236                  }
237 kumpf   1.4      catch (InvalidUser& iu)
238                  {
239 kumpf   1.5          PEG_METHOD_EXIT();
240 kumpf   1.4  	throw iu;
241                  }
242 mike    1.2      catch (Exception& e)
243                  {
244 kumpf   1.5          PEG_METHOD_EXIT();
245 mike    1.2  	throw e;
246                  }
247 kumpf   1.7  #else
248                  PEG_METHOD_EXIT();
249                  return false;
250              #endif
251 mike    1.2  }
252              
253              //
254              // Verify whether the specified user's password is valid
255              //
256              Boolean UserManager::verifyCIMUserPassword (
257              			   const String& userName, 
258              			   const String& password)
259              {
260 kumpf   1.5      PEG_METHOD_ENTER(TRC_USER_MANAGER, "UserManager::verifyCIMUserPassword");
261 mike    1.2  
262 kumpf   1.7  #ifndef PEGASUS_NO_PASSWORDFILE
263 mike    1.2      try
264                  {
265                      if ( _userFileHandler->verifyCIMUserPassword( userName, password ))
266              	{
267 kumpf   1.5              PEG_METHOD_EXIT();
268 mike    1.2  	    return true;
269                      }
270              	else
271              	{
272 kumpf   1.5              PEG_METHOD_EXIT();
273 mike    1.2  	    return false;
274                      }
275 kumpf   1.4      }
276                  catch (InvalidUser& iu)
277                  {
278 kumpf   1.5          PEG_METHOD_EXIT();
279 kumpf   1.4  	throw iu;
280 mike    1.2      }
281                  catch (Exception& e)
282                  {
283 kumpf   1.5          PEG_METHOD_EXIT();
284 mike    1.2  	throw e;
285                  }
286 kumpf   1.7  #else
287                  PEG_METHOD_EXIT();
288                  return false;
289              #endif
290 mike    1.2  }
291              
292              //
293              // Verify whether the specified namespace is valid
294              //
295 kumpf   1.10 Boolean UserManager::verifyNamespace( const CIMNamespaceName& myNamespace )
296 mike    1.2  {
297 kumpf   1.5      PEG_METHOD_ENTER(TRC_AUTHORIZATION, "UserManager::verifyNamespace");
298 mike    1.2  
299                  try
300                  {
301                      if ( _authHandler->verifyNamespace( myNamespace ))
302                      {
303 kumpf   1.5              PEG_METHOD_EXIT();
304 mike    1.2              return true;
305                      }
306                      else
307                      {
308 kumpf   1.5              PEG_METHOD_EXIT();
309 mike    1.2              return false;
310                      }
311                  }
312                  catch (Exception& e)
313                  {
314 kumpf   1.5          PEG_METHOD_EXIT();
315 mike    1.2          throw e;
316                  }
317              }
318              
319              //
320              // Verify whether the specified operation has authorization
321              // to be performed by the specified user.
322              //
323              Boolean UserManager::verifyAuthorization(
324                                          const String& userName,
325 kumpf   1.10                             const CIMNamespaceName& nameSpace,
326                                          const CIMName& cimMethodName)
327 mike    1.2  {
328 kumpf   1.5      PEG_METHOD_ENTER(TRC_AUTHORIZATION, "UserManager::verifyAuthorization");
329 mike    1.2  
330                  try
331                  {
332                      if ( _authHandler->verifyAuthorization(
333                          userName, nameSpace, cimMethodName ) )
334                      {
335 kumpf   1.5              PEG_METHOD_EXIT();
336 mike    1.2              return true;
337                      }
338                      else
339                      {
340 kumpf   1.5              PEG_METHOD_EXIT();
341 mike    1.2              return false;
342                      }
343                  }
344                  catch (Exception& e)
345                  {
346 kumpf   1.5          PEG_METHOD_EXIT();
347 mike    1.2          throw e;
348                  }
349              }
350              
351              //
352              // Set the authorizations
353              //
354              void UserManager::setAuthorization(
355                                          const String& userName,
356 kumpf   1.10                             const CIMNamespaceName& myNamespace,
357 mike    1.2                              const String& auth)
358              {
359 kumpf   1.5      PEG_METHOD_ENTER(TRC_AUTHORIZATION, "UserManager::setAuthorization");
360 kumpf   1.3  
361 mike    1.2      try
362                  {
363                      _authHandler->setAuthorization( userName, myNamespace, auth );
364                  }
365                  catch (Exception& e)
366                  {
367 kumpf   1.5          PEG_METHOD_EXIT();
368 mike    1.2          throw e;
369                  }
370 kumpf   1.3  
371 kumpf   1.5      PEG_METHOD_EXIT();
372 mike    1.2  }
373              
374              //
375              // Remove the authorizations for the specified user and namespace
376              //
377              void UserManager::removeAuthorization(
378                                          const String& userName,
379 kumpf   1.10                             const CIMNamespaceName& myNamespace)
380 mike    1.2  {
381 kumpf   1.5      PEG_METHOD_ENTER(TRC_AUTHORIZATION, "UserManager::removeAuthorization");
382 kumpf   1.3  
383 mike    1.2      try
384                  {
385                      _authHandler->removeAuthorization( userName, myNamespace);
386                  }
387                  catch (Exception& e)
388                  {
389 kumpf   1.5          PEG_METHOD_EXIT();
390 mike    1.2          throw e;
391                  }
392 kumpf   1.3  
393 kumpf   1.5      PEG_METHOD_EXIT();
394 mike    1.2  }
395              
396              
397              //
398              // Get the authorizations for the specified user and namespace
399              //
400              String UserManager::getAuthorization(
401                                          const String& userName,
402 kumpf   1.10                             const CIMNamespaceName& myNamespace)
403 mike    1.2  {
404 kumpf   1.5      PEG_METHOD_ENTER(TRC_AUTHORIZATION, "UserManager::getAuthorization");
405 kumpf   1.3  
406 mike    1.2      String auth = String::EMPTY;
407              
408                  try
409                  {
410                      auth = _authHandler->getAuthorization( userName, myNamespace);
411                  }
412                  catch (Exception& e)
413                  {
414 kumpf   1.5          PEG_METHOD_EXIT();
415 mike    1.2          throw e;
416                  }
417 kumpf   1.3  
418 kumpf   1.5      PEG_METHOD_EXIT();
419 mike    1.2  
420                  return auth;
421              }
422              
423              PEGASUS_NAMESPACE_END
424              
425              

No CVS admin address has been configured
Powered by
ViewCVS 0.9.2