sbuild-chroot.h

Go to the documentation of this file.

/* Copyright © 2005-2008  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_CHROOT_H
#define SBUILD_CHROOT_H

#include <sbuild/sbuild-custom-error.h>
#include <sbuild/sbuild-environment.h>
#include <sbuild/sbuild-format-detail.h>
#include <sbuild/sbuild-keyfile.h>
#include <sbuild/sbuild-regex.h>
#include <sbuild/sbuild-tr1types.h>

#include <list>
#include <ostream>
#include <string>

namespace sbuild
{

  class chroot_facet;

  class chroot
  {
  public:
    enum setup_type
      {
        SETUP_START,   
        SETUP_RECOVER, 
        SETUP_STOP,    
        EXEC_START,    
        EXEC_STOP      
      };

    enum session_flags
      {
        SESSION_NOFLAGS = 0,      
        SESSION_CREATE  = 1 << 0, 
        SESSION_CLONE   = 1 << 1, 
        SESSION_PURGE   = 1 << 2  
      };

    enum error_code
      {
        CHROOT_CREATE,   
        CHROOT_DEVICE,   
        CHROOT_TYPE,     
        DEVICE_ABS,      
        DEVICE_LOCK,     
        DEVICE_NOTBLOCK, 
        DEVICE_UNLOCK,   
        DIRECTORY_ABS,   
        FACET_INVALID,   
        FACET_PRESENT,   
        FILE_ABS,        
        FILE_LOCK,       
        FILE_NOTREG,     
        FILE_OWNER,      
        FILE_PERMS,      
        FILE_UNLOCK,     
        LOCATION_ABS,    
        SESSION_UNLINK,  
        SESSION_WRITE    
      };

    typedef custom_error<error_code> error;

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

    typedef std::tr1::shared_ptr<const chroot> const_ptr;

  protected:
    chroot ();

    chroot (const chroot& rhs);

  public:
    virtual ~chroot ();

    static ptr
    create (std::string const& type);

    virtual ptr
    clone () const = 0;

    virtual chroot::ptr
    clone_session (std::string const& session_id,
                   std::string const& user,
                   bool               root) const = 0;

    virtual chroot::ptr
    clone_source () const = 0;

    std::string const&
    get_name () const;

    void
    set_name (std::string const& name);

    std::string const&
    get_session_id () const;

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

    std::string const&
    get_keyfile_name () const;

    std::string const&
    get_description () const;

    void
    set_description (std::string const& description);

    std::string const&
    get_mount_location () const;

    void
    set_mount_location (std::string const& location);

  public:
    virtual std::string
    get_path () const = 0;

    unsigned int
    get_priority () const;

    void
    set_priority (unsigned int priority);

    string_list const&
    get_users () const;

    void
    set_users (string_list const& users);

    string_list const&
    get_groups () const;

    void
    set_groups (string_list const& groups);

    string_list const&
    get_root_users () const;

    void
    set_root_users (string_list const& users);

    string_list const&
    get_root_groups () const;

    void
    set_root_groups (string_list const& groups);

    string_list const&
    get_aliases () const;

    void
    set_aliases (string_list const& aliases);

    regex const&
    get_environment_filter () const;

    void
    set_environment_filter (regex const& environment_filter);

    bool
    get_active () const;

    bool
    get_original () const;

    void
    set_original (bool original);

    bool
    get_run_setup_scripts () const;

  protected:
    void
    set_run_setup_scripts (bool run_setup_scripts);

  public:
    std::string const&
    get_script_config () const;

    void
    set_script_config (std::string const& script_config);

    string_list const&
    get_command_prefix () const;

    void
    set_command_prefix (string_list const& command_prefix);

    virtual std::string const&
    get_chroot_type () const = 0;

    void
    setup_env (environment& env) const;

    virtual void
    setup_env (chroot const& chroot,
               environment& env) const = 0;

    void
    lock (setup_type type);

    void
    unlock (setup_type type,
            int        status);

  protected:
    virtual void
    setup_session_info (bool start);

    virtual void
    setup_lock(setup_type type,
               bool       lock,
               int        status) = 0;

  public:
    template <typename T>
    std::tr1::shared_ptr<T>
    get_facet ();

    template <typename T>
    const std::tr1::shared_ptr<const T>
    get_facet () const;

    template <typename T>
    void
    add_facet (std::tr1::shared_ptr<T> facet);

    template <typename T>
    void
    remove_facet ();

    template <typename T>
    void
    remove_facet (std::tr1::shared_ptr<T> facet);

    template <typename T>
    void
    replace_facet (std::tr1::shared_ptr<T> facet);

    string_list
    list_facets () const;

    session_flags
    get_session_flags () const;

    virtual chroot::session_flags
    get_session_flags (chroot const& chroot) const = 0;

    friend std::ostream&
    operator << (std::ostream& stream,
                 ptr const&    rhs)
    {
      rhs->print_details(stream);
      return stream;
    }

    friend
    keyfile const&
    operator >> (keyfile const& keyfile,
                 ptr&           rhs)
    {
      string_list used;
      rhs->set_keyfile(keyfile, used);
      keyfile.check_keys(rhs->get_name(), used);
      return keyfile;
    }

    friend
    keyfile&
    operator << (keyfile&   keyfile,
                 ptr const& rhs)
    {
      rhs->get_keyfile(keyfile);
      return keyfile;
    }

    void
    get_details (format_detail& detail) const;

    virtual void
    get_details (chroot const&  chroot,
                 format_detail& detail) const = 0;

    void
    print_details (std::ostream& stream) const;

    void
    get_keyfile (keyfile& keyfile) const;

  protected:
    virtual void
    get_keyfile (chroot const& chroot,
                 keyfile&      keyfile) const = 0;

  public:
    void
    set_keyfile (keyfile const& keyfile,
                 string_list&   used_keys);

  protected:
    virtual void
    set_keyfile (chroot&        chroot,
                 keyfile const& keyfile,
                 string_list&   used_keys) = 0;

  private:
    std::string   name;
    std::string   session_id;
    std::string   description;
    unsigned int  priority;
    string_list   users;
    string_list   groups;
    string_list   root_users;
    string_list   root_groups;
    string_list   aliases;
    regex         environment_filter;
    std::string   mount_location;
    bool          original;
    bool          run_setup_scripts;
    std::string   script_config;
    string_list   command_prefix;

    typedef std::tr1::shared_ptr<chroot_facet> facet_ptr;
    typedef std::list<facet_ptr> facet_list;
    facet_list facets;
  };

  chroot::session_flags
  inline operator | (chroot::session_flags const& lhs,
                     chroot::session_flags const& rhs)
  {
    return static_cast<chroot::session_flags>
      (static_cast<int>(lhs) | static_cast<int>(rhs));
  }

  chroot::session_flags
  inline operator & (chroot::session_flags const& lhs,
                     chroot::session_flags const& rhs)
  {
    return static_cast<chroot::session_flags>
      (static_cast<int>(lhs) & static_cast<int>(rhs));
  }

}

#include <sbuild/sbuild-chroot-facet.h>

namespace sbuild
{

  template <typename T>
  std::tr1::shared_ptr<T>
  chroot::get_facet ()
  {
    std::tr1::shared_ptr<T> ret;

    for (facet_list::const_iterator pos = facets.begin();
         pos != facets.end();
         ++pos)
      {
        if (ret = std::tr1::dynamic_pointer_cast<T>(*pos))
          break;
      }

    return ret;
  }

  template <typename T>
  const std::tr1::shared_ptr<const T>
  chroot::get_facet () const
  {
    std::tr1::shared_ptr<T> ret;

    for (facet_list::const_iterator pos = facets.begin();
         pos != facets.end();
         ++pos)
      {
        if (ret = std::tr1::dynamic_pointer_cast<T>(*pos))
          break;
      }

    return std::tr1::const_pointer_cast<T>(ret);
  }

  template <typename T>
  void
  chroot::add_facet (std::tr1::shared_ptr<T> facet)
  {
    facet_ptr new_facet = std::tr1::dynamic_pointer_cast<chroot_facet>(facet);
    if (!new_facet)
      throw error(FACET_INVALID);

    for (facet_list::const_iterator pos = facets.begin();
         pos != facets.end();
         ++pos)
      {
        if (std::tr1::dynamic_pointer_cast<T>(*pos))
          throw error(FACET_PRESENT);
      }

    new_facet->set_chroot(*this);
    facets.push_back(new_facet);
  }

  template <typename T>
  void
  chroot::remove_facet ()
  {
    for (facet_list::iterator pos = facets.begin();
         pos != facets.end();
         ++pos)
      {
        if (std::tr1::dynamic_pointer_cast<T>(*pos))
          {
            facets.erase(pos);
            break;
          }
      }
  }

  template <typename T>
  void
  chroot::remove_facet (std::tr1::shared_ptr<T> facet)
  {
    remove_facet<T>();
  }

  template <typename T>
  void
  chroot::replace_facet (std::tr1::shared_ptr<T> facet)
  {
    remove_facet<T>();
    add_facet(facet);
  }

}

#endif /* SBUILD_CHROOT_H */

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