source: trunk/debathena/third/schroot/bin/dchroot-dsa/dchroot-dsa-chroot-config.cc @ 24167

/* 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/>.
 *
 *********************************************************************/

#include <config.h>

#include <sbuild/sbuild-chroot-plain.h>
#include <sbuild/sbuild-log.h>
#include <sbuild/sbuild-parse-error.h>

#include "dchroot-dsa-chroot-config.h"

#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <iostream>

#include <boost/format.hpp>

using std::endl;
using sbuild::_;
using sbuild::keyfile;
using boost::format;
using namespace dchroot_dsa;

chroot_config::chroot_config ():
  sbuild::chroot_config()
{
}

chroot_config::chroot_config (std::string const& file,
                              bool               active):
  sbuild::chroot_config(file, active)
{
}

chroot_config::~chroot_config ()
{
}

void
chroot_config::parse_data (std::istream& stream,
                           bool          active)
{
  active = false; // dchroot does not support sessions.

  size_t linecount = 0;
  std::string line;
  std::string chroot_name;
  std::string chroot_location;

  sbuild::keyfile kconfig;

  while (std::getline(stream, line))
    {
      linecount++;

      if (line[0] == '#')
        {
          // Comment line; do nothing.
        }
      else if (line.length() == 0)
        {
          // Empty line; do nothing.
        }
      else // Item
        {
          static const char *whitespace = " \t:;,";

          // Get chroot name
          std::string::size_type cstart = line.find_first_not_of(whitespace);
          std::string::size_type cend = line.find_first_of(whitespace, cstart);

          // Get chroot location
          std::string::size_type lstart = line.find_first_not_of(whitespace,
                                                                 cend);
          std::string::size_type lend = line.find_first_of(whitespace, lstart);

          if (cstart == std::string::npos)
            throw keyfile::error(linecount, keyfile::INVALID_LINE, line);

          std::string chroot_name = line.substr(cstart, cend - cstart);

          std::string location;
          if (lstart != std::string::npos)
            location = line.substr(lstart, lend - lstart);

          // DSA dchroot parses valid users.
          sbuild::string_list users;
          if (lend != std::string::npos)
            users = sbuild::split_string(line.substr(lend), whitespace);

          // Add details to keyfile.
          if (kconfig.has_group(chroot_name))
            throw keyfile::error(linecount, keyfile::DUPLICATE_GROUP,
                                 chroot_name);
          else
            kconfig.set_group(chroot_name, "", linecount);

          kconfig.set_value(chroot_name, "type", "plain", "", linecount);

          // TRANSLATORS: %1% = chroot name
          format fmt(_("%1% chroot (dchroot-dsa compatibility)"));
          fmt % chroot_name;

          kconfig.set_value(chroot_name, "description", fmt, "", linecount);

          if (lstart != std::string::npos)
            kconfig.set_value(chroot_name, "location", location, "", linecount);

          kconfig.set_list_value(chroot_name, "users",
                                 users.begin(), users.end(),
                                 "", linecount);
        }
    }

  load_keyfile(kconfig, active);
}