/*
* Copyright (C) 2010 Vyatta, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstdarg>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <algorithm>
#include <sstream>
// for debian's version comparison algorithm
#define APT_COMPATIBILITY 986
#include <apt-pkg/version.h>
#include <cli_cstore.h>
#include <cstore/cstore.hpp>
#include <cstore/cstore-varref.hpp>
////// constants
//// node status
const string Cstore::C_NODE_STATUS_DELETED = "deleted";
const string Cstore::C_NODE_STATUS_ADDED = "added";
const string Cstore::C_NODE_STATUS_CHANGED = "changed";
const string Cstore::C_NODE_STATUS_STATIC = "static";
//// env vars for shell
// current levels
const string Cstore::C_ENV_EDIT_LEVEL = "VYATTA_EDIT_LEVEL";
const string Cstore::C_ENV_TMPL_LEVEL = "VYATTA_TEMPLATE_LEVEL";
// shell-specific vars
const string Cstore::C_ENV_SHELL_PROMPT = "PS1";
const string Cstore::C_ENV_SHELL_CWORDS = "COMP_WORDS";
const string Cstore::C_ENV_SHELL_CWORD_COUNT = "COMP_CWORD";
// shell api vars
const string Cstore::C_ENV_SHAPI_COMP_VALS = "_cli_shell_api_comp_values";
const string Cstore::C_ENV_SHAPI_LCOMP_VAL = "_cli_shell_api_last_comp_val";
const string Cstore::C_ENV_SHAPI_COMP_HELP = "_cli_shell_api_comp_help";
const string Cstore::C_ENV_SHAPI_HELP_ITEMS = "_cli_shell_api_hitems";
const string Cstore::C_ENV_SHAPI_HELP_STRS = "_cli_shell_api_hstrs";
//// dirs/files
const string Cstore::C_ENUM_SCRIPT_DIR = "/opt/vyatta/share/enumeration";
const string Cstore::C_LOGFILE_STDOUT = "/tmp/cfg-stdout.log";
//// sorting
const unsigned int Cstore::SORT_DEFAULT = 0;
const unsigned int Cstore::SORT_DEB_VERSION = 0;
const unsigned int Cstore::SORT_NONE = 1;
////// static
bool Cstore::_init = false;
Cstore::MapT<unsigned int, Cstore::SortFuncT> Cstore::_sort_func_map;
////// constructors/destructors
/* this constructor just returns the generic environment string,
* currently the two levels. implementation-specific environment
* (e.g., unionfs stuff) is handled by derived class.
*
* note: currently using original semantics for the levels, i.e., they
* represent the actual physical paths, which involve fs-specific
* escaping. this should be changed to a "logical" representation
* so that their manipulation can be moved from derived class to
* this base class.
*/
Cstore::Cstore(string& env)
{
init();
string decl = "declare -x ";
env = (decl + C_ENV_EDIT_LEVEL + "=/; ");
env += (decl + C_ENV_TMPL_LEVEL + "=/;");
}
////// public interface
/* check if specified "logical path" corresponds to a valid template.
* validate_vals: whether to validate "values" along specified path.
* return true if valid. otherwise return false.
*/
bool
Cstore::validateTmplPath(const vector<string>& path_comps, bool validate_vals)
{
vtw_def def;
// if we can get parsed tmpl, path is valid
return get_parsed_tmpl(path_comps, validate_vals, def);
}
/* same as above but return parsed template.
* def: (output) parsed template.
* note: if last path component is "value" (i.e., def.is_value), parsed
* template is actually at "full path - 1". see get_parsed_tmpl() for details.
*/
bool
Cstore::validateTmplPath(const vector<string>& path_comps, bool validate_vals,
vtw_def& def)
{
// if we can get parsed tmpl, path is valid
return get_parsed_tmpl(path_comps, validate_vals, def);
}
/* get parsed template of specified path as a string-string map
* tmap: (output) parsed template.
* return true if successful. otherwise return false.
*/
bool
Cstore::getParsedTmpl(const vector<string>& path_comps,
Cstore::MapT<string, string>& tmap, bool allow_val)
{
vtw_def def;
/* currently this function is used outside actual CLI operations, mainly
* from the perl API. since value validation is from the original CLI
* implementation, it doesn't seem to behave correctly in such cases,
* probably because "at string" is not set?
*
* anyway, not validating values in the following call.
*/
if (!get_parsed_tmpl(path_comps, false, def)) {
return false;
}
if (!allow_val && def.is_value) {
/* note: !allow_val means specified path must terminate at an actual
* "node", not a "value". so this fails since path ends in value.
* this emulates the original perl API behavior.
*/
return false;
}
if (def.is_value) {
tmap["is_value"] = "1";
}
// make the map
if (def.def_type != ERROR_TYPE) {
tmap["type"] = type_to_name(def.def_type);
}
if (def.def_type2 != ERROR_TYPE) {
tmap["type2"] = type_to_name(def.def_type2);
}
if (def.def_node_help) {
tmap["help"] = def.def_node_help;
}
if (def.multi) {
tmap["multi"] = "1";
if (def.def_multi > 0) {
ostringstream s;
s << def.def_multi;
tmap["limit"] = s.str();
}
} else if (def.tag) {
tmap["tag"] = "1";
if (def.def_tag > 0) {
ostringstream s;
s << def.def_tag;
tmap["limit"] = s.str();
}
} else if (def.def_default) {
tmap["default"] = def.def_default;
}
if (def.def_enumeration) {
tmap["enum"] = def.def_enumeration;
}
if (def.def_allowed) {
tmap["allowed"] = def.def_allowed;
}
if (def.def_val_help) {
tmap["val_help"] = def.def_val_help;
}
return true;
}
/* get names of all template child nodes of specified path.
* cnodes: (output) template child node names.
* note: if specified path is at a "tag node", "node.tag" will be returned.
*/
void
Cstore::tmplGetChildNodes(const vector<string>& path_comps,
vector<string>& cnodes)
{
SAVE_PATHS;
append_tmpl_path(path_comps);
get_all_tmpl_child_node_names(cnodes);
sort_nodes(cnodes);
RESTORE_PATHS;
}
/* delete specified "logical path" from "working config".
* def: parsed template corresponding to logical path path_comps.
* return true if successful. otherwise return false.
* note: assume specified path has been validated
* (i.e., validateDeletePath()).
*/
bool
Cstore::deleteCfgPath(const vector<string>& path_comps, const vtw_def& def)
{
ASSERT_IN_SESSION;
if (!cfg_path_exists(path_comps, false, true)) {
output_user("Nothing to delete (the specified %s does not exist)\n",
(!def.is_value || def.tag) ? "node" : "value");
// treat as success
return true;
}
/* path already validated and in working config.
* cases:
* 1. has default value
* => replace current value with default
* 2. no default value
* => remove config path
*/
if (def.def_default) {
// case 1. construct path for value file.
SAVE_PATHS;
append_cfg_path(path_comps);
if (def.is_value) {
// last comp is "value". need to go up 1 level.
pop_cfg_path();
}
/* assume default value is valid (parser should have validated).
* also call unmark_deactivated() in case the node being deleted was
* also deactivated. note that unmark_deactivated() succeeds if it's
* not marked deactivated. also mark "changed".
*/
bool ret = (write_value(def.def_default) && mark_display_default()
&& unmark_deactivated() && mark_changed_with_ancestors());
if (!ret) {
output_user("Failed to set default value during delete\n");
}
RESTORE_PATHS;
return ret;
}
/* case 2.
* sub-cases:
* (1) last path comp is "value", i.e., tag (value of tag node),
* value of single-value node, or value of multi-value node.
* (a) value of single-value node
* => remove node
* (b) value of multi-value node
* => remove value. remove node if last value.
* (c) value of tag node (i.e., tag)
* => remove tag. remove node if last tag.
* (2) last path comp is "node", i.e., typeless node, tag node,
* single-value node, or multi-value node.
* => remove node
*/
bool ret = false;
SAVE_PATHS;
append_cfg_path(path_comps);
if (!def.is_value) {
// sub-case (2)
ret = remove_node();
} else {
// last comp is value
if (def.tag) {
// sub-case (1c)
ret = remove_tag();
} else if (def.multi) {
// sub-case (1b)
pop_cfg_path();
ret = remove_value_from_multi(path_comps[path_comps.size() - 1]);
} else {
// sub-case (1a). delete node at 1 level up.
pop_cfg_path();
ret = remove_node();
}
}
if (ret) {
// mark changed
ret = mark_changed_with_ancestors();
}
RESTORE_PATHS;
if (!ret) {
output_user("Failed to delete specified config path\n");
}
return ret;
}
/* check if specified "logical path" is valid for "set" operation
* return true if valid. otherwise return false.
*/
bool
Cstore::validateSetPath(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
// if we can get parsed tmpl, path is valid
vtw_def def;
string terr;
if (!get_parsed_tmpl(path_comps, true, def, terr)) {
output_user("%s\n", terr.c_str());
return false;
}
bool ret = true;
SAVE_PATHS;
if (!def.is_value) {
if (def.def_type != ERROR_TYPE) {
/* disallow setting value node without value
* note: different from old behavior, which only disallow setting a
* single-value node without value. now all value nodes
* (single-value, multi-value, and tag) must be set with value.
*/
output_user("The specified configuration node requires a value\n");
ret = false;
} else {
/* typeless node
* note: XXX the following is present in the original logic, perhaps
* to trigger check_syn() on the typeless node? is this really
* necessary?
* also, validate_val() uses current cfg path and tmpl path, so
* construct them before calling it.
*/
append_cfg_path(path_comps);
append_tmpl_path(path_comps);
if (!validate_val(&def, "")) {
ret = false;
}
}
}
RESTORE_PATHS;
return ret;
}
/* check if specified "logical path" is valid for "delete" operation
* return true if valid. otherwise return false.
*/
bool
Cstore::validateDeletePath(const vector<string>& path_comps, vtw_def& def)
{
ASSERT_IN_SESSION;
string terr;
if (!get_parsed_tmpl(path_comps, false, def, terr)) {
output_user("%s\n", terr.c_str());
return false;
}
return true;
}
/* check if specified "logical path" is valid for "activate" operation
* return true if valid. otherwise return false.
*/
bool
Cstore::validateActivatePath(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
vtw_def def;
if (!validate_act_deact(path_comps, "activate", def)) {
return false;
}
if (!cfgPathMarkedDeactivated(path_comps)) {
output_user("Activate can only be performed on a node on which the "
"deactivate\ncommand has been performed.\n");
return false;
}
bool ret = true;
if (def.is_value && def.tag && def.def_tag > 0) {
// we are activating a tag, and there is a limit on number of tags.
vector<string> cnodes;
SAVE_PATHS;
append_cfg_path(path_comps);
string t = pop_cfg_path();
// get child nodes, excluding deactivated ones.
get_all_child_node_names(cnodes, false, false);
if (def.def_tag <= cnodes.size()) {
// limit exceeded
output_user("Cannot activate \"%s\": number of values exceeds limit "
"(%d allowed)\n", t.c_str(), def.def_tag);
ret = false;
}
RESTORE_PATHS;
}
return ret;
}
/* check if specified "logical path" is valid for "deactivate" operation
* return true if valid. otherwise return false.
*/
bool
Cstore::validateDeactivatePath(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
vtw_def def;
return validate_act_deact(path_comps, "deactivate", def);
}
/* check if specified "logical path" is valid for "edit" operation.
* return false if invalid.
* if valid, set "env" arg to the environment string needed for the "edit"
* operation and return true.
*/
bool
Cstore::getEditEnv(const vector<string>& path_comps, string& env)
{
ASSERT_IN_SESSION;
vtw_def def;
string terr;
if (!get_parsed_tmpl(path_comps, false, def, terr)) {
output_user("%s\n", terr.c_str());
return false;
}
/* "edit" is only allowed when path ends at a
* (1) "tag value"
* OR
* (2) "typeless node"
*/
if (!(def.is_value && def.tag)
&& !(!def.is_value && def.def_type == ERROR_TYPE)) {
// neither "tag value" nor "typeless node"
output_user("The \"edit\" command cannot be issued "
"at the specified level\n");
return false;
}
if (!cfg_path_exists(path_comps, false, true)) {
/* specified path does not exist.
* follow the original implementation and do a "set".
*/
if (!validateSetPath(path_comps)) {
output_user("The specified config path is not valid\n");
return false;
}
if (!set_cfg_path(path_comps, false)) {
output_user("Failed to create the specified config path\n");
return false;
}
}
SAVE_PATHS;
append_cfg_path(path_comps);
append_tmpl_path(path_comps);
get_edit_env(env);
RESTORE_PATHS;
/* doing the save/restore above to be consistent with the rest of the API.
* however, after the caller evals the returned environment string, the
* levels in "this" will become out-of-sync with the environment. so
* "this" should no longer be used and a new object should be created.
*
* this is only an issue if the calling process doesn't terminate. since
* the function should only be used by the shell/completion, it's not a
* problem (each invocation of my_cli_shell_api uses a new object anyway).
*/
return true;
}
/* set "env" arg to the environment string needed for the "up" operation.
* return true if successful.
*/
bool
Cstore::getEditUpEnv(string& env)
{
ASSERT_IN_SESSION;
/* "up" is based on current levels in environment. levels should already
* be set up in constructor (with "use_edit_level" true).
*/
if (edit_level_at_root()) {
output_user("Already at the top level\n");
return false;
}
/* get_parsed_tmpl() does not allow empty path, so use one component
* from current paths.
*/
vtw_def def;
string terr;
vector<string> path_comps;
if (!get_parsed_tmpl(path_comps, false, def, terr)) {
// this should not happen since it's using existing levels
output_user("%s\n", terr.c_str());
return false;
}
SAVE_PATHS;
if (def.is_value && def.tag) {
// edit level is at "tag value". go up 1 extra level.
pop_cfg_path();
pop_tmpl_path();
}
pop_cfg_path();
pop_tmpl_path();
get_edit_env(env);
RESTORE_PATHS;
// also see getEditEnv for comment on save/restore above
return true;
}
/* set "env" arg to the environment string needed to reset edit levels.
* return true if successful.
*/
bool
Cstore::getEditResetEnv(string& env)
{
ASSERT_IN_SESSION;
SAVE_PATHS;
while (!edit_level_at_root()) {
pop_cfg_path();
pop_tmpl_path();
}
get_edit_env(env);
RESTORE_PATHS;
// also see getEditEnv for comment on save/restore above
return true;
}
/* set "env" arg to the environment string needed for "completion".
* return true if successful.
*
* note: comps must have at least 2 components, the "command" and the
* first path element (which can be empty string).
*/
bool
Cstore::getCompletionEnv(const vector<string>& comps, string& env)
{
ASSERT_IN_SESSION;
vector<string> pcomps = comps;
string cmd = pcomps[0];
string last_comp = pcomps.back();
pcomps.erase(pcomps.begin());
pcomps.pop_back();
bool exists_only = (cmd == "delete" || cmd == "show" || cmd == "edit"
|| cmd == "comment" || cmd == "activate"
|| cmd == "deactivate");
/* at this point, pcomps contains the command line arguments minus the
* "command" and the last one.
*/
bool ret = false;
SAVE_PATHS;
do {
vtw_def def;
if (pcomps.size() > 0) {
if (!get_parsed_tmpl(pcomps, false, def)) {
// invalid path
break;
}
if (exists_only && !cfg_path_exists(pcomps, false, true)) {
// invalid path for the command (must exist)
break;
}
append_cfg_path(pcomps);
append_tmpl_path(pcomps);
} else {
// we are at root. simulate a typeless node.
def.def_type = ERROR_TYPE;
def.tag = def.multi = def.is_value = 0;
}
/* at this point, cfg and tmpl paths are constructed up to the comp
* before last_comp, and def is parsed.
*/
if (def.is_value && !def.tag) {
// invalid path (this means the comp before last_comp is a leaf value)
break;
}
vector<string> comp_vals;
string comp_string;
string comp_help;
vector<pair<string, string> > help_pairs;
bool last_comp_val = true;
if (def.def_type == ERROR_TYPE || def.is_value) {
/* path so far is at a typeless node OR a tag value (tag already
* checked above):
* completions: from tmpl children.
* help:
* values: same as completions.
* text: "help" from child templates.
*
* note: for such completions, we filter non-existent nodes if
* necessary.
*/
vector<string> ufvec;
if (exists_only) {
// only return existing config nodes
get_all_child_node_names(ufvec, false, true);
} else {
// return all template children
get_all_tmpl_child_node_names(ufvec);
}
for (size_t i = 0; i < ufvec.size(); i++) {
if (last_comp == ""
|| ufvec[i].compare(0, last_comp.length(), last_comp) == 0) {
comp_vals.push_back(ufvec[i]);
}
}
if (comp_vals.size() == 0) {
// no matches
break;
}
sort(comp_vals.begin(), comp_vals.end());
for (size_t i = 0; i < comp_vals.size(); i++) {
pair<string, string> hpair(comp_vals[i], "");
push_tmpl_path(hpair.first);
vtw_def cdef;
if (tmpl_parse(cdef) && cdef.def_node_help) {
hpair.second = cdef.def_node_help;
} else {
hpair.second = "<No help text available>";
}
help_pairs.push_back(hpair);
pop_tmpl_path();
}
// last comp is not value
last_comp_val = false;
} else {
/* path so far is at a "value node".
* note: follow the original implementation and don't filter
* non-existent values for such completions
*/
// first, handle completions.
if (def.tag) {
// it's a "tag node". get completions from tag values.
get_all_child_node_names(comp_vals, false, true);
} else {
// it's a "leaf value node". get completions from values.
read_value_vec(comp_vals, false);
}
/* more possible completions from this node's template:
* "allowed"
* "enumeration"
* "$VAR(@) in ..."
*/
if (def.def_enumeration || def.def_allowed) {
/* do "enumeration" or "allowed".
* note: emulate original implementation and set up COMP_WORDS and
* COMP_CWORD environment variables. these are needed by some
* "allowed" scripts.
*/
ostringstream cword_count;
cword_count << (comps.size() - 1);
string cmd_str = ("export " + C_ENV_SHELL_CWORD_COUNT + "="
+ cword_count.str() + "; ");
cmd_str += ("export " + C_ENV_SHELL_CWORDS + "=(");
for (size_t i = 0; i < comps.size(); i++) {
cmd_str += (" '" + comps[i] + "'");
}
cmd_str += "); ";
if (def.def_enumeration) {
cmd_str += (C_ENUM_SCRIPT_DIR + "/" + def.def_enumeration);
} else {
string astr = def.def_allowed;
shell_escape_squotes(astr);
cmd_str += "_cstore_internal_allowed () { eval '";
cmd_str += astr;
cmd_str += "'; }; _cstore_internal_allowed";
}
char *buf = (char *) malloc(MAX_CMD_OUTPUT_SIZE);
int ret = get_shell_command_output(cmd_str.c_str(), buf,
MAX_CMD_OUTPUT_SIZE);
if (ret > 0) {
// '<' and '>' need to be escaped
char *ptr = buf;
while (*ptr) {
if (*ptr == '<' || *ptr == '>') {
comp_string += "\\";
}
comp_string += *ptr;
ptr++;
}
}
/* note that for "enumeration" and "allowed", comp_string is the
* complete output of the command and it is to be evaled by the
* shell into an array of values.
*/
free(buf);
} else if (def.actions[syntax_act].vtw_list_head) {
// look for "self ref in values" from syntax
const valstruct *vals = get_syntax_self_in_valstruct(
def.actions[syntax_act].vtw_list_head);
if (vals) {
if (vals->cnt == 0 && vals->val) {
comp_vals.push_back(vals->val);
} else if (vals->cnt > 0) {
for (int i = 0; i < vals->cnt; i++) {
if (vals->vals[i]) {
comp_vals.push_back(vals->vals[i]);
}
}
}
}
}
// now handle help.
if (def.def_comp_help) {
// "comp_help" exists.
comp_help = def.def_comp_help;
shell_escape_squotes(comp_help);
}
if (def.def_val_help) {
// has val_help. first separate individual lines.
size_t start = 0, i = 0;
vector<string> vhelps;
for (i = 0; def.def_val_help[i]; i++) {
if (def.def_val_help[i] == '\n') {
vhelps.push_back(string(&(def.def_val_help[start]), i - start));
start = i + 1;
}
}
if (start < i) {
vhelps.push_back(string(&(def.def_val_help[start]), i - start));
}
// process each line
for (i = 0; i < vhelps.size(); i++) {
size_t sc;
if ((sc = vhelps[i].find(';')) == vhelps[i].npos) {
// no ';'
if (i == 0 && def.def_type != ERROR_TYPE) {
// first val_help. pair with "type".
help_pairs.push_back(pair<string, string>(
type_to_name(def.def_type), vhelps[i]));
}
if (i == 1 && def.def_type2 != ERROR_TYPE) {
// second val_help. pair with "type2".
help_pairs.push_back(pair<string, string>(
type_to_name(def.def_type2), vhelps[i]));
}
} else {
// ';' at index sc
help_pairs.push_back(pair<string, string>(
vhelps[i].substr(0, sc),
vhelps[i].substr(sc + 1)));
}
}
} else if (def.def_type && def.def_node_help) {
// simple case. just use "type" and "help"
help_pairs.push_back(pair<string, string>(type_to_name(def.def_type),
def.def_node_help));
}
}
// this var is the array of possible completions
env = (C_ENV_SHAPI_COMP_VALS + "=(");
for (size_t i = 0; i < comp_vals.size(); i++) {
shell_escape_squotes(comp_vals[i]);
env += ("'" + comp_vals[i] + "' ");
}
/* as mentioned above, comp_string is the complete command output.
* let the shell eval it into the array since we don't want to
* re-implement the shell interpretation here.
*
* note that as a result, we will not be doing the filtering here.
* instead, the completion script will do the filtering on
* the resulting comp_values array. should be straightforward since
* there's no "existence filtering", only "prefix filtering".
*/
env += (comp_string + "); ");
/* this var indicates whether the last comp is "value"
* follow original implementation: if last comp is value, completion
* script needs to do the following.
* use comp_help if exists
* prefix filter comp_values
* replace any <*> in comp_values with ""
* convert help items to data representation
*/
env += (C_ENV_SHAPI_LCOMP_VAL + "=");
env += (last_comp_val ? "true; " : "false; ");
// this var is the "comp_help" string
env += (C_ENV_SHAPI_COMP_HELP + "='" + comp_help + "'; ");
// this var is the array of "help items", i.e., type names, etc.
string hitems = (C_ENV_SHAPI_HELP_ITEMS + "=(");
// this var is the array of "help strings" corresponding to the items
string hstrs = (C_ENV_SHAPI_HELP_STRS + "=(");
for (size_t i = 0; i < help_pairs.size(); i++) {
string hi = help_pairs[i].first;
string hs = help_pairs[i].second;
shell_escape_squotes(hi);
shell_escape_squotes(hs);
// get rid of leading/trailing "space" chars in help string
while (hi.size() > 0 && isspace(hi[0])) {
hi.erase(0, 1);
}
while (hs.size() > 0 && isspace(hs[0])) {
hs.erase(0, 1);
}
while (hi.size() > 0 && isspace(hi[hi.size() - 1])) {
hi.erase(hi.size() - 1);
}
while (hs.size() > 0 && isspace(hs[hs.size() - 1])) {
hs.erase(hs.size() - 1);
}
hitems += ("'" + hi + "' ");
hstrs += ("'" + hs + "' ");
}
env += (hitems + "); " + hstrs + "); ");
ret = true;
} while(0);
RESTORE_PATHS;
return ret;
}
/* set specified "logical path" in "working config".
* return true if successful. otherwise return false.
* note: assume specified path is valid (i.e., validateSetPath()).
*/
bool
Cstore::setCfgPath(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
return set_cfg_path(path_comps, true);
}
/* check if specified "arguments" is valid for "rename" operation
* return true if valid. otherwise return false.
*/
bool
Cstore::validateRenameArgs(const vector<string>& args)
{
ASSERT_IN_SESSION;
return validate_rename_copy(args, "rename");
}
/* check if specified "arguments" is valid for "copy" operation
* return true if valid. otherwise return false.
*/
bool
Cstore::validateCopyArgs(const vector<string>& args)
{
ASSERT_IN_SESSION;
return validate_rename_copy(args, "copy");
}
/* check if specified "arguments" is valid for "move" operation
* return true if valid. otherwise return false.
*/
bool
Cstore::validateMoveArgs(const vector<string>& args)
{
ASSERT_IN_SESSION;
vector<string> epath;
vector<string> nargs;
if (!conv_move_args_for_rename(args, epath, nargs)) {
output_user("Invalid move command\n");
return false;
}
SAVE_PATHS;
append_cfg_path(epath);
append_tmpl_path(epath);
bool ret = validate_rename_copy(nargs, "move");
RESTORE_PATHS;
return ret;
}
/* check if specified "arguments" is valid for "comment" operation
* return true if valid. otherwise return false.
*/
bool
Cstore::validateCommentArgs(const vector<string>& args, vtw_def& def)
{
ASSERT_IN_SESSION;
/* separate path from comment.
* follow the original implementation: the last arg is the comment, and
* everything else is part of the path.
*/
vector<string> path_comps(args);
string comment = args.back();
path_comps.pop_back();
// check the path
string terr;
if (!get_parsed_tmpl(path_comps, false, def, terr)) {
output_user("%s\n", terr.c_str());
return false;
}
// here we want to include deactivated nodes
if (!cfg_path_exists(path_comps, false, true)) {
output_user("The specified config node does not exist\n");
return false;
}
if (def.is_value && !def.tag) {
/* XXX differ from the original implementation, which allows commenting
* on a "value" BUT silently "promote" the comment to the parent
* "node". this will probably create confusion for the user.
*
* just disallow such cases here.
*/
output_user("Cannot comment on config values\n");
return false;
}
if (def.tag && !def.is_value) {
/* XXX follow original implementation and disallow comment on a
* "tag node". this is because "show" does not display such
* comments (see bug 5794).
*/
output_user("Cannot add comment at this level\n");
return false;
}
if (comment.find_first_of('*') != string::npos) {
// don't allow '*'. this is due to config files using C-style /**/
// comments. this probably belongs to lower-level, but we are enforcing
// it here.
output_user("Cannot use the '*' character in a comment\n");
return false;
}
return true;
}
/* perform rename in "working config" according to specified args.
* return true if successful. otherwise return false.
* note: assume args are already validated (i.e., validateRenameArgs()).
*/
bool
Cstore::renameCfgPath(const vector<string>& args)
{
ASSERT_IN_SESSION;
string otagnode = args[0];
string otagval = args[1];
string ntagval = args[4];
push_cfg_path(otagnode);
/* also mark changed. note that it's marking the "tag node" but not the
* "tag values" since one is being "deleted" and the other is being
* "added" anyway.
*/
bool ret = (rename_child_node(otagval, ntagval)
&& mark_changed_with_ancestors());
pop_cfg_path();
return ret;
}
/* perform copy in "working config" according to specified args.
* return true if successful. otherwise return false.
* note: assume args are already validated (i.e., validateCopyArgs()).
*/
bool
Cstore::copyCfgPath(const vector<string>& args)
{
ASSERT_IN_SESSION;
string otagnode = args[0];
string otagval = args[1];
string ntagval = args[4];
push_cfg_path(otagnode);
/* also mark changed. note that it's marking the "tag node" but not the
* new "tag value" since it is being "added" anyway.
*/
bool ret = (copy_child_node(otagval, ntagval)
&& mark_changed_with_ancestors());
pop_cfg_path();
return ret;
}
/* perform "comment" in working config according to specified args.
* return true if valid. otherwise return false.
*/
bool
Cstore::commentCfgPath(const vector<string>& args, const vtw_def& def)
{
ASSERT_IN_SESSION;
// separate path from comment
vector<string> path_comps(args);
string comment = args.back();
path_comps.pop_back();
SAVE_PATHS;
append_cfg_path(path_comps);
bool ret;
if (comment == "") {
// follow original impl: empty comment => remove it
ret = remove_comment();
if (!ret) {
output_user("Failed to remove comment for specified config node\n");
}
} else {
ret = set_comment(comment);
if (!ret) {
output_user("Failed to add comment for specified config node\n");
}
}
RESTORE_PATHS;
if (ret) {
// mark the root as changed for "comment"
ret = mark_changed_with_ancestors();
}
return ret;
}
/* discard all changes in working config.
* return true if successful. otherwise return false.
*/
bool
Cstore::discardChanges()
{
ASSERT_IN_SESSION;
// just call underlying implementation
unsigned long long num_removed = 0;
if (discard_changes(num_removed)) {
if (num_removed > 0) {
output_user("Changes have been discarded\n");
} else {
output_user("No changes have been discarded\n");
}
return true;
}
return false;
}
/* perform move in "working config" according to specified args.
* return true if successful. otherwise return false.
* note: assume args are already validated (i.e., validateMoveArgs()).
*/
bool
Cstore::moveCfgPath(const vector<string>& args)
{
ASSERT_IN_SESSION;
vector<string> epath;
vector<string> nargs;
if (!conv_move_args_for_rename(args, epath, nargs)) {
output_user("Invalid move command\n");
return false;
}
SAVE_PATHS;
append_cfg_path(epath);
append_tmpl_path(epath);
bool ret = renameCfgPath(nargs);
RESTORE_PATHS;
return ret;
}
/* check if specified "logical path" exists in working config (i.e., the union)
* or active config (i.e., the original).
* return true if it exists. otherwise return false.
*/
bool
Cstore::cfgPathExists(const vector<string>& path_comps, bool active_cfg)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
return cfg_path_exists(path_comps, active_cfg, false);
}
// same as above but "deactivate-aware"
bool
Cstore::cfgPathExistsDA(const vector<string>& path_comps, bool active_cfg,
bool include_deactivated)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
return cfg_path_exists(path_comps, active_cfg, include_deactivated);
}
/* check if specified "logical path" has been deleted in working config.
*/
bool
Cstore::cfgPathDeleted(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
// whether it's in active but not in working
return (cfg_path_exists(path_comps, true, false)
&& !cfg_path_exists(path_comps, false, false));
}
/* check if specified "logical path" has been added in working config.
*/
bool
Cstore::cfgPathAdded(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
// whether it's not in active but in working
return (!cfg_path_exists(path_comps, true, false)
&& cfg_path_exists(path_comps, false, false));
}
/* check if specified "logical path" has been "changed" in working config.
* XXX the definition of "changed" is different from the original
* perl API implementation isChanged(), which was inconsistent between
* "deleted" and "deactivated".
*
* original logic (with $disable arg not defined) returns true in
* either of the 2 cases below:
* (1) node is BEING deactivated or activated
* (2) node appears in changes_only dir
* which means it returns false for nodes being deleted but true
* for nodes being deactivated.
*
* new logic returns true if any of the following is true
* (remember this functions is NOT "deactivate-aware")
* (1) cfgPathDeleted()
* (2) cfgPathAdded()
* (3) cfg_node_changed()
*/
bool
Cstore::cfgPathChanged(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
if (cfgPathDeleted(path_comps) || cfgPathAdded(path_comps)) {
return true;
}
SAVE_PATHS;
append_cfg_path(path_comps);
bool ret = cfg_node_changed();
RESTORE_PATHS;
return ret;
}
/* get names of "deleted" child nodes of specified path during commit
* operation. names are returned in cnodes.
*/
void
Cstore::cfgPathGetDeletedChildNodes(const vector<string>& path_comps,
vector<string>& cnodes)
{
ASSERT_IN_SESSION;
cfgPathGetDeletedChildNodesDA(path_comps, cnodes, false);
}
// same as above but "deactivate-aware"
void
Cstore::cfgPathGetDeletedChildNodesDA(const vector<string>& path_comps,
vector<string>& cnodes,
bool include_deactivated)
{
ASSERT_IN_SESSION;
vector<string> acnodes;
cfgPathGetChildNodesDA(path_comps, acnodes, true, include_deactivated);
vector<string> wcnodes;
cfgPathGetChildNodesDA(path_comps, wcnodes, false, include_deactivated);
MapT<string, bool> cmap;
for (size_t i = 0; i < wcnodes.size(); i++) {
cmap[wcnodes[i]] = true;
}
for (size_t i = 0; i < acnodes.size(); i++) {
if (cmap.find(acnodes[i]) == cmap.end()) {
// in active but not in working
cnodes.push_back(acnodes[i]);
}
}
sort_nodes(cnodes);
}
/* get "deleted" values of specified "multi node" during commit
* operation. values are returned in dvals. if specified path is not
* a "multi node", it's a nop.
*
* NOTE: this function does not consider the "value ordering". the "deleted"
* status is purely based on the presence/absence of a value.
*/
void
Cstore::cfgPathGetDeletedValues(const vector<string>& path_comps,
vector<string>& dvals)
{
ASSERT_IN_SESSION;
cfgPathGetDeletedValuesDA(path_comps, dvals, false);
}
// same as above but DA
void
Cstore::cfgPathGetDeletedValuesDA(const vector<string>& path_comps,
vector<string>& dvals,
bool include_deactivated)
{
ASSERT_IN_SESSION;
vector<string> ovals;
vector<string> nvals;
if (!cfgPathGetValuesDA(path_comps, ovals, true, include_deactivated)
|| !cfgPathGetValuesDA(path_comps, nvals, false, include_deactivated)) {
return;
}
MapT<string, bool> dmap;
for (size_t i = 0; i < nvals.size(); i++) {
dmap[nvals[i]] = true;
}
for (size_t i = 0; i < ovals.size(); i++) {
if (dmap.find(ovals[i]) == dmap.end()) {
// in active but not in working
dvals.push_back(ovals[i]);
}
}
}
/* check whether specified path is "deactivated" in working config or
* active config.
* a node is "deactivated" if the node itself or any of its ancestors is
* "marked deactivated".
*/
bool
Cstore::cfgPathDeactivated(const vector<string>& path_comps, bool active_cfg)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
vector<string> ppath;
for (size_t i = 0; i < path_comps.size(); i++) {
ppath.push_back(path_comps[i]);
if (cfgPathMarkedDeactivated(ppath, active_cfg)) {
// an ancestor or itself is marked deactivated
return true;
}
}
return false;
}
/* check whether specified path is "marked deactivated" in working config or
* active config.
* a node is "marked deactivated" if a deactivate operation has been
* performed on the node.
*/
bool
Cstore::cfgPathMarkedDeactivated(const vector<string>& path_comps,
bool active_cfg)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
SAVE_PATHS;
append_cfg_path(path_comps);
bool ret = marked_deactivated(active_cfg);
RESTORE_PATHS;
return ret;
}
/* get names of child nodes of specified path in working config or active
* config. names are returned in cnodes.
*/
void
Cstore::cfgPathGetChildNodes(const vector<string>& path_comps,
vector<string>& cnodes, bool active_cfg)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
cfgPathGetChildNodesDA(path_comps, cnodes, active_cfg, false);
}
// same as above but "deactivate-aware"
void
Cstore::cfgPathGetChildNodesDA(const vector<string>& path_comps,
vector<string>& cnodes, bool active_cfg,
bool include_deactivated)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
if (!include_deactivated && cfgPathDeactivated(path_comps, active_cfg)) {
/* this node is deactivated (an ancestor or this node itself is
* marked deactivated) and we don't want to include deactivated. nop.
*/
return;
}
SAVE_PATHS;
append_cfg_path(path_comps);
get_all_child_node_names(cnodes, active_cfg, include_deactivated);
RESTORE_PATHS;
sort_nodes(cnodes);
}
/* get value of specified single-value node.
* value: (output) node value.
* active_cfg: whether to get value from active config.
* return false if fails (invalid node, doesn't exist, read fails, etc.).
* otherwise return true.
*/
bool
Cstore::cfgPathGetValue(const vector<string>& path_comps, string& value,
bool active_cfg)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
return cfgPathGetValueDA(path_comps, value, active_cfg, false);
}
// same as above but "deactivate-aware"
bool
Cstore::cfgPathGetValueDA(const vector<string>& path_comps, string& value,
bool active_cfg, bool include_deactivated)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
vtw_def def;
if (!get_parsed_tmpl(path_comps, false, def)) {
// invalid node
return false;
}
/* note: the behavior here is different from original perl API, which
* does not check if specified node is indeed single-value. so if
* the function is erroneously used on a multi-value node, the
* original API will return a single string that includes all values.
* this new function will return failure in such cases.
*/
if (def.is_value || def.multi || def.tag || def.def_type == ERROR_TYPE) {
// specified path is not a single-value node
return false;
}
if (!cfg_path_exists(path_comps, active_cfg, include_deactivated)) {
// specified node doesn't exist
return false;
}
vector<string> vvec;
SAVE_PATHS;
append_cfg_path(path_comps);
bool ret = false;
if (read_value_vec(vvec, active_cfg)) {
if (vvec.size() >= 1) {
// if for some reason we got multiple values, just take the first one.
value = vvec[0];
ret = true;
}
}
RESTORE_PATHS;
return ret;
}
/* get values of specified multi-value node.
* values: (output) node values.
* active_cfg: whether to get values from active config.
* return false if fails (invalid node, doesn't exist, etc.).
* otherwise return true.
*/
bool
Cstore::cfgPathGetValues(const vector<string>& path_comps,
vector<string>& values, bool active_cfg)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
return cfgPathGetValuesDA(path_comps, values, active_cfg, false);
}
// same as above but "deactivate-aware"
bool
Cstore::cfgPathGetValuesDA(const vector<string>& path_comps,
vector<string>& values, bool active_cfg,
bool include_deactivated)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
vtw_def def;
if (!get_parsed_tmpl(path_comps, false, def)) {
// invalid node
return false;
}
/* note: the behavior here is different from original perl API, which
* does not check if specified node is indeed multi-value. so if
* the function is erroneously used on a single-value node, the
* original API will return the node's value. this new function
* will return failure in such cases.
*/
if (def.is_value || !def.multi || def.tag || def.def_type == ERROR_TYPE) {
// specified path is not a multi-value node
return false;
}
if (!cfg_path_exists(path_comps, active_cfg, include_deactivated)) {
// specified node doesn't exist
return false;
}
SAVE_PATHS;
append_cfg_path(path_comps);
bool ret = read_value_vec(values, active_cfg);
RESTORE_PATHS;
return ret;
}
/* get comment of specified node.
* comment: (output) node comment.
* active_cfg: whether to get comment from active config.
* return false if fails (invalid node, doesn't exist, etc.).
* otherwise return true.
*/
bool
Cstore::cfgPathGetComment(const vector<string>& path_comps, string& comment,
bool active_cfg)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
SAVE_PATHS;
append_cfg_path(path_comps);
bool ret = get_comment(comment, active_cfg);
RESTORE_PATHS;
return ret;
}
/* return whether specified path is "default". if a node is "default", it
* is currently not shown by the "show" command unless "-all" is specified.
* active_cfg: whether to observe active config.
*/
bool
Cstore::cfgPathDefault(const vector<string>& path_comps, bool active_cfg)
{
if (!active_cfg) {
ASSERT_IN_SESSION;
}
SAVE_PATHS;
append_cfg_path(path_comps);
bool ret = marked_display_default(active_cfg);
RESTORE_PATHS;
return ret;
}
/* the following functions are observers of the "effective" config.
* they can be used
* (1) outside a config session (e.g., op mode, daemons, callbacks, etc.).
* OR
* (2) during a config session
*
* HOWEVER, NOTE that the definition of "effective" is different under these
* two scenarios.
* (1) when used outside a config session, "effective" == "active".
* in other words, in such cases the effective config is the same
* as the running config.
*
* (2) when used during a config session, a config path (leading to either
* a "node" or a "value") is "effective" if ANY of the following
* is true.
* (a) active && working
* path is in both active and working configs, i.e., unchanged.
* (b) !active && working && committed
* path is not in active, has been set in working, AND has
* already been committed, i.e., "commit" has successfully
* processed the addition/update of the path.
* (c) active && !working && !committed
* path is in active, has been deleted from working, AND
* has not been committed yet, i.e., "commit" (per priority) has
* not processed the deletion of the path yet, or it has been
* processed but failed.
*
* note: during commit, deactivate has the same effect as delete. so
* in such cases, as far as these functions are concerned,
* deactivated nodes don't exist.
*
* originally, these functions are exclusively for use during config
* sessions. however, for some usage scenarios, it is useful to have a set
* of API functions that can be used both during and outside config
* sessions. therefore, definition (1) is added above for convenience.
*
* for example, a developer can use these functions in a script that can
* be used both during a commit action and outside config mode, as long as
* the developer is clearly aware of the difference between the above two
* definitions.
*
* note that when used outside a config session (i.e., definition (1)),
* these functions are equivalent to the observers for the "active" config.
*
* to avoid any confusion, when possible (e.g., in a script that is
* exclusively used in op mode), developers should probably use those
* "active" observers explicitly when outside a config session instead
* of these "effective" observers.
*
* it is also important to note that when used outside a config session,
* due to race conditions, it is possible that the "observed" active config
* becomes out-of-sync with the config that is actually "in effect".
* specifically, this happens when two things occur simultaneously:
* (a) an observer function is called from outside a config session.
* AND
* (b) someone invokes "commit" inside a config session (any session).
*
* this is because "commit" only updates the active config at the end after
* all commit actions have been executed, so before the update happens,
* some config nodes have already become "effective" but are not yet in the
* "active config" and therefore are not observed by these functions.
*
* note that this is only a problem when the caller is outside config mode.
* in such cases, the caller (which could be an op-mode command, a daemon,
* a callback script, etc.) already must be able to handle config changes
* that can happen at any time. if "what's configured" is more important,
* using the "active config" should be fine as long as it is relatively
* up-to-date. if the actual "system state" is more important, then the
* caller should probably just check the system state in the first place
* (instead of using these config observers).
*
* one possible solution is for these "effective" observers to obtain the
* global commit lock before returning their observations. this has not
* been implemented yet since the impact of this issue is not clear at
* the moment.
*/
// return whether specified path is "effective".
bool
Cstore::cfgPathEffective(const vector<string>& path_comps)
{
vtw_def def;
if (!validateTmplPath(path_comps, false, def)) {
// invalid path
return false;
}
bool in_active = cfg_path_exists(path_comps, true, false);
if (!inSession()) {
// not in a config session. use active config only.
return in_active;
}
bool in_work = cfg_path_exists(path_comps, false, false);
if (in_active && in_work) {
// case (1)
return true;
}
bool ret = false;
SAVE_PATHS;
append_cfg_path(path_comps);
if (!in_active && in_work) {
// check if case (2)
ret = marked_committed(def, true);
} else if (in_active && !in_work) {
// check if case (3)
ret = !marked_committed(def, false);
}
RESTORE_PATHS;
return ret;
}
/* get names of "effective" child nodes of specified path during commit
* operation. see above function for definition of "effective".
* names are returned in cnodes.
*/
void
Cstore::cfgPathGetEffectiveChildNodes(const vector<string>& path_comps,
vector<string>& cnodes)
{
if (!inSession()) {
// not in a config session. use active config only.
cfgPathGetChildNodes(path_comps, cnodes, true);
return;
}
// get a union of active and working
MapT<string, bool> cmap;
vector<string> acnodes;
vector<string> wcnodes;
cfgPathGetChildNodes(path_comps, acnodes, true);
cfgPathGetChildNodes(path_comps, wcnodes, false);
for (size_t i = 0; i < acnodes.size(); i++) {
cmap[acnodes[i]] = true;
}
for (size_t i = 0; i < wcnodes.size(); i++) {
cmap[wcnodes[i]] = true;
}
// get only the effective ones from the union
vector<string> ppath = path_comps;
MapT<string, bool>::iterator it = cmap.begin();
for (; it != cmap.end(); ++it) {
string c = (*it).first;
ppath.push_back(c);
if (cfgPathEffective(ppath)) {
cnodes.push_back(c);
}
ppath.pop_back();
}
sort_nodes(cnodes);
}
/* get the "effective" value of specified path during commit operation.
* value: (output) node value
* return true if successful. otherwise return false.
*/
bool
Cstore::cfgPathGetEffectiveValue(const vector<string>& path_comps,
string& value)
{
if (!inSession()) {
// not in a config session. use active config only.
return cfgPathGetValue(path_comps, value, true);
}
vector<string> ppath = path_comps;
string oval, nval;
bool oret = cfgPathGetValue(path_comps, oval, true);
bool nret = cfgPathGetValue(path_comps, nval, false);
bool ret = false;
// all 4 combinations of oret and nret are covered below
if (nret) {
// got new value
ppath.push_back(nval);
if (cfgPathEffective(ppath)) {
// nval already effective
value = nval;
ret = true;
} else if (!oret) {
// no oval. failure.
} else {
// oval still effective
value = oval;
ret = true;
}
} else if (oret) {
// got oval only
ppath.push_back(oval);
if (cfgPathEffective(ppath)) {
// oval still effective
value = oval;
ret = true;
}
}
return ret;
}
/* get the "effective" values of specified path during commit operation.
* values: (output) node values
* return true if successful. otherwise return false.
*/
bool
Cstore::cfgPathGetEffectiveValues(const vector<string>& path_comps,
vector<string>& values)
{
if (!inSession()) {
// not in a config session. use active config only.
cfgPathGetValues(path_comps, values, true);
return (values.size() > 0);
}
// get a union of active and working
MapT<string, bool> vmap;
vector<string> ovals;
vector<string> nvals;
cfgPathGetValues(path_comps, ovals, true);
cfgPathGetValues(path_comps, nvals, false);
for (size_t i = 0; i < ovals.size(); i++) {
vmap[ovals[i]] = true;
}
for (size_t i = 0; i < nvals.size(); i++) {
vmap[nvals[i]] = true;
}
// get only the effective ones from the union
vector<string> ppath = path_comps;
MapT<string, bool>::iterator it = vmap.begin();
for (; it != vmap.end(); ++it) {
string c = (*it).first;
ppath.push_back(c);
if (cfgPathEffective(ppath)) {
values.push_back(c);
}
ppath.pop_back();
}
return (values.size() > 0);
}
/* get the value string that corresponds to specified variable ref string.
* ref_str: var ref string (e.g., "./cost/@").
* type: (output) the node type.
* from_active: if true, value string should come from "active config".
* otherwise from "working config".
* return a pointer to the value string if successful (caller must free).
* otherwise return NULL.
*/
char *
Cstore::getVarRef(const string& ref_str, vtw_type_e& type, bool from_active)
{
char *ret = NULL;
SAVE_PATHS;
VarRef vref(this, ref_str, from_active);
string val;
vtw_type_e t;
if (vref.getValue(val, t)) {
type = t;
// follow original implementation. caller is supposed to free this.
ret = strdup(val.c_str());
}
RESTORE_PATHS;
return ret;
}
/* set the node corresponding to specified variable ref string to specified
* value.
* ref_str: var ref string (e.g., "../encrypted-password/@").
* value: value to be set.
* to_active: if true, set in "active config".
* otherwise in "working config".
* return true if successful. otherwise return false.
*/
bool
Cstore::setVarRef(const string& ref_str, const string& value, bool to_active)
{
/* XXX functions in cli_new only performs "set var ref" operations (e.g.,
* '$VAR(@) = ""', which sets current node's value to empty string)
* during "commit", i.e., if a "set var ref" is specified in
* "syntax:", it will not be performed during "set" (but will be
* during commit).
*
* since commit has not been converted to use the new library, it
* does not use this function. instead, it uses the "cli_val_engine"
* implementation (where filesystem paths are deeply embedded, which
* makes it difficult to abstract low-level filesystem operations
* from high-level functions). as a result, this function is unused
* and untested at the moment. must revisit when converting commit.
*/
SAVE_PATHS;
VarRef vref(this, ref_str, to_active);
vector<string> pcomps;
bool ret = false;
if (vref.getSetPath(pcomps)) {
reset_paths();
vtw_def def;
if (get_parsed_tmpl(pcomps, false, def)) {
if (!def.is_value && !def.tag && !def.multi
&& def.def_type != ERROR_TYPE) {
// currently only support single-value node
append_cfg_path(pcomps);
if (write_value(value, to_active)) {
ret = true;
}
}
}
}
RESTORE_PATHS;
return ret;
}
/* perform deactivate operation on a node, i.e., make the node
* "marked deactivated".
* note: assume all validations have been peformed (see activate.cpp).
* also, when marking a node as deactivated, all of its descendants
* that had been marked deactivated are unmarked.
*/
bool
Cstore::markCfgPathDeactivated(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
if (cfgPathDeactivated(path_comps)) {
output_user("The specified configuration node is already deactivated\n");
// treat as success
return true;
}
SAVE_PATHS;
append_cfg_path(path_comps);
// note: also mark changed
bool ret = (mark_deactivated() && unmark_deactivated_descendants()
&& mark_changed_with_ancestors());
RESTORE_PATHS;
return ret;
}
/* perform activate operation on a node, i.e., make the node no longer
* "marked deactivated".
* note: assume all validations have been peformed (see activate.cpp).
*/
bool
Cstore::unmarkCfgPathDeactivated(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
SAVE_PATHS;
append_cfg_path(path_comps);
// note: also mark changed
bool ret = (unmark_deactivated() && mark_changed_with_ancestors());
RESTORE_PATHS;
return ret;
}
/* "changed" status handling.
* the "changed" status is used during commit to check if a node has been
* changed. note that if a node is "changed", all of its ancestors are also
* considered changed (this follows the original logic).
*
* the original backend implementation only uses the "changed" marker at
* "root" to indicate whether the whole config has changed. for the rest
* of the config hierarchy, the original implementation treated all nodes
* that are present in the unionfs "changes only" directory as "changed".
*
* this worked until the introduction of "deactivate". since deactivated
* nodes are also present in the "changes only" directory, the backend
* treat them as "changed". on the other hand, deleted nodes don't appear
* in "changes only", so they are _not_ treated as "changed". this creates
* problems in various parts of the backend.
*
* the new CLI backend/library "marks" all changed nodes explicitly, and the
* "changed" status depends on such markers. the marking is done using the
* pure virtual mark_changed_with_ancestors() function, which is provided
* by the low-level implementation, so it does not have to be done as a
* "per-node file marker" as long as the low-level implementation can
* correctly answer the "changed" query for a given path.
*
* note that "changed" nodes does not include "added" and "deleted" nodes.
* for the convenience of implementation, the backend must always query
* for "changed" nodes *after* "added" and "deleted" nodes. in other
* words, the backend will only treat a node as "changed" if it is neither
* "added" nor "deleted". currently there are only two places that perform
* changed status query: cfgPathGetChildNodesStatus() and
* cfgPathGetChildNodesStatusDA(). see those two functions for the usage.
*
* what this means is that the backend can choose to either mark or not
* mark "added"/"deleted" nodes as "changed" at its convenience. for
* example, "set" and "delete" always do the marking, but "rename" and
* "copy" do not.
*
* changed status queries are provided by the cfg_node_changed() function,
* and changed markers can be removed by unmarkCfgPathChanged() below (used
* by "commit").
*/
/* unmark "changed" status of specified path in working config.
* this is used, e.g., at the end of "commit" to reset a subtree.
* note: unmarking a node means all of its descendants are also unmarked,
* i.e., they become "unchanged".
* return true if successful. otherwise return false.
*/
bool
Cstore::unmarkCfgPathChanged(const vector<string>& path_comps)
{
ASSERT_IN_SESSION;
SAVE_PATHS;
append_cfg_path(path_comps);
bool ret = unmark_changed_with_descendants();
RESTORE_PATHS;
return ret;
}
////// protected functions
void
Cstore::output_user(const char *fmt, ...)
{
va_list alist;
va_start(alist, fmt);
if (out_stream) {
vfprintf(out_stream, fmt, alist);
} else {
vprintf(fmt, alist);
}
va_end(alist);
}
void
Cstore::output_internal(const char *fmt, ...)
{
va_list alist;
va_start(alist, fmt);
int fdout = -1;
FILE *fout = NULL;
do {
if ((fdout = open(C_LOGFILE_STDOUT.c_str(),
O_WRONLY | O_CREAT, 0660)) == -1) {
break;
}
if (lseek(fdout, 0, SEEK_END) == ((off_t) -1)) {
break;
}
if ((fout = fdopen(fdout, "a")) == NULL) {
break;
}
vfprintf(fout, fmt, alist);
} while (0);
va_end(alist);
if (fout) {
fclose(fout);
// fdout is implicitly closed
} else if (fdout >= 0) {
close(fdout);
}
}
////// private functions
bool
Cstore::sort_func_deb_version(string a, string b)
{
return (pkgVersionCompare(a, b) < 0);
}
void
Cstore::sort_nodes(vector<string>& nvec, unsigned int sort_alg)
{
if (_sort_func_map.find(sort_alg) == _sort_func_map.end()) {
return;
}
sort(nvec.begin(), nvec.end(), _sort_func_map[sort_alg]);
}
/* try to append the logical path to template path.
* is_tag: (output) whether the last component is a "tag".
* return false if logical path is not valid. otherwise return true.
*/
bool
Cstore::append_tmpl_path(const vector<string>& path_comps, bool& is_tag)
{
is_tag = false;
for (size_t i = 0; i < path_comps.size(); i++) {
push_tmpl_path(path_comps[i]);
if (tmpl_node_exists()) {
// got exact match. continue to next component.
continue;
}
// not exact match. check if it's a tag.
pop_tmpl_path();
push_tmpl_path_tag();
if (tmpl_node_exists()) {
// got tag match. continue to next component.
if (i == (path_comps.size() - 1)) {
// last comp
is_tag = true;
}
continue;
}
// not a valid path
return false;
}
return true;
}
/* check whether specified "logical path" is valid template path.
* then template at the path is parsed.
* path_comps: vector of path components.
* validate_vals: whether to validate all "values" along specified path.
* def: (output) parsed template.
* error: (output) error message if failed.
* return false if invalid template path. otherwise return true.
* note:
* also, if last path component is value (i.e., def.is_value), the template
* parsed is actually at "full path - 1".
*/
bool
Cstore::get_parsed_tmpl(const vector<string>& path_comps, bool validate_vals,
vtw_def& def, string& error)
{
// default error message
error = "The specified configuration node is not valid";
if (tmpl_path_at_root() && path_comps.size() == 0) {
// empty path not valid
return false;
}
/* note: this function may be invoked recursively (depth 1) when
* validating values, i.e., validate_value will process variable
* reference, which calls this indirectly to get templates.
* so need special save/restore identifier.
*/
const char *not_validating = "get_parsed_tmpl_not_validating";
if (validate_vals) {
SAVE_PATHS;
} else {
save_paths(not_validating);
}
/* need at least 1 comp to work. 2 comps if last comp is value.
* so pop tmpl_path and prepend them. note that path_comps remain
* constant.
*/
vector<string> *pcomps = const_cast<vector<string> *>(&path_comps);
vector<string> new_path_comps;
if (path_comps.size() < 2) {
new_path_comps = path_comps;
pcomps = &new_path_comps;
for (unsigned int i = 0; i < 2 && pcomps->size() < 2; i++) {
if (!tmpl_path_at_root()) {
pcomps->insert(pcomps->begin(), pop_tmpl_path());
}
}
}
bool ret = false;
do {
/* cases for template path:
* (1) valid path ending in "actual node", i.e., typeless node, tag node,
* single-value node, or multi-value node:
* => tmpl at full path. e.g.:
* typeless node: "service ssh allow-root"
* tag node: "interfaces ethernet"
* single-value node: "system gateway-address"
* multi-value node: "system name-server"
* (2) valid path ending in "value", i.e., tag (value of tag node), or
* value of single-/multi-value node:
* => tmpl at "full path - 1". e.g.:
* "value" of tag node: "interfaces ethernet eth0"
* value of single-value node: "system gateway-address 1.1.1.1"
* value of multi-value node: "system name-server 2.2.2.2"
* (3) invalid path
* => no tmpl
*/
// first scan up to "full path - 1"
bool valid = true;
for (size_t i = 0; i < (pcomps->size() - 1); i++) {
if ((*pcomps)[i] == "") {
// only the last component is potentially allowed to be empty str
valid = false;
break;
}
bool is_tag;
if (append_tmpl_path((*pcomps)[i], is_tag)) {
if (is_tag && validate_vals) {
/* last comp is tag and want to validate value.
* note: validate_val() will use the current tmpl path and cfg path.
* so need both at the "node" level before calling it.
* at this point cfg path is not pushed yet so no need to
* pop it.
*/
pop_tmpl_path();
if (!validate_val(NULL, (*pcomps)[i])) {
// invalid value
error = "Value validation failed";
valid = false;
break;
}
// restore tmpl path
append_tmpl_path((*pcomps)[i], is_tag);
}
/* cfg path is not used here but is needed by validate_val(), so
* need to keep it in sync with tmpl path.
*/
push_cfg_path((*pcomps)[i]);
} else {
// not a valid path
valid = false;
break;
}
}
if (!valid) {
// case (3)
break;
}
/* we are valid up to "full path - 1". now process last path component.
* first, if we are case (2), we should find a "value node" at this point.
* note: this is only possible if there are more than 1 component. otherwise
* we haven't done anything yet.
*/
if (pcomps->size() > 1) {
if (tmpl_parse(def)) {
if (def.tag || def.multi || def.def_type != ERROR_TYPE) {
// case (2). last component is "value".
if (validate_vals) {
// validate value
if (!validate_val(&def, (*pcomps)[pcomps->size() - 1])) {
// invalid value
error = "Value validation failed";
break;
}
}
def.is_value = 1;
ret = true;
break;
}
}
// if no valid template or not a value, it's not case (2) so continue.
}
// now check last component
if ((*pcomps)[pcomps->size() - 1] == "") {
// only value is potentially allowed to be empty str
break;
}
push_tmpl_path((*pcomps)[pcomps->size() - 1]);
// no need to push cfg path (only needed for validate_val())
if (tmpl_node_exists()) {
// case (1). last component is "node".
if (!tmpl_parse(def)) {
exit_internal("failed to parse tmpl [%s]\n",
tmpl_path_to_str().c_str());
}
def.is_value = 0;
ret = true;
break;
}
// case (3) (fall through)
} while (0);
if (validate_vals) {
RESTORE_PATHS;
} else {
restore_paths(not_validating);
}
return ret;
}
/* check if specified "logical path" is valid for "activate" or
* "deactivate" operation.
* return true if valid. otherwise return false.
*/
bool
Cstore::validate_act_deact(const vector<string>& path_comps, const string& op,
vtw_def& def)
{
string terr;
if (!get_parsed_tmpl(path_comps, false, def, terr)) {
output_user("%s\n", terr.c_str());
return false;
}
{
/* XXX this is a temporary workaround for bug 5708, which should be
* addressed _after_ the "default value"-related issues have been
* resolved (see bug for more details). once those are resolved,
* this workaround should be removed and the bug fixed properly.
*/
if (!def.tag && def.def_type != ERROR_TYPE) {
output_user("Cannot %s a leaf configuration node\n", op.c_str());
return false;
}
}
if (def.is_value && !def.tag) {
/* last component is a value of a single- or multi-value node (i.e.,
* a leaf value) => not allowed
*/
output_user("Cannot %s a leaf configuration value\n", op.c_str());
return false;
}
if (!cfg_path_exists(path_comps, false, true)) {
output_user("Nothing to %s (the specified %s does not exist)\n",
op.c_str(), (!def.is_value || def.tag) ? "node" : "value");
return false;
}
return true;
}
/* check if specified args is valid for "rename" or "copy" operation.
* return true if valid. otherwise return false.
*/
bool
Cstore::validate_rename_copy(const vector<string>& args, const string& op)
{
if (args.size() != 5 || args[2] != "to") {
output_user("Invalid %s command\n", op.c_str());
return false;
}
string otagnode = args[0];
string otagval = args[1];
string ntagnode = args[3];
string ntagval = args[4];
if (otagnode != ntagnode) {
output_user("Cannot %s from \"%s\" to \"%s\"\n",
op.c_str(), otagnode.c_str(), ntagnode.c_str());
return false;
}
// check the old path
vector<string> ppath;
ppath.push_back(otagnode);
ppath.push_back(otagval);
vtw_def def;
string terr;
if (!get_parsed_tmpl(ppath, false, def, terr)) {
output_user("%s\n", terr.c_str());
return false;
}
if (!def.is_value || !def.tag) {
// can only rename "tagnode tagvalue"
output_user("Cannot %s under \"%s\"\n", op.c_str(), otagnode.c_str());
return false;
}
if (!cfg_path_exists(ppath, false, true)) {
output_user("Configuration \"%s %s\" does not exist\n",
otagnode.c_str(), otagval.c_str());
return false;
}
// check the new path
ppath.pop_back();
ppath.push_back(ntagval);
if (cfg_path_exists(ppath, false, true)) {
output_user("Configuration \"%s %s\" already exists\n",
ntagnode.c_str(), ntagval.c_str());
return false;
}
if (!get_parsed_tmpl(ppath, true, def, terr)) {
output_user("%s\n", terr.c_str());
return false;
}
return true;
}
// convert args for "move" to be used for equivalent "rename" operation
bool
Cstore::conv_move_args_for_rename(const vector<string>& args,
vector<string>& edit_path_comps,
vector<string>& rn_args)
{
/* note:
* "move interfaces ethernet eth2 vif 100 to 200"
* is equivalent to
* "edit interfaces ethernet eth2" + "rename vif 100 to vif 200"
*
* set the extra levels and then just validate as rename
*/
size_t num_args = args.size();
if (num_args < 4) {
// need at least 4 args
return false;
}
for (size_t i = 0; i < (num_args - 4); i++) {
edit_path_comps.push_back(args[i]);
}
rn_args.push_back(args[num_args - 4]); // vif
rn_args.push_back(args[num_args - 3]); // 100
rn_args.push_back(args[num_args - 2]); // to
rn_args.push_back(args[num_args - 4]); // vif
rn_args.push_back(args[num_args - 1]); // 200
return true;
}
/* check if specified "logical path" exists in working config or
* active config.
* v_def: ptr to parsed template. NULL if none.
* return true if it exists. otherwise return false.
*/
bool
Cstore::cfg_path_exists(const vector<string>& path_comps,
bool active_cfg, bool include_deactivated)
{
SAVE_PATHS;
append_cfg_path(path_comps);
// first check if it's a "node".
bool ret = cfg_node_exists(active_cfg);
if (!ret) {
// doesn't exist as a node. maybe a value?
pop_cfg_path();
ret = cfg_value_exists(path_comps[path_comps.size() - 1], active_cfg);
}
RESTORE_PATHS;
if (ret && !include_deactivated
&& cfgPathDeactivated(path_comps, active_cfg)) {
// don't include deactivated
ret = false;
}
return ret;
}
/* set specified "logical path" in "working config".
* output: whether to generate output
* return true if successful. otherwise return false.
* note: assume specified path is valid (i.e., validateSetPath()).
*/
bool
Cstore::set_cfg_path(const vector<string>& path_comps, bool output)
{
vector<string> ppath;
vtw_def def;
bool ret = true;
bool path_exists = true;
// do the set from the top down
SAVE_PATHS;
for (size_t i = 0; i < path_comps.size(); i++) {
// partial path
ppath.push_back(path_comps[i]);
// get template at this level
if (!get_parsed_tmpl(ppath, false, def)) {
output_internal("paths[%s,%s]\n", cfg_path_to_str().c_str(),
tmpl_path_to_str().c_str());
for (size_t i = 0; i < ppath.size(); i++) {
output_internal(" [%s]\n", ppath[i].c_str());
}
exit_internal("failed to get tmpl during set. not validate first?\n");
}
// nop if this level already in working (including deactivated)
if (cfg_path_exists(ppath, false, true)) {
continue;
}
path_exists = false;
// this level not in working. set it.
append_cfg_path(ppath);
append_tmpl_path(ppath);
if (!def.is_value) {
// this level is a "node"
if (!add_node() || !create_default_children()) {
ret = false;
break;
}
} else if (def.tag) {
// this level is a "tag value".
// add the tag, taking the max tag limit into consideration.
if (!add_tag(def) || !create_default_children()) {
ret = false;
break;
}
} else {
// this level is a "value" of a single-/multi-value node.
// go up 1 level to get the node.
pop_cfg_path();
if (def.multi) {
// value of multi-value node.
// add the value, taking the max multi limit into consideration.
if (!add_value_to_multi(def, ppath.back())) {
ret = false;
break;
}
} else {
// value of single-value node
if (!write_value(ppath.back())) {
ret = false;
break;
}
}
}
if (!mark_changed_with_ancestors()) {
ret = false;
break;
}
RESTORE_PATHS;
}
RESTORE_PATHS; // if "break" was hit
if (ret && def.is_value && def.def_default) {
/* a node with default has been explicitly set. needs to be marked
* as non-default for display purposes.
*
* note: when the new value is the same as the old value, the behavior
* is different from before, which was a nop. the new behavior is
* that the value will remain unchanged, but the "default status"
* will be changed, i.e., it will be marked as non-default.
*/
append_cfg_path(path_comps);
pop_cfg_path();
// only do it if it's previously marked default
if (marked_display_default(false)) {
if ((ret = unmark_display_default())) {
/* XXX work around current commit's unionfs implementation problem.
* current commit's unionfs implementation looks at the "changes
* only" directory (i.e., the r/w portion of the union mount), which
* is wrong.
*
* all config information should be obtained from two directories:
* "active" and "working", e.g., instead of looking at whiteout
* files in "changes only" to find deleted nodes, nodes that are in
* "active" but not in "working" have been deleted.
*
* in this particular case, commit looks at "changes only" to read
* the node.val file. however, since the value didn't change (only
* the "default status" changed), node.val doesn't appear in
* "changes only". here we re-write the file to force it into
* "changes only" so that commit can work correctly.
*/
vector<string> vvec;
read_value_vec(vvec, false);
write_value_vec(vvec);
// pretend it didn't exist since we changed the status
path_exists = false;
// also mark changed
ret = mark_changed_with_ancestors();
}
}
RESTORE_PATHS;
}
if (path_exists) {
// whole path already exists
if (output) {
output_user("The specified configuration node already exists\n");
}
// treat as success
}
return ret;
}
/* this is the equivalent of the listNodeStatus() from the original
* perl API. it provides the "status" ("deleted", "added", "changed",
* or "static") of each child node of specified path.
* cmap: (output) contains the status of child nodes.
* sorted_keys: (output) contains sorted keys. call with NULL if not needed.
*
* note: this function is NOT "deactivate-aware".
*/
void
Cstore::get_child_nodes_status(const vector<string>& path_comps,
Cstore::MapT<string, string>& cmap,
vector<string> *sorted_keys)
{
// get a union of active and working
MapT<string, bool> umap;
vector<string> acnodes;
vector<string> wcnodes;
cfgPathGetChildNodes(path_comps, acnodes, true);
cfgPathGetChildNodes(path_comps, wcnodes, false);
for (size_t i = 0; i < acnodes.size(); i++) {
umap[acnodes[i]] = true;
}
for (size_t i = 0; i < wcnodes.size(); i++) {
umap[wcnodes[i]] = true;
}
// get the status of each one
vector<string> ppath = path_comps;
MapT<string, bool>::iterator it = umap.begin();
for (; it != umap.end(); ++it) {
string c = (*it).first;
ppath.push_back(c);
if (sorted_keys) {
sorted_keys->push_back(c);
}
// note: "changed" includes "deleted" and "added", so check those first.
if (cfgPathDeleted(ppath)) {
cmap[c] = C_NODE_STATUS_DELETED;
} else if (cfgPathAdded(ppath)) {
cmap[c] = C_NODE_STATUS_ADDED;
} else if (cfgPathChanged(ppath)) {
cmap[c] = C_NODE_STATUS_CHANGED;
} else {
cmap[c] = C_NODE_STATUS_STATIC;
}
ppath.pop_back();
}
if (sorted_keys) {
sort_nodes(*sorted_keys);
}
}
/* DA version of the above function.
* cmap: (output) contains the status of child nodes.
* sorted_keys: (output) contains sorted keys. call with NULL if not needed.
*
* note: this follows the original perl API listNodeStatus() implementation.
*/
void
Cstore::get_child_nodes_status_da(const vector<string>& path_comps,
Cstore::MapT<string, string>& cmap,
vector<string> *sorted_keys)
{
// process deleted nodes first
vector<string> del_nodes;
cfgPathGetDeletedChildNodesDA(path_comps, del_nodes);
for (size_t i = 0; i < del_nodes.size(); i++) {
if (sorted_keys) {
sorted_keys->push_back(del_nodes[i]);
}
cmap[del_nodes[i]] = C_NODE_STATUS_DELETED;
}
// get all nodes in working config
vector<string> work_nodes;
cfgPathGetChildNodesDA(path_comps, work_nodes, false);
vector<string> ppath = path_comps;
for (size_t i = 0; i < work_nodes.size(); i++) {
ppath.push_back(work_nodes[i]);
if (sorted_keys) {
sorted_keys->push_back(work_nodes[i]);
}
/* note: in the DA version here, we do NOT check the deactivate state
* when considering the state of the child nodes (which include
* deactivated ones). the reason is that this DA function is used
* for config output-related operations and should return whether
* each node is actually added/deleted from the config independent
* of its deactivate state.
*
* for "added" state, can't use cfgPathAdded() since it's not DA.
*
* for "changed" state, can't use cfgPathChanged() since it's not DA.
*
* deleted ones already handled above.
*/
if (!cfg_path_exists(ppath, true, true)
&& cfg_path_exists(ppath, false, true)) {
cmap[work_nodes[i]] = C_NODE_STATUS_ADDED;
} else {
SAVE_PATHS;
append_cfg_path(ppath);
if (cfg_node_changed()) {
cmap[work_nodes[i]] = C_NODE_STATUS_CHANGED;
} else {
cmap[work_nodes[i]] = C_NODE_STATUS_STATIC;
}
RESTORE_PATHS;
}
ppath.pop_back();
}
if (sorted_keys) {
sort_nodes(*sorted_keys);
}
}
/* remove tag at current work path and its subtree.
* if specified tag is the last one, also remove the tag node.
* return true if successful. otherwise return false.
* note: assume current work path is a tag.
*/
bool
Cstore::remove_tag()
{
if (!remove_node()) {
return false;
}
// go up one level and check if that was the last tag
bool ret = true;
string c = pop_cfg_path();
vector<string> cnodes;
// get child nodes, including deactivated ones.
get_all_child_node_names(cnodes, false, true);
if (cnodes.size() == 0) {
// it was the last tag. remove the node as well.
if (!remove_node()) {
ret = false;
}
}
push_cfg_path(c);
return ret;
}
/* remove specified value from the multi-value node at current work path.
* if specified value is the last one, also remove the multi-value node.
* return true if successful. otherwise return false.
* note: assume current work path is a multi-value node and specified value is
* configured for the node.
*/
bool
Cstore::remove_value_from_multi(const string& value)
{
// get current values
vector<string> vvec;
if (!read_value_vec(vvec, false)) {
return false;
}
// remove the value
size_t bc = vvec.size();
vector<string> nvec(vvec.begin(), remove(vvec.begin(), vvec.end(), value));
size_t ac = nvec.size();
// sanity check
if (ac == bc) {
// nothing removed
return false;
}
if (ac == 0) {
// was the last value. remove the node.
return remove_node();
} else {
// write the new values out
return write_value_vec(nvec);
}
}
/* check whether specified value exists at current work path.
* note: assume current work path is a value node.
*/
bool
Cstore::cfg_value_exists(const string& value, bool active_cfg)
{
// get current values
vector<string> vvec;
if (!read_value_vec(vvec, active_cfg)) {
return false;
}
return (find(vvec.begin(), vvec.end(), value) != vvec.end());
}
/* validate value at current template path.
* def: pointer to parsed template. NULL if none.
* val: value to be validated.
* return true if valid. otherwise return false.
* note: current template and cfg paths both point to the node,
* not the value.
*/
bool
Cstore::validate_val(const vtw_def *def, const string& value)
{
vtw_def ndef;
if (!def) {
if (!tmpl_parse(ndef)) {
exit_internal("failed to parse tmpl [%s]\n", tmpl_path_to_str().c_str());
}
def = &ndef;
if (def->def_type == ERROR_TYPE) {
// not a value node
exit_internal("validating non-value node [%s]\n",
tmpl_path_to_str().c_str());
}
}
// validate_value() may change "value". make a copy first.
size_t vlen = value.size();
char *vbuf = (char *) malloc(vlen + 1);
strncpy(vbuf, value.c_str(), vlen + 1);
vbuf[vlen] = 0;
bool ret = validate_val_impl((vtw_def *) def, vbuf);
free(vbuf);
return ret;
}
/* add tag at current work path.
* return true if successful. otherwise return false.
* note: assume current work path is a new tag and path from root to parent
* already exists.
*/
bool
Cstore::add_tag(const vtw_def& def)
{
string t = pop_cfg_path();
vector<string> cnodes;
// get child nodes, excluding deactivated ones.
get_all_child_node_names(cnodes, false, false);
bool ret = false;
do {
if (def.def_tag > 0 && def.def_tag <= cnodes.size()) {
// limit exceeded
output_user("Cannot set node \"%s\": number of values exceeds limit"
"(%d allowed)\n", t.c_str(), def.def_tag);
break;
}
/* XXX the following is the original logic, which is wrong since def_tag
* is unsigned.
*/
if (def.def_tag < 0 && cnodes.size() == 1) {
/* XXX special case in the original implementation where the previous
* tag should be replaced. this is probably unnecessary since
* "rename" can be used for tag node anyway.
*/
ret = rename_child_node(cnodes[0], t);
break;
}
// neither of the above. just add the tag.
ret = add_child_node(t);
} while (0);
push_cfg_path(t);
return ret;
}
/* add specified value to the multi-value node at current work path.
* return true if successful. otherwise return false.
* note: assume current work path is a multi-value node and specified value is
* not configured for the node.
*/
bool
Cstore::add_value_to_multi(const vtw_def& def, const string& value)
{
// get current values
vector<string> vvec;
// ignore return value here. if it failed, vvec is empty.
read_value_vec(vvec, false);
/* note: XXX the original limit-checking logic uses the same count as tag
* node, which is wrong since multi-node values are not stored as
* directories in the original implementation.
*
* also, original logic only applies limit when def_multi > 1.
* this was probably to support the special case in the design
* when def_multi is 1 to make it behave like a single-value
* node (i.e., a subsequent set replaces the value). however,
* the implementation uses "-1" as the special case (but def_multi
* is unsigned anyway). see also "add_tag()".
*
* for now just apply the limit for anything >= 1.
*/
if (def.def_multi >= 1 && vvec.size() >= def.def_multi) {
// limit exceeded
output_user("Cannot set value \"%s\": number of values exceeded "
"(%d allowed)\n", value.c_str(), def.def_multi);
return false;
}
// append the value
vvec.push_back(value);
return write_value_vec(vvec);
}
/* this uses the get_all_child_node_names_impl() from the underlying
* implementation but provides the option to exclude deactivated nodes.
*/
void
Cstore::get_all_child_node_names(vector<string>& cnodes, bool active_cfg,
bool include_deactivated)
{
vector<string> nodes;
get_all_child_node_names_impl(nodes, active_cfg);
for (size_t i = 0; i < nodes.size(); i++) {
if (!include_deactivated) {
push_cfg_path(nodes[i]);
bool skip = marked_deactivated(active_cfg);
pop_cfg_path();
if (skip) {
continue;
}
}
cnodes.push_back(nodes[i]);
}
}
/* create all child nodes of current work path that have default values
* return true if successful. otherwise return false.
* note: assume current work path has just been created so no child
* nodes exist.
*/
bool
Cstore::create_default_children()
{
vector<string> tcnodes;
get_all_tmpl_child_node_names(tcnodes);
bool ret = true;
for (size_t i = 0; i < tcnodes.size(); i++) {
push_tmpl_path(tcnodes[i]);
vtw_def def;
if (tmpl_node_exists() && tmpl_parse(def)) {
if (def.def_default) {
// has default value. set it.
push_cfg_path(tcnodes[i]);
if (!add_node() || !write_value(def.def_default)
|| !mark_display_default()) {
ret = false;
}
pop_cfg_path();
}
}
pop_tmpl_path();
if (!ret) {
break;
}
}
return ret;
}
/* return environment string for "edit"-related operations based on current
* work/tmpl paths.
*/
void
Cstore::get_edit_env(string& env)
{
vector<string> lvec;
get_edit_level(lvec);
string lvl;
for (size_t i = 0; i < lvec.size(); i++) {
if (lvl.length() > 0) {
lvl += " ";
}
lvl += lvec[i];
}
env = ("export " + C_ENV_EDIT_LEVEL + "='" + get_edit_level_path() + "';");
env += (" export " + C_ENV_TMPL_LEVEL + "='" + get_tmpl_level_path() + "';");
env += (" export " + C_ENV_SHELL_PROMPT + "='"
+ get_shell_prompt(lvl) + "';");
}
// return shell prompt string for specified edit level
string
Cstore::get_shell_prompt(const string& level)
{
string lvl = level;
if (lvl.length() > 0) {
lvl = " " + lvl;
}
return ("[edit" + lvl + "]\\n\\u@\\h# ");
}
// escape the single quotes in the string for shell
void
Cstore::shell_escape_squotes(string& str)
{
size_t sq = 0;
while ((sq = str.find('\'', sq)) != str.npos) {
str.replace(sq, 1, "'\\''");
sq += 4;
}
}