libexec: Sources use namespace scoping

Enclose in namespace as for sbuild sources.

10 files changed, 502 insertions, 472 deletions

diff --git a/bin/dchroot-dsa/main.cc b/bin/dchroot-dsa/main.cc
index 410af234..0a92ae91 100644
--- a/bin/dchroot-dsa/main.cc
+++ b/bin/dchroot-dsa/main.cc
@@ -35,29 +35,33 @@
 using std::endl;
 using sbuild::_;
 using boost::format;
-using namespace dchroot_dsa;
-
-main::main (schroot_common::options::ptr& options):
-  dchroot_common::main("dchroot-dsa",
-                       // TRANSLATORS: '...' is an ellipsis e.g. U+2026, and '-'
-                       // is an em-dash.
-                       _("[OPTION…] chroot [COMMAND] — run command or shell in a chroot"),
-                       options)
-{
-}
 
-main::~main ()
+namespace dchroot_dsa
 {
-}
 
-void
-main::create_session(sbuild::session::operation sess_op)
-{
-  sbuild::log_debug(sbuild::DEBUG_INFO)
-    << "Creating dchroot-dsa session" << endl;
+  main::main (schroot_common::options::ptr& options):
+    dchroot_common::main("dchroot-dsa",
+                         // TRANSLATORS: '...' is an ellipsis e.g. U+2026, and '-'
+                         // is an em-dash.
+                         _("[OPTION…] chroot [COMMAND] — run command or shell in a chroot"),
+                         options)
+  {
+  }
+
+  main::~main ()
+  {
+  }
+
+  void
+  main::create_session(sbuild::session::operation sess_op)
+  {
+    sbuild::log_debug(sbuild::DEBUG_INFO)
+      << "Creating dchroot-dsa session" << endl;
+
+    this->session = sbuild::session::ptr
+      (new dchroot_dsa::session("schroot",
+                                sess_op,
+                                this->chroot_objects));
+  }
 
-  this->session = sbuild::session::ptr
-    (new dchroot_dsa::session("schroot",
-                              sess_op,
-                              this->chroot_objects));
 }
diff --git a/bin/dchroot-dsa/options.cc b/bin/dchroot-dsa/options.cc
index eba4eaba..90ab178b 100644
--- a/bin/dchroot-dsa/options.cc
+++ b/bin/dchroot-dsa/options.cc
@@ -32,76 +32,80 @@ using std::endl;
 using sbuild::_;
 using boost::format;
 namespace opt = boost::program_options;
-using namespace dchroot_dsa;
 
-options::options ():
-  schroot_common::options()
+namespace dchroot_dsa
 {
-}
-
-options::~options ()
-{
-}
-
-void
-options::add_options ()
-{
-  // Chain up to add general schroot options.
-  schroot_common::options::add_options();
-
-  actions.add_options()
-    ("listpaths,p",
-     _("Print paths to available chroots"));
 
-  chroot.add_options()
-    ("all,a",
-     _("Select all chroots"));
+  options::options ():
+    schroot_common::options()
+  {
+  }
+
+  options::~options ()
+  {
+  }
+
+  void
+  options::add_options ()
+  {
+    // Chain up to add general schroot options.
+    schroot_common::options::add_options();
+
+    actions.add_options()
+      ("listpaths,p",
+       _("Print paths to available chroots"));
+
+    chroot.add_options()
+      ("all,a",
+       _("Select all chroots"));
+
+    chrootenv.add_options()
+      ("directory,d", opt::value<std::string>(&this->directory),
+       _("Directory to use"));
+  }
+
+  void
+  options::check_options ()
+  {
+    // Chain up to check general schroot options.
+    schroot_common::options::check_options();
+
+    if (vm.count("listpaths"))
+      this->action = ACTION_LOCATION;
+
+    if (vm.count("all"))
+      {
+        this->all = false;
+        this->all_chroots = true;
+        this->all_sessions = false;
+      }
+
+    // Always preserve environment.
+    this->preserve = true;
+
+    // If no chroots specified, use the first non-option.
+    if (this->chroots.empty() && !this->command.empty())
+      {
+        this->chroots.push_back(this->command[0]);
+        this->command.erase(this->command.begin());
+      }
+
+    // dchroot-dsa only allows one command.
+    if (this->command.size() > 1)
+      throw error(_("Only one command may be specified"));
+
+    if (!this->command.empty() &&
+        !sbuild::is_absname(this->command[0]))
+      throw error(_("Command must have an absolute path"));
+
+    if (this->chroots.empty() && !all_used() &&
+        (this->action != ACTION_CONFIG &&
+         this->action != ACTION_INFO &&
+         this->action != ACTION_LIST &&
+         this->action != ACTION_LOCATION &&
+         this->action != ACTION_HELP &&
+         this->action != ACTION_VERSION))
+      throw error(_("No chroot specified"));
+  }
 
-  chrootenv.add_options()
-    ("directory,d", opt::value<std::string>(&this->directory),
-     _("Directory to use"));
-}
-
-void
-options::check_options ()
-{
-  // Chain up to check general schroot options.
-  schroot_common::options::check_options();
-
-  if (vm.count("listpaths"))
-    this->action = ACTION_LOCATION;
-
-  if (vm.count("all"))
-    {
-      this->all = false;
-      this->all_chroots = true;
-      this->all_sessions = false;
-    }
-
-  // Always preserve environment.
-  this->preserve = true;
-
-  // If no chroots specified, use the first non-option.
-  if (this->chroots.empty() && !this->command.empty())
-    {
-      this->chroots.push_back(this->command[0]);
-      this->command.erase(this->command.begin());
-    }
-
-  // dchroot-dsa only allows one command.
-  if (this->command.size() > 1)
-    throw error(_("Only one command may be specified"));
-
-  if (!this->command.empty() &&
-      !sbuild::is_absname(this->command[0]))
-    throw error(_("Command must have an absolute path"));
-
-  if (this->chroots.empty() && !all_used() &&
-      (this->action != ACTION_CONFIG &&
-       this->action != ACTION_INFO &&
-       this->action != ACTION_LIST &&
-       this->action != ACTION_LOCATION &&
-       this->action != ACTION_HELP &&
-       this->action != ACTION_VERSION))
-    throw error(_("No chroot specified"));
 }
diff --git a/bin/dchroot-dsa/session.cc b/bin/dchroot-dsa/session.cc
index 855515a3..0e003749 100644
--- a/bin/dchroot-dsa/session.cc
+++ b/bin/dchroot-dsa/session.cc
@@ -37,76 +37,80 @@ using std::cout;
 using std::endl;
 using sbuild::_;
 using boost::format;
-using namespace dchroot_dsa;
 
-session::session (std::string const&         service,
-                  operation                  operation,
-                  sbuild::session::chroot_list const& chroots):
-  dchroot_common::session(service, operation, chroots)
+namespace dchroot_dsa
 {
-}
 
-session::~session ()
-{
-}
+  session::session (std::string const&         service,
+                    operation                  operation,
+                    sbuild::session::chroot_list const& chroots):
+    dchroot_common::session(service, operation, chroots)
+  {
+  }
+
+  session::~session ()
+  {
+  }
+
+  sbuild::string_list
+  session::get_login_directories (sbuild::chroot::chroot::ptr& session_chroot,
+                                  sbuild::environment const&   env) const
+  {
+    sbuild::string_list ret;
+
+    std::string const& wd(get_auth()->get_wd());
+    if (!wd.empty())
+      {
+        // Set specified working directory.
+        ret.push_back(wd);
+      }
+    else
+      {
+        ret.push_back(get_auth()->get_home());
+
+        // Final fallback to root.
+        if (std::find(ret.begin(), ret.end(), "/") == ret.end())
+          ret.push_back("/");
+      }
+
+    return ret;
+  }
+
+  void
+  session::get_user_command (sbuild::chroot::chroot::ptr& session_chroot,
+                             std::string&                 file,
+                             sbuild::string_list&         command,
+                             sbuild::environment const&   env) const
+  {
+    std::string programstring = command[0];
+    file = programstring;
+
+    if (!sbuild::is_absname(file))
+      throw error(file, COMMAND_ABS);
+
+    std::string commandstring = sbuild::string_list_to_string(command, " ");
+    sbuild::log_debug(sbuild::DEBUG_NOTICE)
+      << format("Running command: %1%") % commandstring << endl;
+    if (get_auth()->get_uid() == 0 ||
+        get_auth()->get_ruid() != get_auth()->get_uid())
+      syslog(LOG_USER|LOG_NOTICE, "[%s chroot] (%s->%s) Running command: \"%s\"",
+             session_chroot->get_name().c_str(),
+             get_auth()->get_ruser().c_str(),
+             get_auth()->get_user().c_str(),
+             commandstring.c_str());
+
+    if (session_chroot->get_verbosity() != sbuild::chroot::chroot::VERBOSITY_QUIET)
+      {
+        std::string format_string;
+        // TRANSLATORS: %1% = chroot name
+        // TRANSLATORS: %2% = command
+        format_string = (_("[%1% chroot] Running command: “%2%”"));
+
+        format fmt(format_string);
+        fmt % session_chroot->get_name()
+          % programstring;
+        sbuild::log_info() << fmt << endl;
+      }
+  }
 
-sbuild::string_list
-session::get_login_directories (sbuild::chroot::chroot::ptr& session_chroot,
-                                sbuild::environment const&   env) const
-{
-  sbuild::string_list ret;
-
-  std::string const& wd(get_auth()->get_wd());
-  if (!wd.empty())
-    {
-      // Set specified working directory.
-      ret.push_back(wd);
-    }
-  else
-    {
-      ret.push_back(get_auth()->get_home());
-
-      // Final fallback to root.
-      if (std::find(ret.begin(), ret.end(), "/") == ret.end())
-        ret.push_back("/");
-    }
-
-  return ret;
-}
-
-void
-session::get_user_command (sbuild::chroot::chroot::ptr& session_chroot,
-                           std::string&                 file,
-                           sbuild::string_list&         command,
-                           sbuild::environment const&   env) const
-{
-  std::string programstring = command[0];
-  file = programstring;
-
-  if (!sbuild::is_absname(file))
-    throw error(file, COMMAND_ABS);
-
-  std::string commandstring = sbuild::string_list_to_string(command, " ");
-  sbuild::log_debug(sbuild::DEBUG_NOTICE)
-    << format("Running command: %1%") % commandstring << endl;
-  if (get_auth()->get_uid() == 0 ||
-      get_auth()->get_ruid() != get_auth()->get_uid())
-    syslog(LOG_USER|LOG_NOTICE, "[%s chroot] (%s->%s) Running command: \"%s\"",
-           session_chroot->get_name().c_str(),
-           get_auth()->get_ruser().c_str(),
-           get_auth()->get_user().c_str(),
-           commandstring.c_str());
-
-  if (session_chroot->get_verbosity() != sbuild::chroot::chroot::VERBOSITY_QUIET)
-    {
-      std::string format_string;
-      // TRANSLATORS: %1% = chroot name
-      // TRANSLATORS: %2% = command
-      format_string = (_("[%1% chroot] Running command: “%2%”"));
-
-      format fmt(format_string);
-      fmt % session_chroot->get_name()
-        % programstring;
-      sbuild::log_info() << fmt << endl;
-    }
 }
diff --git a/bin/dchroot/dchroot.cc b/bin/dchroot/dchroot.cc
index f4a31a31..658e2650 100644
--- a/bin/dchroot/dchroot.cc
+++ b/bin/dchroot/dchroot.cc
@@ -25,7 +25,6 @@
 
 using std::endl;
 using boost::format;
-using namespace dchroot;
 
 /**
  * Main routine.
diff --git a/bin/dchroot/main.cc b/bin/dchroot/main.cc
index 9bdf0485..3f30f093 100644
--- a/bin/dchroot/main.cc
+++ b/bin/dchroot/main.cc
@@ -35,28 +35,32 @@
 using std::endl;
 using sbuild::_;
 using boost::format;
-using namespace dchroot;
-
-main::main (schroot_common::options::ptr& options):
-  dchroot_common::main("dchroot",
-                       // TRANSLATORS: '...' is an ellipsis e.g. U+2026, and '-'
-                       // is an em-dash.
-                       _("[OPTION…] [COMMAND] — run command or shell in a chroot"),
-                       options)
-{
-}
 
-main::~main ()
+namespace dchroot
 {
-}
 
-void
-main::create_session (sbuild::session::operation sess_op)
-{
-  sbuild::log_debug(sbuild::DEBUG_INFO) << "Creating dchroot session" << endl;
+  main::main (schroot_common::options::ptr& options):
+    dchroot_common::main("dchroot",
+                         // TRANSLATORS: '...' is an ellipsis e.g. U+2026, and '-'
+                         // is an em-dash.
+                         _("[OPTION…] [COMMAND] — run command or shell in a chroot"),
+                         options)
+  {
+  }
+
+  main::~main ()
+  {
+  }
+
+  void
+  main::create_session (sbuild::session::operation sess_op)
+  {
+    sbuild::log_debug(sbuild::DEBUG_INFO) << "Creating dchroot session" << endl;
+
+    this->session = sbuild::session::ptr
+      (new dchroot::session("schroot",
+                            sess_op,
+                            this->chroot_objects));
+  }
 
-  this->session = sbuild::session::ptr
-    (new dchroot::session("schroot",
-                          sess_op,
-                          this->chroot_objects));
 }
diff --git a/bin/dchroot/options.cc b/bin/dchroot/options.cc
index b91b330b..a817f176 100644
--- a/bin/dchroot/options.cc
+++ b/bin/dchroot/options.cc
@@ -30,81 +30,85 @@ using std::endl;
 using sbuild::_;
 using boost::format;
 namespace opt = boost::program_options;
-using namespace dchroot;
 
-options::options ():
-  schroot_common::options()
+namespace dchroot
 {
-}
 
-options::~options ()
-{
-}
+  options::options ():
+    schroot_common::options()
+  {
+  }
+
+  options::~options ()
+  {
+  }
+
+  void
+  options::add_options ()
+  {
+    // Chain up to add general schroot options.
+    schroot_common::options::add_options();
+
+    actions.add_options()
+      ("path,p", opt::value<std::string>(&this->chroot_path),
+       _("Print path to selected chroot"));
+
+    chroot.add_options()
+      ("all,a",
+       _("Select all chroots"));
+
+    chrootenv.add_options()
+      ("directory", opt::value<std::string>(&this->directory),
+       _("Directory to use"))
+      ("preserve-environment,d",
+       _("Preserve user environment"));
+  }
+
+  void
+  options::check_options ()
+  {
+    // Chain up to check general schroot options.
+    schroot_common::options::check_options();
+
+    if (vm.count("path"))
+      {
+        this->action = ACTION_LOCATION;
+        this->chroots.clear();
+        this->chroots.push_back(this->chroot_path);
+      }
+
+    if (vm.count("all"))
+      {
+        this->all = false;
+        this->all_chroots = true;
+        this->all_sessions = false;
+      }
+
+    if (vm.count("preserve-environment"))
+      this->preserve = true;
+
+    if (this->quiet && this->verbose)
+      {
+        sbuild::log_warning()
+          << _("--quiet and --verbose may not be used at the same time")
+          << endl;
+        sbuild::log_info() << _("Using verbose output") << endl;
+      }
+
+    if (!this->chroots.empty() && all_used())
+      {
+        sbuild::log_warning()
+          << _("--chroot and --all may not be used at the same time")
+          << endl;
+        sbuild::log_info() << _("Using --chroots only") << endl;
+        this->all = this->all_chroots = this->all_sessions = false;
+      }
+
+    if (this->all == true)
+      {
+        this->all_chroots = true;
+        this->all_sessions = true;
+      }
+  }
 
-void
-options::add_options ()
-{
-  // Chain up to add general schroot options.
-  schroot_common::options::add_options();
-
-  actions.add_options()
-    ("path,p", opt::value<std::string>(&this->chroot_path),
-     _("Print path to selected chroot"));
-
-  chroot.add_options()
-    ("all,a",
-     _("Select all chroots"));
-
-  chrootenv.add_options()
-    ("directory", opt::value<std::string>(&this->directory),
-     _("Directory to use"))
-    ("preserve-environment,d",
-     _("Preserve user environment"));
-}
-
-void
-options::check_options ()
-{
-  // Chain up to check general schroot options.
-  schroot_common::options::check_options();
-
-  if (vm.count("path"))
-    {
-      this->action = ACTION_LOCATION;
-      this->chroots.clear();
-      this->chroots.push_back(this->chroot_path);
-    }
-
-  if (vm.count("all"))
-    {
-      this->all = false;
-      this->all_chroots = true;
-      this->all_sessions = false;
-    }
-
-  if (vm.count("preserve-environment"))
-    this->preserve = true;
-
-  if (this->quiet && this->verbose)
-    {
-      sbuild::log_warning()
-        << _("--quiet and --verbose may not be used at the same time")
-        << endl;
-      sbuild::log_info() << _("Using verbose output") << endl;
-    }
-
-  if (!this->chroots.empty() && all_used())
-    {
-      sbuild::log_warning()
-        << _("--chroot and --all may not be used at the same time")
-        << endl;
-      sbuild::log_info() << _("Using --chroots only") << endl;
-      this->all = this->all_chroots = this->all_sessions = false;
-    }
-
-  if (this->all == true)
-    {
-      this->all_chroots = true;
-      this->all_sessions = true;
-    }
 }
diff --git a/bin/dchroot/session.cc b/bin/dchroot/session.cc
index 21a6e00f..03938846 100644
--- a/bin/dchroot/session.cc
+++ b/bin/dchroot/session.cc
@@ -37,87 +37,91 @@ using std::cout;
 using std::endl;
 using sbuild::_;
 using boost::format;
-using namespace dchroot;
 
-session::session (std::string const&                  service,
-                  operation                           operation,
-                  sbuild::session::chroot_list const& chroots):
-  dchroot_common::session(service, operation, chroots)
+namespace dchroot
 {
-}
 
-session::~session ()
-{
-}
+  session::session (std::string const&                  service,
+                    operation                           operation,
+                    sbuild::session::chroot_list const& chroots):
+    dchroot_common::session(service, operation, chroots)
+  {
+  }
+
+  session::~session ()
+  {
+  }
+
+  sbuild::string_list
+  session::get_login_directories (sbuild::chroot::chroot::ptr& session_chroot,
+                                  sbuild::environment const&   env) const
+  {
+    sbuild::string_list ret;
+
+    std::string const& wd(get_auth()->get_wd());
+    if (!wd.empty())
+      {
+        // Set specified working directory.
+        ret.push_back(wd);
+      }
+    else
+      {
+        // Set current working directory only if preserving environment.
+        // Only change to home if not preserving the environment.
+        if (get_preserve_environment() ||
+            session_chroot->get_preserve_environment())
+          ret.push_back(this->sbuild::session::cwd);
+        else
+          ret.push_back(get_auth()->get_home());
+
+        // Final fallback to root.
+        if (std::find(ret.begin(), ret.end(), "/") == ret.end())
+          ret.push_back("/");
+      }
+
+    return ret;
+  }
+
+  void
+  session::get_user_command (sbuild::chroot::chroot::ptr& session_chroot,
+                             std::string&                 file,
+                             sbuild::string_list&         command,
+                             sbuild::environment const&   env) const
+  {
+    std::string programstring = sbuild::string_list_to_string(command, " ");
+
+    command.clear();
+    command.push_back("/bin/sh");
+    command.push_back("-c");
+    command.push_back(programstring);
+
+    file = command[0];
+
+    sbuild::log_debug(sbuild::DEBUG_NOTICE) << "file=" << file << endl;
+
+    std::string commandstring = sbuild::string_list_to_string(command, " ");
+    sbuild::log_debug(sbuild::DEBUG_NOTICE)
+      << format("Running command: %1%") % commandstring << endl;
+    if (get_auth()->get_uid() == 0 ||
+        get_auth()->get_ruid() != get_auth()->get_uid())
+      syslog(LOG_USER|LOG_NOTICE, "[%s chroot] (%s->%s) Running command: \"%s\"",
+             session_chroot->get_name().c_str(),
+             get_auth()->get_ruser().c_str(),
+             get_auth()->get_user().c_str(),
+             commandstring.c_str());
+
+    if (session_chroot->get_verbosity() != sbuild::chroot::chroot::VERBOSITY_QUIET)
+      {
+        std::string format_string;
+        // TRANSLATORS: %1% = chroot name
+        // TRANSLATORS: %2% = command
+        format_string = (_("[%1% chroot] Running command: “%2%”"));
+
+        format fmt(format_string);
+        fmt % session_chroot->get_name()
+          % programstring;
+        sbuild::log_info() << fmt << endl;
+      }
+  }
 
-sbuild::string_list
-session::get_login_directories (sbuild::chroot::chroot::ptr& session_chroot,
-                                sbuild::environment const&   env) const
-{
-  sbuild::string_list ret;
-
-  std::string const& wd(get_auth()->get_wd());
-  if (!wd.empty())
-    {
-      // Set specified working directory.
-      ret.push_back(wd);
-    }
-  else
-    {
-      // Set current working directory only if preserving environment.
-      // Only change to home if not preserving the environment.
-      if (get_preserve_environment() ||
-          session_chroot->get_preserve_environment())
-        ret.push_back(this->sbuild::session::cwd);
-      else
-        ret.push_back(get_auth()->get_home());
-
-      // Final fallback to root.
-      if (std::find(ret.begin(), ret.end(), "/") == ret.end())
-        ret.push_back("/");
-    }
-
-  return ret;
-}
-
-void
-session::get_user_command (sbuild::chroot::chroot::ptr& session_chroot,
-                           std::string&                 file,
-                           sbuild::string_list&         command,
-                           sbuild::environment const&   env) const
-{
-  std::string programstring = sbuild::string_list_to_string(command, " ");
-
-  command.clear();
-  command.push_back("/bin/sh");
-  command.push_back("-c");
-  command.push_back(programstring);
-
-  file = command[0];
-
-  sbuild::log_debug(sbuild::DEBUG_NOTICE) << "file=" << file << endl;
-
-  std::string commandstring = sbuild::string_list_to_string(command, " ");
-  sbuild::log_debug(sbuild::DEBUG_NOTICE)
-    << format("Running command: %1%") % commandstring << endl;
-  if (get_auth()->get_uid() == 0 ||
-      get_auth()->get_ruid() != get_auth()->get_uid())
-    syslog(LOG_USER|LOG_NOTICE, "[%s chroot] (%s->%s) Running command: \"%s\"",
-           session_chroot->get_name().c_str(),
-           get_auth()->get_ruser().c_str(),
-           get_auth()->get_user().c_str(),
-           commandstring.c_str());
-
-  if (session_chroot->get_verbosity() != sbuild::chroot::chroot::VERBOSITY_QUIET)
-    {
-      std::string format_string;
-      // TRANSLATORS: %1% = chroot name
-      // TRANSLATORS: %2% = command
-      format_string = (_("[%1% chroot] Running command: “%2%”"));
-
-      format fmt(format_string);
-      fmt % session_chroot->get_name()
-        % programstring;
-      sbuild::log_info() << fmt << endl;
-    }
 }
diff --git a/bin/schroot/main.cc b/bin/schroot/main.cc
index 79d5cd53..aab79ac0 100644
--- a/bin/schroot/main.cc
+++ b/bin/schroot/main.cc
@@ -35,43 +35,47 @@
 using std::endl;
 using boost::format;
 using sbuild::_;
-using namespace schroot;
 
-main::main (schroot_common::options::ptr& options):
-  schroot_common::main("schroot",
-                       _("[OPTION…] [COMMAND] — run command or shell in a chroot"),
-                       options,
-                       true)
+namespace schroot
 {
-}
 
-main::~main ()
-{
-}
+  main::main (schroot_common::options::ptr& options):
+    schroot_common::main("schroot",
+                         _("[OPTION…] [COMMAND] — run command or shell in a chroot"),
+                         options,
+                         true)
+  {
+  }
 
-void
-main::action_list ()
-{
-  // This list is pre-validated.
-  for (const auto& chroot : this->chroot_names)
-    std::cout << chroot << '\n';
-  std::cout << std::flush;
-}
+  main::~main ()
+  {
+  }
 
-void
-main::create_session(sbuild::session::operation sess_op)
-{
-  sbuild::log_debug(sbuild::DEBUG_INFO) << "Creating schroot session" << endl;
+  void
+  main::action_list ()
+  {
+    // This list is pre-validated.
+    for (const auto& chroot : this->chroot_names)
+      std::cout << chroot << '\n';
+    std::cout << std::flush;
+  }
 
-  this->session = sbuild::session::ptr
-    (new sbuild::session("schroot", sess_op, this->chroot_objects));
-}
+  void
+  main::create_session(sbuild::session::operation sess_op)
+  {
+    sbuild::log_debug(sbuild::DEBUG_INFO) << "Creating schroot session" << endl;
 
-void
-main::add_session_auth ()
-{
-  schroot_common::main::add_session_auth();
+    this->session = sbuild::session::ptr
+      (new sbuild::session("schroot", sess_op, this->chroot_objects));
+  }
+
+  void
+  main::add_session_auth ()
+  {
+    schroot_common::main::add_session_auth();
+
+    if (!this->options->user.empty())
+      this->session->get_auth()->set_user(this->options->user);
+  }
 
-  if (!this->options->user.empty())
-    this->session->get_auth()->set_user(this->options->user);
 }
diff --git a/bin/schroot/options.cc b/bin/schroot/options.cc
index 48f1416c..19a1bd86 100644
--- a/bin/schroot/options.cc
+++ b/bin/schroot/options.cc
@@ -30,120 +30,124 @@ using std::endl;
 using boost::format;
 using sbuild::_;
 namespace opt = boost::program_options;
-using namespace schroot;
 
-options::options ():
-  schroot_common::options()
+namespace schroot
 {
-}
-
-options::~options ()
-{
-}
-
-void
-options::add_options ()
-{
-  // Chain up to add general schroot options.
-  schroot_common::options::add_options();
-
-  actions.add_options()
-    ("location",
-     _("Print location of selected chroots"));
-
-  chroot.add_options()
-    ("all,a",
-     _("Select all chroots and active sessions"))
-    ("all-chroots",
-     _("Select all chroots"))
-    ("all-sessions",
-     _("Select all active sessions"))
-    ("all-source-chroots",
-     _("Select all source chroots"))
-    ("exclude-aliases",
-     _("Do not include aliases"));
-
-  chrootenv.add_options()
-    ("directory,d", opt::value<std::string>(&this->directory),
-     _("Directory to use"))
-    ("shell,s", opt::value<std::string>(&this->shell),
-     _("Shell to use as login shell"))
-    ("user,u", opt::value<std::string>(&this->user),
-     _("Username (default current user)"))
-    ("preserve-environment,p",
-     _("Preserve user environment"))
-    ("option,o", opt::value<sbuild::string_list>(&this->useroptions),
-     _("Set option"));
-
-  session_actions.add_options()
-    ("automatic-session",
-     _("Begin, run and end a session automatically (default)"))
-    ("begin-session,b",
-     _("Begin a session; returns a session ID"))
-    ("recover-session",
-     _("Recover an existing session"))
-    ("run-session,r",
-     _("Run an existing session"))
-    ("end-session,e",
-     _("End an existing session"));
-
-  session_options.add_options()
-    ("session-name,n", opt::value<std::string>(&this->session_name),
-     _("Session name (defaults to an automatically generated name)"))
-    ("force,f",
-     _("Force operation, even if it fails"));
-}
-
 
-void
-options::check_options ()
-{
-  // Chain up to check general schroot options.
-  schroot_common::options::check_options();
-
-  if (vm.count("location"))
-    this->action = ACTION_LOCATION;
-
-  if (vm.count("all"))
-    this->all = true;
-  if (vm.count("all-chroots"))
-    this->all_chroots = true;
-  if (vm.count("all-sessions"))
-    this->all_sessions = true;
-  if (vm.count("all-source-chroots"))
-    this->all_source_chroots = true;
-  if (vm.count("exclude-aliases"))
-    this->exclude_aliases = true;
-
-  if (vm.count("preserve-environment"))
-    this->preserve = true;
-
-  if (vm.count("automatic-session"))
-    this->action = ACTION_SESSION_AUTO;
-  if (vm.count("begin-session"))
-    this->action = ACTION_SESSION_BEGIN;
-  if (vm.count("recover-session"))
-    this->action = ACTION_SESSION_RECOVER;
-  if (vm.count("run-session"))
-    this->action = ACTION_SESSION_RUN;
-  if (vm.count("end-session"))
-    this->action = ACTION_SESSION_END;
-  if (vm.count("force"))
-    this->session_force = true;
-
-  if (this->all == true)
-    {
+  options::options ():
+    schroot_common::options()
+  {
+  }
+
+  options::~options ()
+  {
+  }
+
+  void
+  options::add_options ()
+  {
+    // Chain up to add general schroot options.
+    schroot_common::options::add_options();
+
+    actions.add_options()
+      ("location",
+       _("Print location of selected chroots"));
+
+    chroot.add_options()
+      ("all,a",
+       _("Select all chroots and active sessions"))
+      ("all-chroots",
+       _("Select all chroots"))
+      ("all-sessions",
+       _("Select all active sessions"))
+      ("all-source-chroots",
+       _("Select all source chroots"))
+      ("exclude-aliases",
+       _("Do not include aliases"));
+
+    chrootenv.add_options()
+      ("directory,d", opt::value<std::string>(&this->directory),
+       _("Directory to use"))
+      ("shell,s", opt::value<std::string>(&this->shell),
+       _("Shell to use as login shell"))
+      ("user,u", opt::value<std::string>(&this->user),
+       _("Username (default current user)"))
+      ("preserve-environment,p",
+       _("Preserve user environment"))
+      ("option,o", opt::value<sbuild::string_list>(&this->useroptions),
+       _("Set option"));
+
+    session_actions.add_options()
+      ("automatic-session",
+       _("Begin, run and end a session automatically (default)"))
+      ("begin-session,b",
+       _("Begin a session; returns a session ID"))
+      ("recover-session",
+       _("Recover an existing session"))
+      ("run-session,r",
+       _("Run an existing session"))
+      ("end-session,e",
+       _("End an existing session"));
+
+    session_options.add_options()
+      ("session-name,n", opt::value<std::string>(&this->session_name),
+       _("Session name (defaults to an automatically generated name)"))
+      ("force,f",
+       _("Force operation, even if it fails"));
+  }
+
+
+  void
+  options::check_options ()
+  {
+    // Chain up to check general schroot options.
+    schroot_common::options::check_options();
+
+    if (vm.count("location"))
+      this->action = ACTION_LOCATION;
+
+    if (vm.count("all"))
+      this->all = true;
+    if (vm.count("all-chroots"))
       this->all_chroots = true;
+    if (vm.count("all-sessions"))
       this->all_sessions = true;
+    if (vm.count("all-source-chroots"))
       this->all_source_chroots = true;
-    }
-
-  for (const auto& useroption : this->useroptions)
-    {
-      std::string::size_type sep = useroption.find_first_of('=', 0);
-      std::string key = useroption.substr(0,sep);
-      ++sep;
-      std::string value = useroption.substr(sep);
-      this->useroptions_map.insert(std::make_pair(key,value));
-    }
+    if (vm.count("exclude-aliases"))
+      this->exclude_aliases = true;
+
+    if (vm.count("preserve-environment"))
+      this->preserve = true;
+
+    if (vm.count("automatic-session"))
+      this->action = ACTION_SESSION_AUTO;
+    if (vm.count("begin-session"))
+      this->action = ACTION_SESSION_BEGIN;
+    if (vm.count("recover-session"))
+      this->action = ACTION_SESSION_RECOVER;
+    if (vm.count("run-session"))
+      this->action = ACTION_SESSION_RUN;
+    if (vm.count("end-session"))
+      this->action = ACTION_SESSION_END;
+    if (vm.count("force"))
+      this->session_force = true;
+
+    if (this->all == true)
+      {
+        this->all_chroots = true;
+        this->all_sessions = true;
+        this->all_source_chroots = true;
+      }
+
+    for (const auto& useroption : this->useroptions)
+      {
+        std::string::size_type sep = useroption.find_first_of('=', 0);
+        std::string key = useroption.substr(0,sep);
+        ++sep;
+        std::string value = useroption.substr(sep);
+        this->useroptions_map.insert(std::make_pair(key,value));
+      }
+  }
+
 }
diff --git a/bin/schroot/schroot.cc b/bin/schroot/schroot.cc
index 395af026..7aeffb51 100644
--- a/bin/schroot/schroot.cc
+++ b/bin/schroot/schroot.cc
@@ -25,7 +25,6 @@
 
 using std::endl;
 using boost::format;
-using namespace schroot;
 
 /**
  * Main routine.