gprocess.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_PROCESS_H
#define G_PROCESS_H

#include "gdef.h"
#include "gexception.h"
#include "gidentity.h"
#include "gpath.h"
#include "gstrings.h"
#include <iostream>
#include <sys/types.h>
#include <string>

namespace G
{
        class Process ;
        class NewProcess ;
}

class G::Process : private G::IdentityUser 
{
public:
        G_EXCEPTION( CannotChangeDirectory , "cannot cd()" ) ;
        G_EXCEPTION( InvalidId , "invalid process-id string" ) ;

        class IdImp ;
        class Id 
        {
                public: Id() ;
                public: explicit Id( std::istream & ) ;
                public: Id( SignalSafe , const char * pid_file_path ) ; // (ctor for signal-handler)
                public: std::string str() const ;
                public: bool operator==( const Id & ) const ;
                private: pid_t m_pid ;
                friend class NewProcess ;
                friend class Process ;
        } ;
        class Umask 
        {
                public: enum Mode { Readable , Tighter , Tightest , GroupOpen } ;
                public: explicit Umask( Mode ) ;
                public: ~Umask() ;
                public: static void set( Mode ) ;
                private: Umask( const Umask & ) ; // not implemented
                private: void operator=( const Umask & ) ; // not implemented
                private: class UmaskImp ;
                private: UmaskImp * m_imp ;
        } ;
        class NoThrow 
                {} ;

        static void closeFiles( bool keep_stderr = false ) ;

        static void closeFiles( int fd ) ;

        static void closeStderr() ;

        static void cd( const Path & dir ) ;

        static bool cd( const Path & dir , NoThrow ) ;

        static int errno_() ;

        static int errno_( int ) ;

        static std::string strerror( int errno_ ) ;

        static void revokeExtraGroups() ;

        static Identity beOrdinary( Identity nobody , bool change_group = true ) ;

        static Identity beSpecial( Identity special , bool change_group = true ) ;

        static Identity beOrdinary( SignalSafe , Identity nobody , bool change_group = true ) ;

        static Identity beSpecial( SignalSafe , Identity special , bool change_group = true ) ;

        static void beNobody( Identity ) ;

private:
        Process() ;
} ;

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

        inline
        std::istream & operator>>( std::istream & stream , G::Process::Id & id )
        {
                id = G::Process::Id( stream ) ;
                return stream ;
        }
}

#endif