VestaConfig.C

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta 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
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#include <Basics.H>
#include <Generics.H>
#include "VestaConfig.H"
#include <OS.H>

#include <sstream>

using std::ostringstream;
using std::istringstream;
using std::ifstream;

//  **********************************************************
//  * Configuration parameters (documented in VestaConfig.H) *
//  **********************************************************

#define VESTA_CONFIG "VESTACONFIG"
#define DEFAULT_CONFIG_FILE_NAME "vesta.cfg"
#define DEFAULT_GLOBAL_CONFIG_FILE_NAME "/etc/vesta.cfg"
#define HOME_DIRECTORY "HOME"

#define MAX_INCLUDE_DEPTH 10

//  *******************************************
//  * Global variables (static class members) *
//  *******************************************

static Basics::mutex m;        // initialized by constructor
static Text  location("");     // configuration file location - don't
                               // know where it is, yet
static int   include_depth = 0;

// Data structures holding parsed config file representation
static TextTextTbl *tbl = NULL;
typedef Table<Text,TextSeq *>::Default SectionVarsTbl;
typedef Table<Text,TextSeq *>::Iterator SectionVarsIter;
static SectionVarsTbl *vars_tbl = NULL;

//  *************
//  * Utilities *
//  *************

static void report_error(const Text &msg, int line_no = -1)
{
  Text error_msg(msg);
  if (location != "") {
    ostringstream s;
    if (line_no >= 0) s << ", line #" << line_no;
    error_msg = error_msg + " (file: " + location + s.str() + ")";
  };
  throw(VestaConfig::failure(error_msg));
}

static void delete_parse()
{
  include_depth = 0;
  if (tbl != NULL) { delete tbl; tbl = NULL; }
  if (vars_tbl != NULL)
    {
      SectionVarsIter it(vars_tbl);
      Text sect;
      TextSeq *vars;
      while(it.Next(sect, vars))
        delete vars;
      delete vars_tbl; vars_tbl = NULL;
    }
}

static Text make_key(const Text &section, const Text &name) {
  int len1 = section.Length();
  int len2 = name.Length() + 1; // include terminating NULL character
  char* buff = NEW_PTRFREE_ARRAY(char, 2 + len1 + len2);
  buff[0] = '['; buff[1+len1] = ']';
  memcpy(buff+1, section.cchars(), len1);
  memcpy(buff+2+len1, name.cchars(), len2);
  Text t(buff);
  delete [] buff;
  return t;
}

static void locate_file();
static void parse();
static void parse_file(const Text &file_name);
static bool include_file(const Text &line);

//  *********************************
//  * Configuration file processing *
//  *********************************

void VestaConfig::set_location(const Text &file_name)
{
  m.lock();
  delete_parse();
  location = file_name;
  m.unlock();
}

Text VestaConfig::get_location() throw(VestaConfig::failure)
{
  Text loc;
  m.lock();
  try {
    locate_file();
  } catch (...) { m.unlock(); throw; }
  loc = location;
  m.unlock();
  return loc;
}

static void locate_file()
{
  // Assumes m is locked.
  if (location != "") return;

  // set_location was never called
  char *v(getenv(VESTA_CONFIG));
  if (v != NULL) { location = v; return; }

  // The environment variable VESTA_CONFIG isn't defined.
  // Try home directory.
  struct stat dummy;
  v = getenv(HOME_DIRECTORY);
  if (v != NULL) {
    Text path = Text(v) + PathnameSep + DEFAULT_CONFIG_FILE_NAME;
    if (stat(path.chars(), &dummy) == SYSOK) { location = path; return; }
  }

  // Try default global configuration file.
  if (stat(DEFAULT_GLOBAL_CONFIG_FILE_NAME, &dummy) == SYSOK) {
      location = Text(DEFAULT_GLOBAL_CONFIG_FILE_NAME);
      return;
  }

  report_error("Can't find configuration file!");
}

static Text strip_whitespace(const Text &t)
{
  int j = t.Length()-1;
  while (j > 0 && (t[j] == ' ' || t[j] == '\t')) j--;
  int i = 0;
  while (i <= j && (t[i] == ' ' || t[i] == '\t')) i++;
  return t.Sub(i, j-i+1);
}

static void parse()
{
  // Assumes m is locked.

  if (tbl != NULL) return;     // already parsed

  locate_file();

  try {
    parse_file(location.chars());
  } catch (VestaConfig::failure f) { delete_parse(); throw(f); }

  if (tbl == NULL) report_error("Empty configuration file");
}

static void parse_file(const Text &file_name) {
  ifstream cf(file_name.chars());
  if (!cf) throw VestaConfig::failure("Can't open file: " + file_name);

  int line_no = 0;
  Text section;

  try {
    while (!cf.eof()) {
      Text line("");
      for (;;)  {
        char buff[100];
        (void) cf.getline(buff, sizeof(buff));
        line = line + buff;
#if defined(__DECCXX)
        // Work around a bug in the Compaq C++ iostream library.
        // According to the ISO C++ standard, getline is supposed to
        // set the 'fail' state bit when the buffer is too small for
        // the line.  The Compaq C++ RTL doesn't do so.  This makes it
        // impossible to differentiate between a long line which we
        // should continue to read and a line which fills the buffer
        // an integral number of times.
        if (cf.gcount() != (sizeof(buff) - 1)) break;
#else
        if(!cf.fail() || cf.eof()) break; 
#endif
        // we overflowed the buffer, so compliant implementations of
        // basic_ios will set the fail bit.  We clear it now, as we're
        // about to read the next chunk of the line.
        cf.clear();
      }

      line_no++;
      line = strip_whitespace(line);

      if (!(line.Length() == 0 || line[0] == ';' ||
            (line.Length() > 1 && line[0] == '/' && line[1] == '/'))) {
        // Not a blank or comment line; analyze it.
        if (line[0] == '[') {
          if (line[line.Length()-1] != ']') 
            throw VestaConfig::failure("Missing ]");
          line = strip_whitespace(line.Sub(1, line.Length()-2));
          // Look for special case of [ include <filename> ]
          if (include_file(line))
              section = Text("");
          else
              section = line;
        }
        else {
          int i = line.FindChar('=');
          if (i < 0) throw VestaConfig::failure("Missing =");
          if (section.Empty())
            throw VestaConfig::failure("Missing section name");
          Text name = strip_whitespace(line.Sub(0, i));
          if (name.Empty())
            throw VestaConfig::failure("Missing name field");
          Text key(make_key(section, name));
          Text value(strip_whitespace(line.Sub(i+1)));
          if (tbl == NULL)
            tbl = NEW(TextTextTbl);
          bool intbl = tbl->Put(key, value);
          if(!intbl)
            {
              // No previous value for this setting.  Record it in
              // vars_tbl.
              if(vars_tbl == 0)
                vars_tbl = NEW(SectionVarsTbl);
              TextSeq *sect_vars;
              if(!vars_tbl->Get(section, sect_vars))
                {
                  sect_vars = NEW(TextSeq);
                  vars_tbl->Put(section, sect_vars);
                }
              sect_vars->addhi(name);
            }
        }
      }
    }
  } catch (VestaConfig::failure f) {
    Text error_msg;
    ostringstream s;
    s << ", line #" << line_no;
    // Add backtrace line to error report.
    error_msg = f.msg + "\nfile: " + file_name + s.str();
    throw(VestaConfig::failure(error_msg));
  }
  
}

static bool include_file(const Text &line) {
  int i;
  const Text incl("include");

  if ((i = line.FindChar(' ')) < 0 || line.Sub(0, i) != incl) return false;
  Text file_name(strip_whitespace(line.Sub(i)));
  if (file_name.Length() == 0)
      return false;  // ordinary section named [include]

  include_depth++;
  if (include_depth > MAX_INCLUDE_DEPTH)
    throw VestaConfig::failure("[include] statements are nested too deeply.");

  parse_file(file_name);

  include_depth--;

  return true;  
}

//  *****************
//  * Interrogation *
//  *****************

bool VestaConfig::get(const Text &section, const Text &name, Text &value)
     throw(VestaConfig::failure)
{
  m.lock();

  try {
    parse();
  } catch (failure f) { m.unlock(); throw(f); }

  Text key(make_key(section, name));

  bool result = tbl->Get(key, value);

  m.unlock();
  return result;
}

Text VestaConfig::get_Text(const Text &section, const Text &name)
    throw(VestaConfig::failure)
{
  Text value;
  if (get(section, name, value)) return value;
  report_error("The name '" + name + "' in section '" + section +
                "' could not be found");
  return value; // not reached
}

int VestaConfig::get_int(const Text &section, const Text &name)
    throw(VestaConfig::failure)
{
  Text txt(get_Text(section, name));
  istringstream ss(txt.chars());
  int value;
  if (!(ss >> value))
    report_error("The value for ([" + section + "], "
                 + name + ") isn't an integer");
  return value;
}

bool VestaConfig::get_bool(const Text &section, const Text &name)
  throw(VestaConfig::failure)
{
  Text txt(get_Text(section, name));

  if((strcasecmp("yes", txt.cchars()) == 0) ||
     (strcasecmp("on", txt.cchars()) == 0) ||
     (strcasecmp("true", txt.cchars()) == 0))
    {
      return true;
    }
  else if((strcasecmp("no", txt.cchars()) == 0) ||
          (strcasecmp("off", txt.cchars()) == 0) ||
          (strcasecmp("false", txt.cchars()) == 0))
    {
      return false;
    }
  else
    {
      istringstream ss(txt.chars());
      int value;
      if (!(ss >> value))
        report_error("The value for ([" + section + "], "
                     + name + ") isn't a boolean");
      return (value != 0);
    }
}

bool VestaConfig::is_set(const Text &section, const Text &name)
  throw(VestaConfig::failure)
{
  m.lock();

  try {
    parse();
  } catch (failure f) { m.unlock(); throw(f); }

  Text key(make_key(section, name));

  Text value;
  bool result = tbl->Get(key, value);

  m.unlock();
  return result;
}

float VestaConfig::get_float(const Text &section, const Text &name)
    throw(VestaConfig::failure)
{
  Text txt(get_Text(section, name));
  istringstream ss(txt.chars());
  float value;
  if (!(ss >> value))
    report_error("The value for ([" + section + "], "
                 + name + ") isn't a floating-point number");
  return value;
}

TextSeq VestaConfig::sections()
  throw(VestaConfig::failure)
{
  m.lock();

  try {
    parse();
  } catch (failure f) { m.unlock(); throw(f); }

  TextSeq result;

  if(vars_tbl != 0)
    {
      SectionVarsIter it(vars_tbl);
      Text sect;
      TextSeq *vars;
      while(it.Next(sect, vars))
        result.addhi(sect);
    }

  m.unlock();

  return result;
}

TextSeq VestaConfig::section_vars(const Text &section)
  throw(VestaConfig::failure)
{
  m.lock();

  try {
    parse();
  } catch (failure f) { m.unlock(); throw(f); }

  TextSeq result, *sect_vars = 0;

  if((vars_tbl != 0) && vars_tbl->Get(section, sect_vars))
    result = *sect_vars;

  m.unlock();

  return result;
}

---