Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbApplication/BdbDomainAuth.cc

Go to the documentation of this file.

#if !defined(BDBDOMAINAUTH_CC)
#define BDBDOMAINAUTH_CC
//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbDomainAuth.cc,v 1.4 2002/06/18 23:29:00 becla Exp $
//
// Description:
//      Class BdbDomainAuth
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Simon Patton            Stripped from origianl BdbDomain code
//
// Copyright Information:
//      Copyright (C) 1999      LBNL
//
//------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbApplication/BdbDomainAuth.hh"

//-------------
// C Headers --
//-------------
extern "C" {
#include <assert.h>
#include <stdlib.h> // getenv
#include <ctype.h> // tolower
#include <pwd.h> // getpwuid
#include <string.h>
#include <strings.h>
#include <unistd.h> // cuserid
#include <stdio.h>  // cuserid for Linux
}

//---------------
// C++ Headers --
//---------------

//----------------
// BaBar Header --
//----------------
#include "BaBar/BaBar.hh"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbUtil/BdbPathName.hh"

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------

//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------

//              -----------------------------------------------
//              -- Static Data & Function Member Definitions --
//              -----------------------------------------------

const char* 
BdbDomainAuth::AuthLevelNames[] = { "system" ,
                                    "groups" ,
                                    "users" ,
                                    "illegal" };

const char*
BdbDomainAuth::_userName = 0;

const char*
BdbDomainAuth::_groupName = 0;

const char*
BdbDomainAuth::_systemAuthName = "bb";

const char*
BdbDomainAuth::authLevelName( AuthLevels theAuthLevel )
{
   return AuthLevelNames[theAuthLevel];
}

const char*
BdbDomainAuth::groupName( )
{
   if ( 0 == _groupName ) {
      _groupName = getenv( "BABARGROUPNAME" );
      if ( 0 == _groupName ) {
         _groupName = "bfactory";
      }
   }
   return _groupName;
}

const char*
BdbDomainAuth::userName( )
{
   if ( 0 == _userName ) {
      _userName = getenv( "BABARUSERNAME" );
      if ( 0 == _userName ) {

         // Fixed by gg on 20/11/98 for HP/aCC
#ifndef HPaCC
         _userName = cuserid( (char*)0 );
#else
         _userName = getpwuid(getuid())->pw_name;
#endif

      }
   }
   return _userName;
}

bool
BdbDomainAuth::isAuthLevelValid( AuthLevels theAuthLevel )
{
   bool result = false;
   if ( ( theAuthLevel >= FirstAuth ) && ( theAuthLevel < IllegalAuth ) ) {
      result = !false;
   }
   return result;
}

// Only order is important, must start with 0. On error must return IllegalAuth
int
BdbDomainAuth::authLevelNr(const char* authLevelName)
{
   if ( ! strcmp(authLevelName, "system") )
      return 0 ;
   if ( ! strcmp(authLevelName, "groups") )
      return 1 ;
   if ( ! strcmp(authLevelName, "users") )      
      return 2 ;
        
   return IllegalAuth ;
}


const char* 
BdbDomainAuth::authLevelName(char c)
{
   if ( c == 's' || c == 'S' ) {
      return AuthLevelNames[System];
   } else if ( c == 'g' || c == 'G' ) {
      return AuthLevelNames[Group];
   }
    
   return AuthLevelNames[User];
}

//              ---------------------------------
//              -- Member Function Definitions --
//              ---------------------------------

//----------------
// Constructors --
//----------------

BdbDomainAuth::BdbDomainAuth()
   : _authLevel    ( User ),
     _authName     ( NULL )
{
}

// BdbDomainAuth::BdbDomainAuth( const BdbDomainAuth& aRhs )
// {
// }

//--------------
// Destructor --
//--------------

BdbDomainAuth::~BdbDomainAuth( ) 
{
   if ( NULL != _authName ) {
      delete [] _authName;
      _authName = NULL;
   }
}

//-------------
// Operators --
//-------------
    
// const BdbDomainAuth& BdbDomainAuth::operator=( const BdbDomainAuth& aRhs )
// {
// }

//-------------
// Selectors --
//-------------

BdbDomainAuth::AuthLevels
BdbDomainAuth::authLevel( ) const
{
   return _authLevel;
}
    
const char*
BdbDomainAuth::authLevelName( ) const
{
   return BdbDomainAuth::AuthLevelNames[ _authLevel ];
}
    
const char*
BdbDomainAuth::authName( ) const
{
   return _authName;
}
    
bool
BdbDomainAuth::isAccessAllowed( const char* userName ) const
{
   return !false;
}

//-------------
// Modifiers --
//-------------

bool
BdbDomainAuth::setAuthLevel( AuthLevels theAuthLevel, const char* const theAuthName )
{
   assert( isAuthLevelValid( theAuthLevel ) );
   bool result = false ;

   if ( isAuthorized( theAuthLevel, theAuthName ) ) {
      result = setInitialAuthLevel( theAuthLevel, theAuthName );
   }
   return result;
}
    
bool
BdbDomainAuth::setAuthLevel( const char* const theAuthPath )
{
   AuthLevels  theAuthLevel = getAuthLevel( theAuthPath );
   const char* theAuthName  = getAuthName ( theAuthPath );

   bool result = setAuthLevel( theAuthLevel, theAuthName );
   return result;
}
    
void
BdbDomainAuth::setAuthName( const char* const theAuthName )
{
   if ( ( NULL != _authName ) && ( theAuthName != _authName ) ) {
      delete [] _authName;
      _authName = NULL;
   }
   if ( ( NULL != theAuthName ) && ( NULL == _authName ) ) {
      _authName = new char[strlen( theAuthName )+1];
      strcpy( _authName, theAuthName );
   }
}
    
//--------------
// Operations --
//--------------

bool
BdbDomainAuth::setInitialAuthLevel( AuthLevels theAuthLevel, 
                                    const char* const theAuthName )
{
   assert( isAuthLevelValid( theAuthLevel ) );
   const char* useName = theAuthName;

   switch( theAuthLevel ) {
      case System:
      {
         _authLevel = theAuthLevel;
         useName    = NULL;
         break;
      }
      case Group:
      {
         _authLevel = theAuthLevel;
         useName    = theAuthName;
         if ( NULL == useName ) {
            useName = "Global";
         }
         break;
      }
      case User:
      {
         // The theAuthName argument specifies the particular user
         // and defaults to current user if it's NULL or zero length.
         _authLevel = theAuthLevel;
         if ( NULL == useName ) {  
            useName = userName( );
         }
         break;
      }
   }
   setAuthName( useName );
   return !false;
}

BdbDomainAuth::AuthLevels
BdbDomainAuth::parseAuthLevel( const char* const theAuthPath )
{
   // Check that the path is an absolute path
   AuthLevels result( IllegalAuth );
   const char localSeparator( BdbPathName::separator() );
   if( ( 0 == theAuthPath ) ||
       ( localSeparator != *theAuthPath ) ) {
      return result;
   }

   // copy leading leaf into temporary
   char* theAuthLevel = BdbPathName::leaf( theAuthPath,
                                           0 );
   if( 0 == theAuthLevel ) {
      return result;
   }

   // Test temporary for a valid authorization level (case-insensitive)
   if        ( 0 == strncmp( theAuthLevel, 
                             AuthLevelNames[0], 
                             strlen( AuthLevelNames[0] ) ) ) {
      result = System;
   } else if ( 0 == strncmp( theAuthLevel, 
                             AuthLevelNames[1],
                             strlen( AuthLevelNames[1] ) ) ) {
      result = Group;
   } else if ( 0 == strncmp( theAuthLevel, 
                             AuthLevelNames[2],
                             strlen( AuthLevelNames[2] ) ) ) {
      result = User;
   }
   delete [] theAuthLevel;

   return result;
}
    
BdbDomainAuth::AuthLevels
BdbDomainAuth::getAuthLevel( const char* const theAuthPath )
// Retrieve the authorization level from the authorization path.
//
// The format of the authorization path is:
//
//      [/<level>][/<name>/]<text>
//
// where <level> is one of "system", "groups" or "users". Note that 
// the current level will be returned if no leading "/" is detected. 
{
   AuthLevels result( parseAuthLevel( theAuthPath ) );
   if( IllegalAuth == result ) {
      return authLevel();
   }

   return result;
}

char*
BdbDomainAuth::parseAuthName( const char* const theAuthPath )
{
   // Check that the path is an absolute path
   char* result( 0 );
   const char localSeparator( BdbPathName::separator() );
   if( ( 0 == theAuthPath ) ||
       ( localSeparator != *theAuthPath ) ) {
      return result;
   }

   // Find user (if not System level authorization)
   AuthLevels theAuthLevel( parseAuthLevel( theAuthPath ) );
   switch( theAuthLevel ) {
      case Group:
      case User:
      {
         result = BdbPathName::leaf( theAuthPath,
                                     1 );
         if( 0 != result ) {
            if( 0 == strcmp( result,
                             "<user>" ) ) {
               delete [] result;
               const char* realResult( userName() );
               result = new char[ strlen( realResult ) + 1 ];
               strcpy( result,
                       realResult );
            }
         }
         break;
      }
      default:
      {
         result = 0;
         break;
      }
   }
   return result;
}

const char*
BdbDomainAuth::getAuthName( const char* const theAuthPath )
// Retrieve the authorization name from the authorization path
//
// The format of the authorization path is:
//
//      [/<level>][/<name>/]...
//
// where <level> is one of "system", "groups" or "users", and <name>
// is the group name or user name. Note that NULL is returned for
// level "system", and the default name will be returned if no leading "/"
// is detected. Finally, /users/<user>/... is recognised as corresponding
// to the current user name.
{
   // Check that the path is an absolute path
   char* result( 0 );
   const char localSeparator( BdbPathName::separator() );
   if( ( 0 == theAuthPath ) ||
       ( localSeparator != *theAuthPath ) ) {
      return authName();
   }

   result = parseAuthName( theAuthPath );
   static char theAuthName[256];
   if( 0 != result ) {
      strcpy( theAuthName,
              result );
      delete [] result;
      result = theAuthName;
   }
   return result;
}

const char*
BdbDomainAuth::useAuthName( AuthLevels theAuthLevel,
                            const char* const theAuthName )
// Retrieve the effective authorization name from the authorization level
// and supplied name. If the level is either of groups or users and the
// supplied name is NULL, then the default is returned.
{
   const char* result = theAuthName;
   if ( ( 0 == result ) && ( System != theAuthLevel ) ) {
      result = authName( );
   }
   return result;
}

const char*
BdbDomainAuth::skipAuthName( const char* const theAuthPath )
// Skip over the authorization level and name from the authorization path
//
// The format of the authorization path is:
//
//      [/<level>][/<name>/]...
//
// where <level> is one of "system", "groups" or "users", and <name>
// is the group name or user name. Note that NULL is returned for
// level "system", and the default name will be returned if no leading "/"
// is detected. Finally, /users/<user>/... is recognised as corresponding
// to the current user name.
{
   const char* result   = theAuthPath;
   const char* theStart = theAuthPath;
   const char* theEnd;

   if ( 0 != theAuthPath ) {
      // Locate Authorization Level
      if ( '/' == *theStart ) {
         theStart++;
         AuthLevels theAuthLevel = getAuthLevel( theAuthPath );
         switch( theAuthLevel ) {
            case Group:
            case User:
            {
               theEnd = strchr( theStart, '/' );
               if ( 0 != theEnd ) {
                  theStart = theEnd + 1;
               }
               break;
            }
            case System:
            {
            }
         }
         theEnd = strchr( theStart, '/' );
         if ( 0 != theEnd ) {
            theEnd++;
         }
         result = theEnd;
      }
   }
   return result;
}

#endif // BDBDOMAINAUTH_CC

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002