sbuild-session.h

/* Copyright © 2005-2007  Roger Leigh <rleigh@debian.org>
 *
 * schroot 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.
 *
 * schroot 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 SBUILD_SESSION_H
#define SBUILD_SESSION_H

#include <sbuild/sbuild-auth.h>
#include <sbuild/sbuild-chroot.h>
#include <sbuild/sbuild-custom-error.h>

#include <string>

#include <signal.h>
#include <sys/types.h>
#include <termios.h>
#include <unistd.h>

namespace sbuild
{

  class session
  {
  public:
    typedef std::vector<chroot::ptr> chroot_list;

    enum operation
      {
        OPERATION_AUTOMATIC, 
        OPERATION_BEGIN,     
        OPERATION_RECOVER,   
        OPERATION_END,       
        OPERATION_RUN        
      };

    enum error_code
      {
        CHDIR,          
        CHDIR_FB,       
        CHILD_CORE,     
        CHILD_FAIL,     
        CHILD_FORK,     
        CHILD_SIGNAL,   
        CHILD_WAIT,     
        CHROOT,         
        CHROOT_ALIAS,   
        CHROOT_LOCK,    
        CHROOT_NOTFOUND,
        CHROOT_SETUP,   
        CHROOT_UNLOCK,  
        COMMAND_ABS,    
        EXEC,           
        GROUP_GET_SUP,  
        GROUP_GET_SUPC, 
        GROUP_SET,      
        GROUP_SET_SUP,  
        GROUP_UNKNOWN,  
        PAM,            
        ROOT_DROP,      
        SET_SESSION_ID, 
        SHELL,          
        SHELL_FB,       
        SIGNAL_CATCH,   
        SIGNAL_SET,     
        USER_SET,       
        USER_SWITCH     
      };

    typedef custom_error<error_code> error;

    typedef std::tr1::shared_ptr<session> ptr;

    session (std::string const& service,
             operation          operation,
             chroot_list const& chroots);

    virtual ~session ();

    auth::ptr const&
    get_auth () const;

    void
    set_auth (auth::ptr& auth);

    chroot_list const&
    get_chroots () const;

    void
    set_chroots (chroot_list const& chroots);

    operation
    get_operation () const;

    void
    set_operation (operation operation);

    std::string const&
    get_session_id () const;

    void
    set_session_id (std::string const& session_id);

    std::string const&
    get_verbosity () const;

    void
    set_verbosity (std::string const& verbosity);

    bool
    get_preserve_environment () const;

    void
    set_preserve_environment (bool preserve_environment);

    bool
    get_force () const;

    void
    set_force (bool force);

    void
    save_termios ();

    void
    restore_termios ();

    int
    get_child_status () const;

  protected:
    void
    get_chroot_membership (chroot::ptr const& chroot,
                           bool&              in_users,
                           bool&              in_root_users,
                           bool&              in_groups,
                           bool&              in_root_groups) const;

    virtual auth::status
    get_chroot_auth_status (auth::status status,
                            chroot::ptr const& chroot) const;

  public:
    virtual sbuild::auth::status
    get_auth_status () const;

    void
    run ();

  protected:
    virtual void
    run_impl ();

    virtual string_list
    get_login_directories (sbuild::chroot::ptr& session_chroot,
                           environment const&   env) const;

    virtual string_list
    get_command_directories (sbuild::chroot::ptr& session_chroot,
                             environment const&   env) const;

    virtual std::string
    get_shell () const;

    virtual void
    get_command (chroot::ptr&       session_chroot,
                 std::string&       file,
                 string_list&       command,
                 environment const& env) const;

    virtual void
    get_login_command (chroot::ptr& session_chroot,
                       std::string& file,
                       string_list& command) const;

    virtual void
    get_user_command (chroot::ptr&       session_chroot,
                      std::string&       file,
                      string_list&       command,
                      environment const& env) const;

  private:
    void
    setup_chroot (chroot::ptr&       session_chroot,
                  chroot::setup_type setup_type);

    void
    run_chroot (chroot::ptr& session_chroot);

    void
    run_child (chroot::ptr& session_chroot);

    void
    wait_for_child (pid_t pid,
                    int&  child_status);

    void
    set_sighup_handler ();

    void
    clear_sighup_handler ();

    void
    set_sigint_handler ();

    void
    clear_sigint_handler ();

    void
    set_sigterm_handler ();

    void
    clear_sigterm_handler ();

    void
    set_signal_handler (int                signal,
                        struct sigaction  *saved_signal,
                        void             (*handler)(int));

    void
    clear_signal_handler (int               signal,
                          struct sigaction *saved_signal);

    auth::ptr        authstat;
    chroot_list      chroots;
    int              chroot_status;
    bool lock_status;
    int              child_status;
    operation        session_operation;
    std::string      session_id;
    bool             force;
    struct sigaction saved_sighup_signal;
    struct sigaction saved_sigint_signal;
    struct sigaction saved_sigterm_signal;
    struct termios saved_termios;
    bool termios_ok;
    std::string verbosity;
    bool        preserve_environment;

  protected:
    std::string      cwd;
  };

}

#endif /* SBUILD_SESSION_H */

/*
 * Local Variables:
 * mode:C++
 * End:
 */