gidentity.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// ===

#ifndef G_IDENTITY_H
#define G_IDENTITY_H

#include "gdef.h"
#include "gexception.h"
#include "gsignalsafe.h"
#include <string>
#include <iostream>

namespace G
{
        class Identity ;
        class IdentityUser ;
}

class G::Identity  
{
public:
        G_EXCEPTION( NoSuchUser , "no such user" ) ;
        G_EXCEPTION( UidError , "cannot set uid" ) ;
        G_EXCEPTION( GidError , "cannot set gid" ) ;

        explicit Identity( const std::string & login_name ) ;

        static Identity effective() ;

        static Identity real() ;

        static Identity root() ;

        static Identity invalid() ;

        bool isRoot() const ;

        std::string str() const ;

        void setRealUser( bool do_throw = true ) ;

        void setEffectiveUser( bool do_throw = true ) ;

        void setEffectiveUser( SignalSafe ) ;

        void setRealGroup( bool do_throw = true ) ;

        void setEffectiveGroup( bool do_throw = true ) ;

        void setEffectiveGroup( SignalSafe ) ;

        bool operator==( const Identity & ) const ;

        bool operator!=( const Identity & ) const ;

private:
        Identity() ; // no throw

private:
        uid_t m_uid ;
        gid_t m_gid ;
        HANDLE m_h ; // windows
} ;

class G::IdentityUser 
{
protected:
        static void setRealUserTo( Identity , bool do_throw = true ) ;

        static void setEffectiveUserTo( Identity , bool do_throw = true ) ;

        static void setEffectiveUserTo( SignalSafe , Identity ) ;

        static void setRealGroupTo( Identity , bool do_throw = true ) ;

        static void setEffectiveGroupTo( Identity , bool do_throw = true ) ;

        static void setEffectiveGroupTo( SignalSafe , Identity ) ;

private:
        IdentityUser() ; // not implemented
} ;

namespace G
{
        inline
        std::ostream & operator<<( std::ostream & stream , const G::Identity & identity )
        {
                return stream << identity.str() ;
        }
}

#endif