rconfig.cc

Go to the documentation of this file.

#include "config.h"

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
#include <cctype>

#include "asserts.h"
#include "error.h"
#include "estring.h"
#include "fs.h"
#include "tstamp.h"

#include "rconfig.h"

//----------------------------------------------------------------------------

/** Reset to a default value */
void archive_path_element::clear(void)
{
        m_type = jobname;
        m_literal.erase();
}

/** C'tor */
archive_path_element::archive_path_element()
{
        clear();
}

/** C'tor */
archive_path_element::archive_path_element(
        const archive_path_element& a_class)
{
        clear();
        assign(a_class);
}

/** C'tor */
archive_path_element::archive_path_element(
        const archive_path_element::element_type& a_enum
        )
{
        clear();
        assign(a_enum);
}

/** C'tor */
archive_path_element::archive_path_element(const std::string& a_str)
{
        clear();
        assign(a_str);
}

/** Assign the value from another archive_path_element instance */
void archive_path_element::assign(const archive_path_element& a_class)
{
        if (this == &a_class)
                return;

        if (a_class.type() == literal)
                assign(a_class.str());
        else
                assign(a_class.type());
}

/** Assign any type except literal */
void archive_path_element::assign(
        const archive_path_element::element_type& a_enum
        )
{
        m_type = a_enum;
        if (m_type != literal) {
                m_literal.erase();
        }
}

/** Assign a literal */
void archive_path_element::assign(const std::string& a_str)
{
        std::string es;
        std::string str;
        std::string::size_type idx;

        TRY_nomem(es = "Invalid archive-path keyword: \"");
        TRY_nomem(es += a_str);
        TRY_nomem(es += "\"");

        if (a_str.size() == 0) {
                throw(ERROR(0,es));
        }
        if (a_str[0] == '"') {
                if (a_str.size() < 3) {
                        throw(ERROR(0,es));
                }
                if (a_str[a_str.size()-1] != '"') {
                        throw(ERROR(0,es));
                }
                TRY_nomem(str = a_str.substr(1,a_str.size()-2));

                idx = str.find('"');
                while (idx != std::string::npos) {
                        if ((idx > 0) && (str[idx-1] != '\\'))
                                throw(ERROR(0,es));
                        idx = str.find('"',idx+1);
                }

                idx = str.find("\\\"");
                while (idx != std::string::npos) {
                        str.erase(idx,1);
                        idx = str.find("\\\"");
                }

                TRY_nomem(m_literal = str);
                m_type = literal;
        }
        else {
                str = estring(a_str).lower();
                if (str == "jobname") {
                        assign(jobname);
                }
                else if (str == "groupname") {
                        assign(groupname);
                }
                else if (str == "hostname") {
                        assign(hostname);
                }
                else if (str == "pathname") {
                        assign(pathname);
                }
                else if (str == "permutation") {
                        assign(permutation);
                }
                else {
                        throw(ERROR(0,es));
                }
        }
}

/** Retrieve the current type */
const archive_path_element::element_type& 
        archive_path_element::type(void) const
{
        return(m_type);
}

/** Retrieve the current literal value */
const std::string& archive_path_element::value(void) const
{
        return(m_literal);
}

/** Construct a string of the current value */
const std::string archive_path_element::str(void) const
{
        std::string::size_type idx;
        std::string value;

        if (m_type == jobname) {
                TRY_nomem(value = "jobname");
        }
        else if (m_type == groupname) {
                TRY_nomem(value = "groupname");
        }
        else if (m_type == hostname) {
                TRY_nomem(value = "hostname");
        }
        else if (m_type == pathname) {
                TRY_nomem(value = "pathname");
        }
        else if (m_type == permutation) {
                TRY_nomem(value = "permutation");
        }
        else {
                TRY_nomem(value = "\"");
                for (idx = 0; idx != m_literal.size(); idx++) {
                        if (m_literal[idx] == '"') {
                                TRY_nomem(value += '\\');
                        }
                        TRY_nomem(value += m_literal[idx]);
                }
                TRY_nomem(value += '"');
        }

        return(value);
}

/** Assignment */
archive_path_element& 
        archive_path_element::operator=(const archive_path_element& a_class)
{
        clear();
        assign(a_class);

        return(*this);
}

/** Assignment */
archive_path_element& 
        archive_path_element::operator=(
                const archive_path_element::element_type a_enum)
{
        clear();
        assign(a_enum);

        return(*this);
}

/** Assignment */
archive_path_element& 
        archive_path_element::operator=(const std::string& a_str)
{
        clear();
        assign(a_str);

        return(*this);
}

//----------------------------------------------------------------------------

/** Reset to a default value */
void archive_path::reset(void)
{
        clear();
        push_back("hostname/pathname");
}

/** C'tor */
archive_path::archive_path()
{
        reset();
}

/** C'tor */
archive_path::archive_path(const archive_path& a_class)
{
        push_back(a_class);
}

/** C'tor */
archive_path::archive_path(const archive_path_element& a_class)
{
        push_back(a_class);
}

/** C'tor */
archive_path::archive_path(const std::string& a_str)
{
        push_back(a_str);
}

/** Add elements to the path list from another archive_path instance */
void archive_path::push_back(const archive_path& a_class)
{
        const_iterator li;

        for (li = a_class.begin(); li != a_class.end(); li++) {
                TRY_nomem(push_back(*li));
        }
}

/** Add an element to the path list from an archive_path_element instance */
void archive_path::push_back(const archive_path_element& a_class)
{
        TRY_nomem(type::push_back(a_class));
}

/** Parse a string into an archive-path list */
void archive_path::push_back(const std::string& a_str)
{
        std::string es;
        std::string keyword;
        std::string str;
        std::string::size_type idx;
        archive_path_element ape;

        if (a_str.size() == 0)
                return;

        TRY_nomem(str = a_str);
        if (str[0] == '/')
                str.erase(0,1);
        if (str[str.size()-1] == '/')
                str.erase(str.size()-1,1);
        
        while (str.size() > 0) {
                idx = str.find('/');
                if (idx == std::string::npos) {
                        TRY_nomem(keyword = str);
                        str.erase();
                }
                else {
                        TRY_nomem(keyword = str.substr(0,idx));
                        str.erase(0,idx+1);
                }

                ape.clear();
                TRY_nomem(es = "At: \"");
                TRY_nomem(es += keyword);
                TRY_nomem(es += "\"");
                TRY(ape.assign(keyword),es);
                TRY_nomem(push_back(ape));
        }
}

/** Reconstruct a string from an archive-path list */
const std::string archive_path::str(void) const
{
        std::string str;
        const_iterator li;

        for (li = begin(); li != end(); li++) {
                if (li != begin()) {
                        TRY_nomem(str += '/');
                }
                TRY_nomem(str += (*li).str());
        }

        return(str);
}

/** Assign an archive-path list from another archive_path instance */
void archive_path::assign(const archive_path& a_class)
{
        if (this != &a_class) {
                clear();
                push_back(a_class);
        }
}

/** Assign an archive-path list from a single archive_path_element instance */
void archive_path::assign(const archive_path_element& a_class)
{
        clear();
        push_back(a_class);
}

/** Assign an archive-path list from a string (parse the string) */
void archive_path::assign(const std::string& a_str)
{
        clear();
        push_back(a_str);
}

/** Assignment */
archive_path& archive_path::operator=(const archive_path& a_class)
{
        assign(a_class);

        return(*this);
}

/** Assignment */
archive_path& archive_path::operator=(const archive_path_element& a_class)
{
        assign(a_class);

        return(*this);
}

/** Assignment */
archive_path& archive_path::operator=(const std::string& a_str)
{
        assign(a_str);

        return(*this);
}

//----------------------------------------------------------------------------

/** Default behavior */
const uint16 rsync_behavior::default_behavior;

/** Clear all values and set the default to "retry" */
void rsync_behavior::clear(void)
{
        m_map.clear();
        m_default = retry;
}

/** Clear all values and set some sane default actions */
void rsync_behavior::reset(void)
{
        clear();
        m_default = retry;
        TRY_nomem(
                m_map[0] = ok;
                m_map[1] = fail;
                m_map[2] = fail;
                m_map[4] = fail;
                m_map[23] = retry_without_hardlinks;
                m_map[124] = fail;
                m_map[125] = fail;
                m_map[126] = fail;
                m_map[127] = fail;
        );
}

/** C'tor */
rsync_behavior::rsync_behavior()
{
        reset();
}

/** C'tor */
rsync_behavior::rsync_behavior(const rsync_behavior& a_class)
{
        assign(a_class);
}

/** Assign an action to be taken for a specific exit code */
void rsync_behavior::assign(const uint16 a_code, const value_type a_action)
{
        if (a_code == default_behavior)
                m_default = a_action;
        else {
                TRY_nomem(m_map[a_code] = a_action);
        }
}

/** Assign actions to be taken from another rsync_behavior instance */
void rsync_behavior::assign(const rsync_behavior& a_class)
{
        if (this == &a_class)
                return;

        clear();
        m_default = a_class.default_value();
        TRY_nomem(m_map = a_class.map_value());
}

/**
        Assign actions to be taken from a string (parse a string in the form of
        exit-code '=' action)
 */
void rsync_behavior::assign(const std::string& a_str)
{
        std::string es;
        std::string code_str;
        std::string action_str;
        uint16 code;
        rsync_behavior::behavior_type action;
        std::string::size_type idx;

        TRY_nomem(es = "Invalid rsync-behavior value: \"");
        TRY_nomem(es += a_str);
        TRY_nomem(es += "\"");

        TRY_nomem(action_str = a_str);
        idx = 0;
        while (isdigit(action_str[idx]) || (action_str[idx] == '*'))
                ++idx;
        TRY_nomem(code_str = action_str.substr(0,idx));
        action_str.erase(0,idx);
        if (code_str.size() == 0)
                throw(ERROR(0,es));

        idx = 0;
        while ((action_str[idx] == ' ') || (action_str[idx] == '\t'))
                idx++;
        action_str.erase(0,idx);

        if (action_str[0] != '=')
                throw(ERROR(0,es));
        action_str.erase(0,1);

        idx = 0;
        while ((action_str[idx] == ' ') || (action_str[idx] == '\t'))
                idx++;
        action_str.erase(0,idx);

        if (code_str == "*")
                code = rsync_behavior::default_behavior;
        else
                code = estring(code_str);
        if (estring(action_str).lower() == "ok")
                action = rsync_behavior::ok;
        else if (estring(action_str).lower() == "fail")
                action = rsync_behavior::fail;
        else if (estring(action_str).lower() == "retry")
                action = rsync_behavior::retry;
        else if (estring(action_str).lower() == "retry-without-hardlinks")
                action = rsync_behavior::retry_without_hardlinks;
        else if (estring(action_str).lower() == "ok")
                action = rsync_behavior::quit;
        else
                throw(ERROR(0,es));
        assign(code, action);
}

/** Return the action to be taken for a given exit code */
const rsync_behavior::value_type 
        rsync_behavior::operator[](const uint16 a_code) const
{
        if (a_code == default_behavior) {
                return(m_default);
        }
        if (m_map.find(a_code) != m_map.end()) {
                return(m_map.find(a_code)->second);
        }
        return(m_default);
}

/** Return the action to be taken for a given exit code */
rsync_behavior::value_type&
        rsync_behavior::operator[](const uint16 a_code)
{
        if (a_code == default_behavior) {
                return(m_default);
        }
        return(m_map[a_code]);
}

/** Assignment */
rsync_behavior& rsync_behavior::operator=(const rsync_behavior& a_class)
{
        assign(a_class);

        return(*this);
}

/** Assignment */
rsync_behavior& 
        rsync_behavior::operator=(const rsync_behavior::behavior_type a_enum)
{
        assign(default_behavior, a_enum);

        return(*this);
}

/** Assignment */
rsync_behavior& rsync_behavior::operator=(const std::string& a_str)
{
        assign(a_str);

        return(*this);
}

/** Return the default action */
const rsync_behavior::behavior_type rsync_behavior::default_value(void) const
{
        return(m_default);
}

/** Return an std::map of exit codes to actions */
const rsync_behavior::map_type& rsync_behavior::map_value(void) const
{
        return(m_map);
}

//----------------------------------------------------------------------------

/** C'tor */
job::job()
{
        clear();
}

/** C'tor */
job::job(const job& a_job)
{
        clear();
        assign(a_job);
}

/** Clear values */
void job::clear(void)
{
        default_config_path.erase();
        default_config_line = 0;
        config_path.erase();
        config_line = 0;
        archive_path = "hostname/pathname";
        excludes.clear();
        includes.clear();
        groupname.erase();
        hostname.erase();
        jobname.erase();
        paths.clear();
        rsync_behavior.reset();
        rsync_connection = connection_remote;
        rsync_hardlink = true;
        rsync_options.erase();
        rsync_remote_user.erase();
        rsync_remote_path.erase();
        rsync_remote_port = 0;
        rsync_remote_module.erase();
        rsync_retry_count = 3;
        rsync_timeout = 60 * 60 * 4; // 4 hours;
}

/** Assign values from another job instance */
void job::assign(const job& a_job)
{
        clear();

        default_config_path = a_job.default_config_path;
        default_config_line = a_job.default_config_line;
        config_path = a_job.config_path;
        config_line = a_job.config_line;
        archive_path = a_job.archive_path;
        excludes = a_job.excludes;
        includes = a_job.includes;
        groupname = a_job.groupname;
        hostname = a_job.hostname;
        jobname = a_job.jobname;
        paths = a_job.paths;
        rsync_behavior.clear();
        rsync_behavior = a_job.rsync_behavior;
        rsync_connection = a_job.rsync_connection;
        rsync_hardlink = a_job.rsync_hardlink;
        rsync_options = a_job.rsync_options;
        rsync_remote_user = a_job.rsync_remote_user;
        rsync_remote_path = a_job.rsync_remote_path;
        rsync_remote_port = a_job.rsync_remote_port;
        rsync_remote_module = a_job.rsync_remote_module;
        rsync_retry_count = a_job.rsync_retry_count;
        rsync_timeout = a_job.rsync_timeout;
}

/** Assignment */
job& job::operator=(const job& a_job)
{
        assign(a_job);

        return(*this);
}

/** Generate the archive-path subdirectory for this job */
const std::string job::generate_archive_path(const std::string& a_path) const
{
        std::string es;
        std::string path;
        archive_path::const_iterator capi;

        for (capi = archive_path.begin(); capi != archive_path.end(); ++capi) {
                if (capi->type() == archive_path_element::jobname) {
                        if (jobname.size() == 0) {
                                TRY_nomem(es = "archive-path references jobname, ");
                                TRY_nomem(es += "but jobname is empty");
                                throw(ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += jobname);
                }
                else if (capi->type() == archive_path_element::groupname) {
                        if (groupname.size() == 0) {
                                TRY_nomem(es = "archive-path references groupname, ");
                                TRY_nomem(es += "but groupname is empty");
                                throw(ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += groupname);
                }
                else if (capi->type() == archive_path_element::hostname) {
                        if (hostname.size() == 0) {
                                TRY_nomem(es = "archive-path references hostname, ");
                                TRY_nomem(es += "but hostname is empty");
                                throw(ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += hostname);
                }
                else if (capi->type() == archive_path_element::pathname) {
                        if (a_path.size() == 0) {
                                TRY_nomem(es = "archive-path references path name, ");
                                TRY_nomem(es += "but path name is empty");
                                throw(ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += a_path);
                }
                else if (capi->type() == archive_path_element::permutation) {
                        if (a_path.size() == 0) {
                                TRY_nomem(es = "archive-path references path name, ");
                                TRY_nomem(es += "but path name is empty");
                                throw(ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += permute_path(a_path));
                }
                else if (capi->type() == archive_path_element::literal) {
                        if (capi->value().size() == 0) {
                                TRY_nomem(es = "archive-path references literal string, ");
                                TRY_nomem(es += "but literal string value is empty");
                                throw(INTERNAL_ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += capi->value());
                }
                else
                        throw(INTERNAL_ERROR(0,"Unknown archive path element type"));
        }

        // If path does not end with a '/', strip off characters until it does.
        while ((path.size() > 0) && (path[path.size()-1] != '/'))
                path.erase(path.size()-1);

        path = reform_path(path);

        return(path);
}

/** Generate the source path to be passed to rsync on the command line */
const std::string job::generate_source_path(const std::string& a_path) const
{
        estring path;

        if (rsync_connection == connection_server) {
                path += "rsync://";
                if (rsync_remote_user.size() != 0) {
                        path += rsync_remote_user;
                        path += "@";
                }
                TRY_nomem(path += hostname);
                if (rsync_remote_port != 0) {
                        path += ":";
                        path += estring(rsync_remote_port);
                }
                if (rsync_remote_module.size() != 0) {
                        path += "/";
                        path += rsync_remote_module;
                        if ((a_path.size() > 0) && (a_path[0] != '/'))
                                path += "/";
                }
        }
        else if (rsync_connection == connection_remote) {
                if (rsync_remote_user.size() != 0) {
                        path += rsync_remote_user;
                        path += "@";
                }
                path += hostname;
                path += ":";
        }
        path += a_path;

        return(path);
}

/** Find the common pathname among all job paths (may be an empty string) */
const std::string job::common_pathname(void) const
{
        std::string common_path;
        paths_type::size_type pidx;
        std::string::size_type sidx;
        std::string::size_type max_sidx;
        bool same;

        TRY_nomem(common_path = "");
        sidx = 0;
        max_sidx = paths[0].size();
        for (pidx = 0; pidx < paths.size(); pidx++) {
                if (max_sidx > paths[pidx].size()) {
                        max_sidx = paths[pidx].size();
                }
        }
        same = true;
        for (sidx = 0; sidx < max_sidx; sidx++) {
                for (pidx = 0; (same && (pidx < paths.size())); pidx++) {
                        if (pidx == 0)
                                continue;
                        if (paths[pidx-1][sidx] != paths[pidx][sidx])
                                same = false;
                }
                if (same)
                        TRY_nomem(common_path += paths[0][sidx]);
        }
        if (common_path[0] == '/')
                common_path.erase(0,1);
        if ((common_path.size() > 0) && (common_path[common_path.size()-1] == '/'))
                common_path.erase(common_path.size()-1);

        return(common_path);
}

/** Generate a unique ID string for this job */
const std::string job::generate_job_id(void) const
{
        std::string es;
        std::string path;
        archive_path::const_iterator capi;

        for (capi = archive_path.begin(); capi != archive_path.end(); ++capi) {
                if (capi->type() == archive_path_element::jobname) {
                        if (jobname.size() == 0) {
                                TRY_nomem(es = "archive-path references jobname, ");
                                TRY_nomem(es += "but jobname is empty");
                                throw(ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += jobname);
                }
                else if (capi->type() == archive_path_element::groupname) {
                        if (groupname.size() == 0) {
                                TRY_nomem(es = "archive-path references groupname, ");
                                TRY_nomem(es += "but groupname is empty");
                                throw(ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += groupname);
                }
                else if (capi->type() == archive_path_element::hostname) {
                        if (hostname.size() == 0) {
                                TRY_nomem(es = "archive-path references hostname, ");
                                TRY_nomem(es += "but hostname is empty");
                                throw(ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += hostname);
                }
                else if (capi->type() == archive_path_element::pathname) {
                        if (path.size() == 0) {
                                TRY_nomem(path += common_pathname());
                        }
                }
                else if (capi->type() == archive_path_element::permutation) {
                        if (path.size() == 0) {
                                TRY_nomem(path += permute_path(common_pathname()));
                        }
                }
                else if (capi->type() == archive_path_element::literal) {
                        if (capi->value().size() == 0) {
                                TRY_nomem(es = "archive-path references literal string, ");
                                TRY_nomem(es += "but literal string value is empty");
                                throw(INTERNAL_ERROR(0,es));
                        }
                        if (path.size() != 0) {
                                TRY_nomem(path += '/');
                        }
                        TRY_nomem(path += capi->value());
                }
        }

        path = reform_path(path);

        if (path.size() == 0) {
                TRY_nomem(path = jobname);
        }
        return(path);
}

/** Perform sanity checks for the configuration settings of this job */
void job::check(void)
{
        std::string es;
        std::string this_path;
        std::string that_path;
        paths_type::const_iterator cpi;
        configuration_manager::jobs_type::const_iterator cji;
        paths_type::const_iterator cjapi;

        if (
                        (
                                (rsync_connection == connection_remote) 
                                || (rsync_connection == connection_server)
                        )
                        && (hostname.size() == 0)
                )
        {
                TRY_nomem(es = "rsync-connection-type references hostname, ");
                TRY_nomem(es += "but hostname is empty");
                throw(ERROR(0,es));
        }

        if ((rsync_remote_module.size() != 0) 
                && (rsync_connection != connection_server)) 
        {
                TRY_nomem(es = "rsync-remote-module specifies a module, but ");
                TRY_nomem(es = "rsync-connection-type is not server");
                throw(ERROR(0,es));
        }

        if (paths.size() == 0) {
                throw(ERROR(0,"No paths defined for this job"));
        }

        for (cpi = paths.begin() ; cpi != paths.end(); cpi++) {
                TRY_nomem(this_path = generate_archive_path(*cpi));

                for (
                        cji = config.jobs().begin();
                        cji != config.jobs().end();
                        cji++
                        )
                {
                        for (
                                cjapi = cji->paths.begin();
                                cjapi != cji->paths.end();
                                cjapi++
                                )
                        {
                                TRY_nomem(that_path = cji->generate_archive_path(*cjapi));

                                if (this_path == that_path) {
                                        error e(0);

                                        TRY_nomem(es = "Duplicate archive-path values detected");
                                        e.push_back(ERROR_INSTANCE(es));
                                        TRY_nomem(es = "Archive path: \"");
                                        TRY_nomem(es += this_path);
                                        TRY_nomem(es += "\"");
                                        e.push_back(ERROR_INSTANCE(es));
                                        TRY_nomem(es = "Previously defined at ");
                                        TRY_nomem(es += cji->config_path);
                                        TRY_nomem(es += "[");
                                        TRY_nomem(es += estring(cji->config_line));
                                        TRY_nomem(es += "]");
                                        e.push_back(ERROR_INSTANCE(es));
                                        throw(e);
                                }

                                if (
                                                (this_path.size() < that_path.size())
                                                && (this_path == that_path.substr(0,this_path.size()))
                                                && (
                                                        (that_path[this_path.size()] == '/')
                                                        || (this_path.size() == 0)
                                                        )
                                        )
                                {
                                        error e(0);

                                        TRY_nomem(es = "Overlapping archive-path values detected");
                                        e.push_back(ERROR_INSTANCE(es));
                                        TRY_nomem(es = "Defined archive-path: \"");
                                        TRY_nomem(es += this_path);
                                        TRY_nomem(es += "\"");
                                        e.push_back(ERROR_INSTANCE(es));
                                        TRY_nomem(es = "Is in a parent directory of another job's previously defined archive-path");
                                        e.push_back(ERROR_INSTANCE(es));
                                        TRY_nomem(es = "At ");
                                        TRY_nomem(es += cji->config_path);
                                        TRY_nomem(es += "[");
                                        TRY_nomem(es += estring(cji->config_line));
                                        TRY_nomem(es += "]");
                                        e.push_back(ERROR_INSTANCE(es));
                                        throw(e);
                                }

                                if (
                                                (this_path.size() > that_path.size())
                                                && (this_path.substr(0,that_path.size()) == that_path)
                                                && (
                                                        (this_path[that_path.size()] == '/')
                                                        || (that_path.size() == 0)
                                                        )
                                        )
                                {
                                        error e(0);

                                        TRY_nomem(es = "Overlapping archive-path values detected");
                                        e.push_back(ERROR_INSTANCE(es));
                                        TRY_nomem(es = "Defined archive-path: \"");
                                        TRY_nomem(es += this_path);
                                        TRY_nomem(es += "\"");
                                        e.push_back(ERROR_INSTANCE(es));
                                        TRY_nomem(es = "Is in a subdirectory of another job's previously defined archive-path");
                                        e.push_back(ERROR_INSTANCE(es));
                                        TRY_nomem(es = "At ");
                                        TRY_nomem(es += cji->config_path);
                                        TRY_nomem(es += "[");
                                        TRY_nomem(es += estring(cji->config_line));
                                        TRY_nomem(es += "]");
                                        e.push_back(ERROR_INSTANCE(es));
                                        throw(e);
                                }
                        }
                }
        }
}

//----------------------------------------------------------------------------

/** Reset configuration to default settings */
void configuration_manager::clear(void)
{
        m_initialized = false;
        m_configs_read = 0;
        m_default = true;
        TRY_nomem(m_default_file = CONFIGFILE);
        m_action = action_help;
        m_timestamp.set();
        m_cfgfiles.clear();
        m_link_catalog_dir.erase();
        TRY_nomem(m_log_dir = LOGDIR);
        m_delete_old_log_files = false;
        m_delete_old_report_files = false;
        m_rsync_local_path.erase();
        if (strlen(LOCAL_RSYNC) > 0) {
                TRY_nomem(m_rsync_local_path = LOCAL_RSYNC);
        }
        m_rsync_parallel = 1;
        m_io_poll_interval = 1;
        m_vaults.clear();
        m_vault_overflow_behavior = overflow_quit;
        m_vault_overflow_blocks = 10;
        m_vault_overflow_inodes = 10;
        m_vault_selection_behavior = selection_round_robin;
        m_vault_locking = true;
        m_default_job.clear();
        m_logging_level = logging_child;
        m_error_logging_level = logging_rsync;
        m_jobs.clear();
}

/** C'tor */
configuration_manager::configuration_manager()
{
        if (this != &config)
                throw(
                        INTERNAL_ERROR(0,"Attempt to allocate multiple configuration managers")
                        );
        clear();
}

/** Initialize the configuration manager from rvm's command line options */
void configuration_manager::init(int argc, char *argv[])
{
        int c;
        estring opt;
        estring arg;
        std::string es;
        std::string tes;
        cfgfiles_type::const_iterator cfi;
        bool use_custom_timestamp = false;
        class timestamp custom_timestamp;

        for (c = 1; c < argc; c++) {
                TRY_nomem(opt = argv[c]);
                if (c+1 == argc) {
                        TRY_nomem(arg = "");
                }
                else {
                        TRY_nomem(arg = argv[c+1]);
                }

                if (opt == "--archive") {
                        m_action = action_archive;
                }
                else if (opt == "--relink") {
                        m_action = action_relink;
                }
                else if (opt == "--help") {
                        m_action = action_help;
                }
                else if (opt == "--version") {
                        m_action = action_version;
                }
                else if (opt == "--check-config") {
                        m_action = action_check_config;
                }
                else if (opt == "--no-default-config") {
                        m_default = false;
                }
                else if (opt == "--config") {
                        directory dir;
                        directory::const_iterator cdi;

                        TRY_nomem(es = "Error finding configuration file(s) ");
                        TRY_nomem(es += "matching command line argument [");
                        TRY_nomem(es += estring(c+1));
                        TRY_nomem(es += "]: \"");
                        TRY_nomem(es += arg);
                        TRY_nomem(es += "\"");

                        try {
                                dir.path(arg);
                        }
                        catch(error e) {
                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                        catch(...) {
                                error e = err_unknown;

                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                        if (dir.size() == 0) {
                                TRY_nomem(es = "No configuration file(s) found matching ");
                                TRY_nomem(es += "command line argument [");
                                TRY_nomem(es += estring(c+1));
                                TRY_nomem(es += "]: \"");
                                TRY_nomem(es += arg);
                                TRY_nomem(es += "\"");

                                throw(ERROR(0,es));
                        }
                        for (cdi = dir.begin(); cdi != dir.end(); cdi++) {
                                TRY_nomem(m_cfgfiles.push_back(cfgfile_element(config_file, arg)));
                        }

                        c++;
                }
                else if (opt == "--job") {
                        directory dir;
                        directory::const_iterator cdi;

                        TRY_nomem(es = "Error finding job file(s) ");
                        TRY_nomem(es += "matching command line argument [");
                        TRY_nomem(es += estring(c+1));
                        TRY_nomem(es += "]: \"");
                        TRY_nomem(es += arg);
                        TRY_nomem(es += "\"");

                        try {
                                dir.path(arg);
                        }
                        catch(error e) {
                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                        catch(...) {
                                error e = err_unknown;
                                throw(e);
                        }
                        if (dir.size() == 0) {
                                TRY_nomem(es = "No job file(s) found matching ");
                                TRY_nomem(es += "command line argument [");
                                TRY_nomem(es += estring(c+1));
                                TRY_nomem(es += "]: \"");
                                TRY_nomem(es += arg);
                                TRY_nomem(es += "\"");

                                throw(ERROR(0,es));
                        }
                        for (cdi = dir.begin(); cdi != dir.end(); cdi++) {
                                TRY_nomem(m_cfgfiles.push_back(cfgfile_element(job_file, arg)));
                        }

                        c++;
                }
                else if (opt == "--timestamp") {
                        TRY_nomem(es = "From command line argument ");
                        TRY_nomem(es += estring(c+1));
                        TRY(custom_timestamp.assign(arg),es);
                        use_custom_timestamp = true;
                        c++;
                        TRY_nomem(tes = es);
                }
                else {
                        TRY_nomem(es = "Unknown command line option: \"");
                        TRY_nomem(es += opt);
                        TRY_nomem(es += "\"");
                        throw(ERROR(0,es));
                }
        }

        m_initialized = true;

        if ((m_action == action_help) || (m_action == action_version))
                return;
        
        if (use_default())
                read_config(m_default_file);

        for (cfi = m_cfgfiles.begin(); cfi != m_cfgfiles.end(); cfi++) {
                if (cfi->first == config_file) {
                        read_config(cfi->second);
                }
                else {
                        read_job(cfi->second);
                }
        }

        if (m_configs_read == 0) {
                throw(ERROR(0,"No configuration file(s) read"));
        }

        if (use_custom_timestamp) {
                TRY(m_timestamp = custom_timestamp,tes);
        }

        check();
}

/** Perform sanity checks on configuration settings */
void configuration_manager::check(void) const
{
        std::string es;
        subdirectory subdir;
        filestatus fstat;

        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        // log-dir -- If no log-dir is set then we use a default.  What if that
        // default doesn't exist?
        if (m_log_dir.size() == 0) {
                throw(ERROR(0,"log-dir not set"));
        }
        TRY_nomem(es = "Invalid log-dir value: \"");
        TRY_nomem(es += m_log_dir);
        TRY_nomem(es += "\"");
        TRY_instead(subdir.path(m_log_dir,"*"),es);

        // rsync-local-path -- If (a) rsync-local-path is not set from config, and
        // (b) a default was determined at compile time, then (c) does the default
        // exist?
        TRY_nomem(es = "Invalid rsync-local-path value: \"");
        TRY_nomem(es += m_rsync_local_path);
        TRY_nomem(es += "\"");
        TRY(fstat.path(m_rsync_local_path),es);

        // vault -- Are there any?
        if (m_vaults.size() == 0) {
                throw(ERROR(0,"No vaults defined"));
        }

        // Do all jobs generate a valid job ID?
        // Note: This is purely cosmetic, generated job ID strings are only used in
        // status reports and report logs.
        if (jobs().size() > 0) {
                jobs_type::const_iterator cji;

                for (cji = jobs().begin(); cji != jobs().end(); cji++) {
                        if (cji->generate_job_id().size() == 0) {
                                error e(0);

                                TRY_nomem(es = "Empty ID generated by job at ");
                                TRY_nomem(es += cji->config_path);
                                TRY_nomem(es += "[");
                                TRY_nomem(es += estring(cji->config_line));
                                TRY_nomem(es += "]");
                                e.push_back(es);
                                TRY_nomem(es =
                                        "Use 'jobname' to assign a descriptive name to this job");
                                e.push_back(es);
                                throw(e);
                        }
                }
        }
}

/** Return the initialized state of the configuration manager */
const bool configuration_manager::initialized(void) const
{
        return(m_initialized);
}

/** Return the action rvm is to take */
const configuration_manager::action_type 
        configuration_manager::action(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_action);
}

/** Return whether or not rvm is to try to read it's default configuration file */
const bool configuration_manager::use_default(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_default);
}

/** Set the default configuration filename */
void configuration_manager::default_file(const std::string& a_path)
{
        TRY_nomem(m_default_file = a_path);
}

/** Return the default configuration filename */
const std::string& configuration_manager::default_file(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_default_file);
}

/** Return the default log-dir */
void configuration_manager::default_logdir(const std::string& a_path)
{
        TRY_nomem(m_log_dir = a_path);
}

/** Return the timestamp of this instance of rvm */
const class timestamp& configuration_manager::timestamp(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_timestamp);
}

/** Return the link-catalog-dir path */
const std::string& configuration_manager::link_catalog_dir(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_link_catalog_dir);
}

/** Return the log-dir path */
const std::string& configuration_manager::log_dir(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_log_dir);
}

/** Return the value of delete-old-log-files */
const bool configuration_manager::delete_old_log_files(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_delete_old_log_files);
}

/** Return the value of delete-old-report-files */
const bool configuration_manager::delete_old_report_files(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_delete_old_report_files);
}

/** Return the rsync-local-path */
const std::string& configuration_manager::rsync_local_path(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_rsync_local_path);
}

/** Return the rsync-parallel */
const uint16& configuration_manager::rsync_parallel(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_rsync_parallel);
}

/** Return the number of seconds to sleep between polling for I/O */
const uint16& configuration_manager::io_poll_interval(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_io_poll_interval);
}

/** Return the timestamp-resolution */
const timestamp::resolution_type configuration_manager::timestamp_resolution(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_timestamp.resolution());
}

/** Return the vaults */
const configuration_manager::vaults_type& configuration_manager::vaults(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_vaults);
}

/** Return the vault-overflow-behavior */
const configuration_manager::overflow_type& configuration_manager::vault_overflow_behavior(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_vault_overflow_behavior);
}

/** Return the vault-overflow-blocks */
const uint16& configuration_manager::vault_overflow_blocks(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_vault_overflow_blocks);
}

/** Return the vault-overflow-inodes */
const uint16& configuration_manager::vault_overflow_inodes(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_vault_overflow_inodes);
}

/** Return the vault-selection-behavior */
const configuration_manager::selection_type& configuration_manager::vault_selection_behavior(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_vault_selection_behavior);
}

/** Return the vault-locking selection */
const bool configuration_manager::vault_locking(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_vault_locking);
}

/** Return the default job configuration */
const job& configuration_manager::default_job(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_default_job);
}

/** Return a list of jobs */
const configuration_manager::jobs_type& configuration_manager::jobs(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_jobs);
}

/** Return the logging-level */
const configuration_manager::logging_type& configuration_manager::logging_level(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_logging_level);
}

/** Return the error-logging-level */
const configuration_manager::logging_type& configuration_manager::error_logging_level(void) const
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));

        return(m_error_logging_level);
}

/** Read a configuration file */
void configuration_manager::read_config(const std::string& a_path)
{
        std::string es;
        std::ifstream in;
        uint16 line = 0;

        in.open(a_path.c_str());
        if (!in.is_open()) {
                TRY_nomem(es = "Could not open configuration file: \"");
                TRY_nomem(es += a_path);
                TRY_nomem(es += "\"");
                throw(ERROR(errno,es));
        }

        global_parser(a_path, line, in);

        in.close();
        m_configs_read++;
}

/** Read a job configuration file */
void configuration_manager::read_job(const std::string& a_path)
{
        std::string es;
        std::ifstream in;
        job njob;
        uint16 line = 0;

        in.open(a_path.c_str());
        if (!in.is_open()) {
                TRY_nomem(es = "Could not open job file: \"");
                TRY_nomem(es += a_path);
                TRY_nomem(es += "\"");
                throw(ERROR(errno,es));
        }

        njob = m_default_job;

        job_parser(&njob, a_path, line, in, "", false);

        njob.check();

        in.close();
}

//----------------------------------------------------------------------------

/** Parse a keyword/value pair read from a configuration file */
void parse_line(
        std::istream& a_in,
        std::string& a_keyword,
        std::string& a_value
        )
{
        std::string es;
        char ch;

        a_keyword.erase();
        a_value.erase();

        while (true) {
                a_in.get(ch);
                // Skip whitespace before keyword.
                while ((a_in) && ((ch == ' ') || (ch == '\t'))) {
                        a_in.get(ch);
                }
                // Read keyword
                while ((a_in) && ((ch != ' ') && (ch != '\t') && (ch != '\n'))) {
                        TRY_nomem(a_keyword += ch);
                        a_in.get(ch);
                }
                if (!a_in)
                        return;
        
                // If keyword is empty then this is a blank line, skip it.
                if (a_keyword.size() == 0)
                        return;

                // If keyword starts with a '#' then this is a comment line, skip it.
                if (a_keyword[0] == '#') {
                        // Discard the rest of the line.
                        while ((a_in) && (ch != '\n')) {
                                a_in.get(ch);
                        }
                        return;
                }

                a_keyword = estring(a_keyword).lower();

                // If there is not value, return.
                if (ch == '\n')
                        return;

                // Skip whitespace between keyword and value.
                a_in.get(ch);
                while ((a_in) && ((ch == ' ') || (ch == '\t'))) {
                        a_in.get(ch);
                }
                if (!a_in)
                        return;
                a_in.putback(ch);
                if (!a_in)
                        return;

                // Read value
                a_in.get(ch);
                while ((a_in) && (ch != '\n')) {
                        TRY_nomem(a_value += ch);
                        a_in.get(ch);
                }
                return;
        }
}

/** Given a path, strip off the basename -- like the dirname UNIX command */
const std::string parse_dirname(const std::string& a_path)
{
        std::string rpath;

        TRY_nomem(rpath = a_path);

        if (rpath.find_last_of('/') != std::string::npos)
                rpath.erase(rpath.find_last_of('/'));
        
        if (rpath.size() == 0) {
                TRY_nomem(rpath = "./");
                return(rpath);
        }

        if (rpath[rpath.size()-1] != '/') {
                TRY_nomem(rpath += '/');
        }

        return(rpath);
}

/** Given a path, strip off the directory -- like the basename UNIX commane */
const std::string parse_basename(const std::string& a_path)
{
        std::string es;
        std::string rpath;

        TRY_nomem(rpath = a_path);

        if (rpath.find_last_of('/') != std::string::npos)
                rpath.erase(0,rpath.find_last_of('/'));

        return(rpath);
}

//----------------------------------------------------------------------------

/** C'tor */
global_parser::global_parser(
        const std::string& a_path,
        uint16& a_line,
        std::istream& a_in
        )
{
        m_in = &a_in;
        m_path = &a_path;
        m_line = &a_line;

        parse();
}

/** Generate a string showing the current location within a configuration file
 * of the parser */
const std::string global_parser::location(void)
{
        std::string es;

        TRY_nomem(es = "At ");
        TRY_nomem(es += (*m_path));
        TRY_nomem(es += "[");
        TRY_nomem(es += estring((*m_line)));
        TRY_nomem(es += "]");

        return(es);
}

/** Read a configuration file, used by the "include" command */
void global_parser::read_config(const std::string& a_path)
{
        std::string es;
        std::ifstream in;
        uint16 line = 0;

        in.open(a_path.c_str());
        if (!in.is_open()) {
                TRY_nomem(es = "Could not open configuraiton file: \"");
                TRY_nomem(es += a_path);
                TRY_nomem(es += "\"");
                throw(ERROR(errno,es));
        }

        global_parser(a_path, line, in);

        in.close();
        config.m_configs_read++;
}

/** Read a job configuration file, used by the "include-job" command */
void global_parser::read_job(const std::string& a_path, job& a_job)
{
        std::string es;
        std::ifstream in;
        uint16 line = 0;

        in.open(a_path.c_str());
        if (!in.is_open()) {
                TRY_nomem(es = "Could not open job file: \"");
                TRY_nomem(es += a_path);
                TRY_nomem(es += "\"");
                throw(ERROR(errno,es));
        }

        job_parser(&a_job, a_path, line, in, "", false);

        TRY_nomem(a_job.config_path = *m_path);
        TRY_nomem(a_job.config_line = *m_line);
        a_job.check();

        in.close();
}

/** Global context parser */
void global_parser::parse(void)
{
        std::string es;
        std::string keyword;
        std::string value;

        while ((*m_in)) {
                (*m_line)++;
                
                try {
                        parse_line((*m_in), keyword, value);
                }
                catch(error e) {
                        e.push_back(ERROR_INSTANCE(location()));
                        throw(e);
                }
                catch(...) {
                        error e = err_unknown;

                        e.push_back(ERROR_INSTANCE(location()));
                        throw(e);
                }

                if (keyword.size() == 0)
                        continue;
                if (keyword[0] == '#')
                        continue;

                try {
                        if (keyword == "<default>") {
                                parse_default(value);
                        }
                        else if (keyword == "include") {
                                parse_include(value);
                        }
                        else if (keyword == "include-job") {
                                parse_include_job(value);
                        }
                        else if (keyword == "<job>") {
                                parse_job(value);
                        }
                        else if (keyword == "link-catalog-dir") {
                                parse_link_catalog_dir(value);
                        }
                        else if (keyword == "log-dir") {
                                parse_log_dir(value);
                        }
                        else if (keyword == "delete-old-log-files") {
                                parse_delete_old_log_files(value);
                        }
                        else if (keyword == "delete-old-report-files") {
                                parse_delete_old_report_files(value);
                        }
                        else if (keyword == "logging-level") {
                                parse_logging_level(value);
                        }
                        else if (keyword == "error-logging-level") {
                                parse_error_logging_level(value);
                        }
                        else if (keyword == "rsync-local-path") {
                                parse_rsync_local_path(value);
                        }
                        else if (keyword == "rsync-parallel") {
                                parse_rsync_parallel(value);
                        }
                        else if (keyword == "io-poll-interval") {
                                parse_io_poll_interval(value);
                        }
                        else if (keyword == "timestamp-resolution") {
                                parse_timestamp_resolution(value);
                        }
                        else if (keyword == "vault") {
                                try {
                                        parse_vault(value);
                                }
                                catch(error e) {
                                        std::cerr << e;
                                }
                                catch(...) {
                                        throw(err_unknown);
                                }
                        }
                        else if (keyword == "vault-overflow-behavior") {
                                parse_vault_overflow_behavior(value);
                        }
                        else if (keyword == "vault-overflow-blocks") {
                                parse_vault_overflow_blocks(value);
                        }
                        else if (keyword == "vault-overflow-inodes") {
                                parse_vault_overflow_inodes(value);
                        }
                        else if (keyword == "vault-selection-behavior") {
                                parse_vault_selection_behavior(value);
                        }
                        else if (keyword == "vault-locking") {
                                parse_vault_locking(value);
                        }
                        else {
                                error e(0);

                                TRY_nomem(es = "Unknown command in global context: \"");
                                TRY_nomem(es += keyword);
                                TRY_nomem(es += "\"");
                                throw(ERROR(0,es));
                        }
                }
                catch(error e) {
                        e.push_back(ERROR_INSTANCE(location()));
                        throw(e);
                }
                catch(...) {
                        error e = err_unknown;

                        e.push_back(ERROR_INSTANCE(location()));
                        throw(e);
                }
        }
}

/** Parse a default job context */
void global_parser::parse_default(const std::string& a_value)
{
        std::string delimiter;
        std::string default_config_path;
        uint16 default_config_line;
        job* jobPtr = &config.m_default_job;

        config.m_default_job.clear();

        TRY_nomem(default_config_path = *m_path);
        TRY_nomem(default_config_line = *m_line);
        TRY_nomem(delimiter = "</default>");

        job_parser(jobPtr, *m_path, *m_line, *m_in, delimiter, true);

        TRY_nomem(jobPtr->default_config_path = default_config_path);
        jobPtr->default_config_line = default_config_line;
}

/** Parse an "include" command */
void global_parser::parse_include(const std::string& a_value)
{
        std::string es;
        directory dir;
        directory::const_iterator cdi;
        std::string rpath;
        std::string ipath;

        if (a_value.size() == 0) {
                TRY_nomem(es = "Invalid include path: \"");
                TRY_nomem(es += a_value);
                TRY_nomem(es += "\"");
                throw(ERROR(0,es));
        }

        if (a_value[0] != '/') {
                TRY_nomem(rpath = parse_dirname(*m_path));
        }

        TRY_nomem(ipath = rpath + a_value);

        TRY_nomem(es = "No configuration file(s) found: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_instead(dir.path(ipath),es);
        if (dir.size() == 0)
                throw(ERROR(0,es));
        
        for (cdi = dir.begin(); cdi != dir.end(); cdi++) {
                if (dir.size() > 1) {
                        TRY_nomem(es = "For files found matching: \"");
                        TRY_nomem(es += a_value);
                        TRY_nomem(es += "\"");
                        try {
                                read_config(*cdi);
                        }
                        catch(error e) {
                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                        catch(...) {
                                error e = err_unknown;
                
                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                }
                else
                        read_config(*cdi);
        }
}

/** Parse an "include-job" command */
void global_parser::parse_include_job(const std::string& a_value)
{
        std::string es;
        directory dir;
        directory::const_iterator cdi;
        std::string rpath;
        std::string ipath;

        if (a_value.size() == 0) {
                TRY_nomem(es = "Invalid include-job path: \"");
                TRY_nomem(es += a_value);
                TRY_nomem(es += "\"");
                throw(ERROR(0,es));
        }

        if (a_value[0] != '/') {
                TRY_nomem(rpath = parse_dirname(*m_path));
        }

        TRY_nomem(ipath = rpath + a_value);

        TRY_nomem(es = "No job file(s) found: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(dir.path(ipath),es);
        if (dir.size() == 0)
                throw(ERROR(0,es));

        for (cdi = dir.begin(); cdi != dir.end(); cdi++) {
                job new_job;
                
                new_job = config.m_default_job;
                
                if (dir.size() > 1) {
                        TRY_nomem(es = "For files found matching: \"");
                        TRY_nomem(es += a_value);
                        TRY_nomem(es += "\"");
                        try {
                                read_job(*cdi, new_job);
                        }
                        catch(error e) {
                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                        catch(...) {
                                error e = err_unknown;

                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                }
                else
                        read_job(*cdi, new_job);
                TRY_nomem(config.m_jobs.push_back(new_job));
        }
}

/** Parse a job context */
void global_parser::parse_job(const std::string& a_value)
{
        std::string delimiter;
        std::string config_path;
        uint16 config_line;
        job new_job;
        
        TRY_nomem(config_path = *m_path);
        config_line = *m_line;
        new_job = config.m_default_job;

        TRY_nomem(new_job.config_path = config_path);
        new_job.config_line = config_line;
        TRY_nomem(delimiter = "</job>");

        job_parser(&new_job, *m_path, *m_line, *m_in, delimiter, false);

        new_job.check();

        TRY_nomem(config.m_jobs.push_back(new_job));
}

/** Parse a "link-catalog-dir" command */
void global_parser::parse_link_catalog_dir(const std::string& a_value)
{
        std::string es;
        subdirectory subdir;
        
        TRY_nomem(es = "Invalid link-catalog-dir path: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_instead(subdir.path(a_value,"*"),es);
        TRY_nomem(config.m_link_catalog_dir = a_value);
}

/** Parse a "log-dir" command */
void global_parser::parse_log_dir(const std::string& a_value)
{
        std::string es;
        subdirectory subdir;

        TRY_nomem(es = "Invalid log-dir path: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_instead(subdir.path(a_value,"*"),es);
        TRY_nomem(config.m_log_dir = a_value);
}

/** Parse a "delete-old-log-files" command */
void global_parser::parse_delete_old_log_files(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid delete-old-log-files value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (
                   (str == "y")
                || (str == "yes")
                || (str == "t")
                || (str == "true")
                || (str == "1")
                || (str == "on")
                ) {
                config.m_delete_old_log_files = true;
        }
        else if (
                   (str == "n")
                || (str == "no")
                || (str == "f")
                || (str == "false")
                || (str == "0")
                || (str == "off")
                ) {
                config.m_delete_old_log_files = false;
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse a "delete-old-report-files" command */
void global_parser::parse_delete_old_report_files(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid delete-old-report-files value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (
                   (str == "y")
                || (str == "yes")
                || (str == "t")
                || (str == "true")
                || (str == "1")
                || (str == "on")
                ) {
                config.m_delete_old_report_files = true;
        }
        else if (
                   (str == "n")
                || (str == "no")
                || (str == "f")
                || (str == "false")
                || (str == "0")
                || (str == "off")
                ) {
                config.m_delete_old_report_files = false;
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse a "loging-level" command */
void global_parser::parse_logging_level(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid logging-level value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_nomem(str = estring(a_value).lower());
        if (str == "manager") {
                config.m_logging_level = configuration_manager::logging_manager;
        }
        else if (str == "child") {
                config.m_logging_level = configuration_manager::logging_child;
        }
        else if (str == "rsync") {
                config.m_logging_level = configuration_manager::logging_rsync;
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse a "error-loging-level" command */
void global_parser::parse_error_logging_level(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid error-logging-level value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_nomem(str = estring(a_value).lower());
        if (str == "manager") {
                config.m_error_logging_level = configuration_manager::logging_manager;
        }
        else if (str == "child") {
                config.m_error_logging_level = configuration_manager::logging_child;
        }
        else if (str == "rsync") {
                config.m_error_logging_level = configuration_manager::logging_rsync;
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse an "rsync-local-path" command */
void global_parser::parse_rsync_local_path(const std::string& a_value)
{
        std::string es;
        filestatus fstat;

        TRY_nomem(es = "Invalid rsync-local-path value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_instead(fstat.path(a_value),es);
        TRY_nomem(config.m_rsync_local_path = a_value);
}

/** Parse an "rsync-parallel" command */
void global_parser::parse_rsync_parallel(const std::string& a_value)
{
        std::string es;
        uint16 num;

        TRY_nomem(es = "Invalid rsync-parallel value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_instead(num = estring(a_value),es);
        if (num == 0)
                throw(ERROR(0,es));
        config.m_rsync_parallel = num;
}

/** Parse "io-poll-interval" command */
void global_parser::parse_io_poll_interval(const std::string& a_value)
{
        std::string es;
        uint16 num;

        TRY_nomem(es = "Invalid io-poll-interval value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_instead(num = estring(a_value),es);
        if (num == 0)
                throw(ERROR(0,es));
        config.m_io_poll_interval = num;
}

/** Parse a "timestamp-resolution" command */
void global_parser::parse_timestamp_resolution(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid timestamp-resolution: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (str == "year") {
                config.m_timestamp.resolution(timestamp::resolution_year);
        }
        else if (str == "month") {
                config.m_timestamp.resolution(timestamp::resolution_month);
        }
        else if (str == "day") {
                config.m_timestamp.resolution(timestamp::resolution_day);
        }
        else if (str == "hour") {
                config.m_timestamp.resolution(timestamp::resolution_hour);
        }
        else if (str == "minute") {
                config.m_timestamp.resolution(timestamp::resolution_minute);
        }
        else if (str == "second") {
                config.m_timestamp.resolution(timestamp::resolution_second);
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse a "vault" command */
void global_parser::parse_vault(const std::string& a_value)
{
        std::string es;
        directory dir;
        directory::const_iterator cdi;
        subdirectory subdir;
        filestatus fstat;
        error partial_vault_error = ERROR(0,"One or more vault paths were found to be invalid:");

        TRY_nomem(es = "Invalid vault path: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");

        if (a_value.size() == 0)
                throw(ERROR(0,es));

        TRY(dir.path(a_value),es);

        if (dir.size() == 0) {
                TRY_instead(fstat.path(a_value),es);
        }

        for (cdi = dir.begin(); cdi != dir.end(); cdi++) {
                if (!is_dir(*cdi)) {
                        TRY_nomem(es = get_error_str(ENOTDIR));
                        TRY_nomem(es += ": \"");
                        TRY_nomem(es += *cdi);
                        TRY_nomem(es += "\"");
                        partial_vault_error.push_back(es);
                        continue;
                }
                if (!readable(*cdi)) {
                        TRY_nomem(es = "No read access to path: \"");
                        TRY_nomem(es += *cdi);
                        TRY_nomem(es += "\"");
                        partial_vault_error.push_back(es);
                        continue;
                }
                if (!writable(*cdi)) {
                        TRY_nomem(es = "No write access to path: \"");
                        TRY_nomem(es += *cdi);
                        TRY_nomem(es += "\"");
                        partial_vault_error.push_back(es);
                        continue;
                }
                if (!executable(*cdi)) {
                        TRY_nomem(es = "No execution access to path: \"");
                        TRY_nomem(es += *cdi);
                        TRY_nomem(es += "\"");
                        partial_vault_error.push_back(es);
                        continue;
                }
                TRY_nomem(config.m_vaults.push_back(*cdi));
        }

        if (partial_vault_error.size() > 1) {
                TRY_nomem(es = "For paths found matching: \"");
                TRY_nomem(es += a_value);
                TRY_nomem(es += "\"");
                partial_vault_error.push_back(es);
                throw(partial_vault_error);
        }
}

/** Parse a "vault-overflow-behavior" command */
void global_parser::parse_vault_overflow_behavior(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid vault-overflow-behavior value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (str == "quit") {
                config.m_vault_overflow_behavior = configuration_manager::overflow_quit;
        }
        else if (str == "delete-oldest") {
                config.m_vault_overflow_behavior = configuration_manager::overflow_delete_oldest;
        }
        else if (str == "delete-until-free") {
                config.m_vault_overflow_behavior = configuration_manager::overflow_delete_until_free;
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse a "vault-overflow-blocks" command */
void global_parser::parse_vault_overflow_blocks(const std::string& a_value)
{
        std::string es;
        uint16 num;

        TRY_nomem(es = "Invalid vault-overflow-blocks value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(num = estring(a_value),es);
        if (num > 50)
                throw(ERROR(0,es));
        config.m_vault_overflow_blocks = num;
}

/** Parse a "vault-overflow-inodes" command */
void global_parser::parse_vault_overflow_inodes(const std::string& a_value)
{
        std::string es;
        uint16 num;

        TRY_nomem(es = "Invalid vault-overflow-inodes value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(num = estring(a_value),es);
        if (num > 50)
                throw(ERROR(0,es));
        config.m_vault_overflow_inodes = num;
}

/** Parse a "vault-selection-behavior" command */
void global_parser::parse_vault_selection_behavior(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid vault-selection-behavior value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (str == "max-free") {
                config.m_vault_selection_behavior = configuration_manager::selection_max_free;
        }
        else if (str == "round-robin") {
                config.m_vault_selection_behavior = configuration_manager::selection_round_robin;
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse a "vault-locking" command */
void global_parser::parse_vault_locking(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid vault-locking value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (
                   (str == "y")
                || (str == "yes")
                || (str == "t")
                || (str == "true")
                || (str == "1")
                || (str == "on")
                ) {
                config.m_vault_locking = true;
        }
        else if (
                   (str == "n")
                || (str == "no")
                || (str == "f")
                || (str == "false")
                || (str == "0")
                || (str == "off")
                ) {
                config.m_vault_locking = false;
        }
        else {
                throw(ERROR(0,es));
        }
}

//----------------------------------------------------------------------------

/** C'tor */
job_parser::job_parser(
        job * a_job,
        const std::string& a_path,
        uint16& a_line,
        std::istream& a_in,
        const std::string& a_block_delimiter,
        const bool a_default_context = false
        )
{
        m_job = a_job;
        m_in = &a_in;
        m_path = &a_path;
        m_line = &a_line;
        m_delimiter = &a_block_delimiter;
        m_default_context = a_default_context;

        parse();
}

/** Construct a string with the current location of the parser in a
 * configuration file */
const std::string job_parser::location(void)
{
        std::string es;

        TRY_nomem(es = "At ");
        TRY_nomem(es += (*m_path));
        TRY_nomem(es += "[");
        TRY_nomem(es += estring((*m_line)));
        TRY_nomem(es += "]");

        return(es);
}

/** Read a job configuration file, used by the "include" command */
void job_parser::read_job(const std::string& a_path)
{
        std::string es;
        std::ifstream in;
        uint16 line = 0;

        in.open(a_path.c_str());
        if (!in.is_open()) {
                TRY_nomem(es = "Could not open job file: \"");
                TRY_nomem(es += a_path);
                TRY_nomem(es += "\"");
                throw(ERROR(errno,es));
        }

        job_parser(m_job, a_path, line, in, "", m_default_context);

        in.close();
}

/** Job context parser */
void job_parser::parse(void)
{
        std::string es;
        std::string keyword;
        std::string value;

        while ((*m_in)) {
                (*m_line)++;
                
                try {
                        parse_line((*m_in), keyword, value);
                }
                catch(error e) {
                        e.push_back(ERROR_INSTANCE(location()));
                        throw(e);
                }
                catch(...) {
                        error e = err_unknown;

                        e.push_back(ERROR_INSTANCE(location()));
                        throw(e);
                }

                if (!(*m_in) && (m_delimiter->size() != 0)) {
                        TRY_nomem(es = "Unexpected end of file, expected \"");
                        TRY_nomem(es += *m_delimiter);
                        TRY_nomem(es += "\" here");
                        throw(ERROR(errno,es));
                }

                if (keyword.size() == 0)
                        continue;
                if (keyword[0] == '#')
                        continue;

                try {
                        if (keyword == *m_delimiter) {
                                return;
                        }
                        else if (keyword == "archive-path") {
                                parse_archive_path(value);
                        }
                        else if (keyword == "clear") {
                                parse_clear(value);
                        }
                        else if (keyword == "exclude-from") {
                                parse_exclude_from(value);
                        }
                        else if (keyword == "include-from") {
                                parse_include_from(value);
                        }
                        else if (keyword == "groupname") {
                                parse_groupname(value);
                        }
                        else if (keyword == "hostname") {
                                parse_hostname(value);
                        }
                        else if (keyword == "include") {
                                parse_include(value);
                        }
                        else if ((keyword == "jobname") && (*m_delimiter == "</job>")) {
                                parse_jobname(value);
                        }
                        else if (keyword == "path") {
                                parse_path(value);
                        }
                        else if (keyword == "rsync-behavior") {
                                parse_rsync_behavior(value);
                        }
                        else if (keyword == "rsync-connection-type") {
                                parse_rsync_connection_type(value);
                        }
                        else if (keyword == "rsync-hardlink") {
                                parse_rsync_hardlink(value);
                        }
                        else if (keyword == "rsync-options") {
                                parse_rsync_options(value);
                        }
                        else if (keyword == "<rsync-options>") {
                                parse_rsync_options_context(value);
                        }
                        else if (keyword == "rsync-remote-user") {
                                parse_rsync_remote_user(value);
                        }
                        else if (keyword == "rsync-remote-path") {
                                parse_rsync_remote_path(value);
                        }
                        else if (keyword == "rsync-remote-port") {
                                parse_rsync_remote_port(value);
                        }
                        else if (keyword == "rsync-remote-module") {
                                parse_rsync_remote_module(value);
                        }
                        else if (keyword == "rsync-retry-count") {
                                parse_rsync_retry_count(value);
                        }
                        else if (keyword == "rsync-timeout") {
                                parse_rsync_timeout(value);
                        }
                        else {
                                error e(0);

                                TRY_nomem(es = "Unknown command in ");
                                if (m_default_context) {
                                        TRY_nomem(es += "default");
                                }
                                else {
                                        TRY_nomem(es += "job");
                                }
                                TRY_nomem(es += " context: \"");
                                TRY_nomem(es += keyword);
                                TRY_nomem(es += "\"");
                                throw(ERROR(0,es));
                        }
                }
                catch(error e) {
                        if ((*m_delimiter).size() == 0)
                                e.push_back(ERROR_INSTANCE(location()));
                        throw(e);
                }
                catch(...) {
                        error e = err_unknown;

                        e.push_back(ERROR_INSTANCE(location()));
                        throw(e);
                }
        }
}

/** Parse an "archive-path" command */
void job_parser::parse_archive_path(const std::string& a_value)
{
        std::string es;

        TRY_nomem(es = "Invalid archive-path value");
        TRY((*m_job).archive_path = a_value,es);
}

/** Parse a "clear" command */
void job_parser::parse_clear(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid clear value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (str == "archive-path") {
                m_job->archive_path.clear();
        }
        else if (str == "exclude-from") {
                m_job->excludes.clear();
        }
        else if (str == "groupname") {
                m_job->groupname.erase();
        }
        else if (str == "hostname") {
                m_job->hostname.erase();
        }
        else if (str == "include-from") {
                m_job->includes.clear();
        }
        else if ((str == "jobname") && (*m_delimiter == "</job>")) {
                m_job->jobname.erase();
        }
        else if (str == "paths") {
                m_job->paths.clear();
        }
        else if (str == "rsync-behavior") {
                m_job->rsync_behavior.clear();
        }
        else if (str == "rsync-options") {
                m_job->rsync_options.erase();
        }
        else if (str == "rsync-remote-user") {
                m_job->rsync_remote_user.erase();
        }
        else if (str == "rsync-remotr-port") {
                m_job->rsync_remote_port = 0;
        }
        else if (str == "rsync-remote-module") {
                m_job->rsync_remote_module.erase();
        }
        else if (str == "rsync-remote-path") {
                m_job->rsync_remote_path.erase();
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse an "exclude-from" command */
void job_parser::parse_exclude_from(const std::string& a_value)
{
        std::string es;
        directory dir;
        directory::const_iterator cdi;
        std::string rpath;
        std::string ipath;

        if (a_value.size() == 0) {
                TRY_nomem(es = "Invalid exclude-from path: \"");
                TRY_nomem(es += a_value);
                TRY_nomem(es += "\"");
                throw(ERROR(0,es));
        }

        if (a_value[0] != '/') {
                TRY_nomem(rpath = parse_dirname(*m_path));
        }

        TRY_nomem(ipath = rpath + a_value);

        TRY_nomem(es = "No exclude-from file(s) found: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(dir.path(ipath),es);
        if (dir.size() == 0)
                throw(ERROR(0,es));
        
        for (cdi = dir.begin(); cdi != dir.end(); cdi++) {
                TRY_nomem((*m_job).excludes.push_back(*cdi));
        }
}

/** Parse an "include-from" command */
void job_parser::parse_include_from(const std::string& a_value)
{
        std::string es;
        directory dir;
        directory::const_iterator cdi;
        std::string rpath;
        std::string ipath;

        if (a_value.size() == 0) {
                TRY_nomem(es = "Invalid include-from path: \"");
                TRY_nomem(es += a_value);
                TRY_nomem(es += "\"");
                throw(ERROR(0,es));
        }

        if (a_value[0] != '/') {
                TRY_nomem(rpath = parse_dirname(*m_path));
        }

        TRY_nomem(ipath = rpath + a_value);

        TRY_nomem(es = "No include-from file(s) found: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(dir.path(ipath),es);
        if (dir.size() == 0)
                throw(ERROR(0,es));
        
        for (cdi = dir.begin(); cdi != dir.end(); cdi++) {
                TRY_nomem((*m_job).includes.push_back(*cdi));
        }
}

/** Parse a "groupname" command */
void job_parser::parse_groupname(const std::string& a_value)
{
        TRY_nomem((*m_job).groupname = a_value);
}

/** Parse a "hostname" command */
void job_parser::parse_hostname(const std::string& a_value)
{
        TRY_nomem((*m_job).hostname = a_value);
}

/** Parse an "include" command */
void job_parser::parse_include(const std::string& a_value)
{
        std::string es;
        directory dir;
        directory::const_iterator cdi;
        std::string rpath;
        std::string ipath;

        if (a_value.size() == 0) {
                TRY_nomem(es = "Invalid include path: \"");
                TRY_nomem(es += a_value);
                TRY_nomem(es += "\"");
                throw(ERROR(0,es));
        }

        if (a_value[0] != '/') {
                TRY_nomem(rpath = parse_dirname(*m_path));
        }

        TRY_nomem(ipath = rpath + a_value);

        TRY_nomem(es = "No configuration file(s) found: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_instead(dir.path(ipath),es);
        if (dir.size() == 0)
                throw(ERROR(0,es));
        
        for (cdi = dir.begin(); cdi != dir.end(); cdi++) {
                if (dir.size() > 1) {
                        TRY_nomem(es = "For files found matching: \"");
                        TRY_nomem(es += a_value);
                        TRY_nomem(es += "\"");
                        try {
                                read_job(*cdi);
                        }
                        catch(error e) {
                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                        catch(...) {
                                error e = err_unknown;

                                e.push_back(ERROR_INSTANCE(es));
                                throw(e);
                        }
                }
                else
                        read_job(*cdi);
        }
}

/** Parse a "jobname" command */
void job_parser::parse_jobname(const std::string& a_value)
{
        TRY_nomem((*m_job).jobname = a_value);
}

/** Parse a "path" command */
void job_parser::parse_path(const std::string& a_value)
{
        TRY_nomem((*m_job).paths.push_back(a_value));
}

/** Parse an "rsync-behavior" command */
void job_parser::parse_rsync_behavior(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid rsync-behavior value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (str == "clear") {
                (*m_job).rsync_behavior.clear();
        }
        else if (str == "reset") {
                (*m_job).rsync_behavior.reset();
        }
        else
                (*m_job).rsync_behavior.assign(a_value);
}

/** Parse an "rsync-connection-type" command */
void job_parser::parse_rsync_connection_type(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid rsync-connection-type value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (str == "local") {
                (*m_job).rsync_connection = job::connection_local;
        }
        else if (str == "remote") {
                (*m_job).rsync_connection = job::connection_remote;
        }
        else if (str == "server") {
                (*m_job).rsync_connection = job::connection_server;
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse an "rsync-hardlink" command */
void job_parser::parse_rsync_hardlink(const std::string& a_value)
{
        std::string es;
        estring str;

        TRY_nomem(es = "Invalid rsync-hardlink value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY(str = estring(a_value).lower(),es);
        if (
                   (str == "y")
                || (str == "yes")
                || (str == "t")
                || (str == "true")
                || (str == "1")
                || (str == "on")
                ) {
                (*m_job).rsync_hardlink = true;
        }
        else if (
                   (str == "n")
                || (str == "no")
                || (str == "f")
                || (str == "false")
                || (str == "0")
                || (str == "off")
                ) {
                (*m_job).rsync_hardlink = false;
        }
        else {
                throw(ERROR(0,es));
        }
}

/** Parse an "rsync-options" command */
void job_parser::parse_rsync_options(const std::string& a_value)
{
        if (*m_delimiter == "</default>") {
                TRY_nomem((*m_job).rsync_options = a_value);
        }
        else {
                if ((*m_job).rsync_options.size() != 0) {
                        TRY_nomem((*m_job).rsync_options += " ");
                }
                TRY_nomem((*m_job).rsync_options += a_value);
        }
}

/** Parse an rsync-options context */
void job_parser::parse_rsync_options_context(const std::string& a_value)
{
        std::string es;
        std::string value;
        std::string rsync_options;
        char ch;

        while ((*m_in)) {
                (*m_line)++;

                value.erase();

                (*m_in).get(ch);
                while ((ch == ' ') || (ch == '\t'))
                        (*m_in).get(ch);
                while (((*m_in)) && (ch != '\n')) {
                        TRY_nomem(value += ch);
                        (*m_in).get(ch);
                }

                if ((!(*m_in)) && (value != "</rsync-options>")) {
                        TRY_nomem(es = "Unexpected end of file, expected ");
                        TRY_nomem(es += "\"</rsync-options>\" here");
                        throw(ERROR(errno,es));
                }

                if (value.size() == 0)
                        continue;
                if (value[0] == '#')
                        continue;

                if (value == "</rsync-options>") {
                        parse_rsync_options(rsync_options);
                        return;
                }

                if (rsync_options.size() != 0) {
                        TRY_nomem(rsync_options += ' ');
                }
                TRY_nomem(rsync_options += value);
        }
}

/** Parse a "remote-user" command */
void job_parser::parse_rsync_remote_user(const std::string& a_value)
{
        TRY_nomem((*m_job).rsync_remote_user = a_value);
}

/** Parse an "rsync-remote-path" command */
void job_parser::parse_rsync_remote_path(const std::string& a_value)
{
        TRY_nomem((*m_job).rsync_remote_path = a_value);
}

/** Parse an "rsync-remote-port" command */
void job_parser::parse_rsync_remote_port(const std::string& a_value)
{
        std::string es;
        estring str;
        uint16 num;

        TRY_nomem(es = "Invalid rsync-remote-port value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_nomem(str = a_value);
        TRY(num = str,es);
        (*m_job).rsync_remote_port = num;
}

/** Parse an "rsync-remote-module" command */
void job_parser::parse_rsync_remote_module(const std::string& a_value)
{
        TRY_nomem((*m_job).rsync_remote_module = a_value);
}

/** Parse an "rsync-retry-count" command */
void job_parser::parse_rsync_retry_count(const std::string& a_value)
{
        std::string es;
        estring str;
        uint16 num;

        TRY_nomem(es = "Invalid rsync-retry-count value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_nomem(str = a_value);
        TRY(num = str,es);
        (*m_job).rsync_retry_count = num;
}

/** Parse an "rsync-timeout" command */
void job_parser::parse_rsync_timeout(const std::string& a_value)
{
        std::string es;
        estring str;
        uint16 num;

        TRY_nomem(es = "Invalid rsync-timeout value: \"");
        TRY_nomem(es += a_value);
        TRY_nomem(es += "\"");
        TRY_nomem(str = a_value);
        TRY(num = str,es);
        (*m_job).rsync_timeout = num;
}

//----------------------------------------------------------------------------

/** The global configuration manager instance */
configuration_manager config;

---