add new cstore library

1 files changed, 1078 insertions, 0 deletions

diff --git a/src/cstore/unionfs/cstore-unionfs.cpp b/src/cstore/unionfs/cstore-unionfs.cpp
new file mode 100644
index 0000000..977a597
--- /dev/null
+++ b/src/cstore/unionfs/cstore-unionfs.cpp
@@ -0,0 +1,1078 @@
+/*
+ * 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 <map>
+#include <fstream>
+#include <sstream>
+
+#include <errno.h>
+#include <sys/mount.h>
+
+extern "C" {
+#include "cli_val.h"
+#include "cli_objects.h"
+}
+
+#include "cstore-unionfs.hpp"
+
+
+////// constants
+// environment vars defining root dirs
+const string UnionfsCstore::C_ENV_TMPL_ROOT = "VYATTA_CONFIG_TEMPLATE";
+const string UnionfsCstore::C_ENV_WORK_ROOT = "VYATTA_TEMP_CONFIG_DIR";
+const string UnionfsCstore::C_ENV_ACTIVE_ROOT
+  = "VYATTA_ACTIVE_CONFIGURATION_DIR";
+const string UnionfsCstore::C_ENV_CHANGE_ROOT = "VYATTA_CHANGES_ONLY_DIR";
+const string UnionfsCstore::C_ENV_TMP_ROOT = "VYATTA_CONFIG_TMP";
+
+// default root dirs/paths
+const string UnionfsCstore::C_DEF_TMPL_ROOT
+  = "/opt/vyatta/share/vyatta-cfg/templates";
+const string UnionfsCstore::C_DEF_CFG_ROOT
+  = "/opt/vyatta/config";
+const string UnionfsCstore::C_DEF_ACTIVE_ROOT
+  = UnionfsCstore::C_DEF_CFG_ROOT + "/active";
+const string UnionfsCstore::C_DEF_CHANGE_PREFIX = "/tmp/changes_only_";
+const string UnionfsCstore::C_DEF_WORK_PREFIX
+  = UnionfsCstore::C_DEF_CFG_ROOT + "/tmp/new_config_";
+const string UnionfsCstore::C_DEF_TMP_PREFIX
+  = UnionfsCstore::C_DEF_CFG_ROOT + "/tmp/tmp_";
+
+// markers
+const string UnionfsCstore::C_MARKER_DEF_VALUE  = "def";
+const string UnionfsCstore::C_MARKER_DEACTIVATE = ".disable";
+const string UnionfsCstore::C_MARKER_CHANGED = ".modified";
+const string UnionfsCstore::C_MARKER_UNSAVED = ".unsaved";
+const string UnionfsCstore::C_COMMITTED_MARKER_FILE = "/tmp/.changes";
+const string UnionfsCstore::C_COMMENT_FILE = ".comment";
+
+
+////// static
+static map<char, string> _fs_escape_chars;
+static map<string, char> _fs_unescape_chars;
+static void
+_init_fs_escape_chars()
+{
+  _fs_escape_chars[-1] = "\%\%\%";
+  _fs_escape_chars['%'] = "\%25";
+  _fs_escape_chars['/'] = "\%2F";
+
+  _fs_unescape_chars["\%\%\%"] = -1;
+  _fs_unescape_chars["\%25"] = '%';
+  _fs_unescape_chars["\%2F"] = '/';
+}
+
+static string
+_escape_char(char c)
+{
+  map<char, string>::iterator p = _fs_escape_chars.find(c);
+  if (p != _fs_escape_chars.end()) {
+    return _fs_escape_chars[c];
+  } else {
+    return string(1, c);
+  }
+}
+
+static map<string, string> _escape_path_name_cache;
+
+static string
+_escape_path_name(const string& path)
+{
+  map<string, string>::iterator p = _escape_path_name_cache.find(path);
+  if (p != _escape_path_name_cache.end()) {
+    // found escaped string in cache. just return it.
+    return _escape_path_name_cache[path];
+  }
+
+  // special case for empty string
+  string npath = (path.size() == 0) ? _fs_escape_chars[-1] : "";
+  for (unsigned int i = 0; i < path.size(); i++) {
+    npath += _escape_char(path[i]);
+  }
+
+  // cache it before return
+  _escape_path_name_cache[path] = npath;
+  return npath;
+}
+
+static map<string, string> _unescape_path_name_cache;
+
+static string
+_unescape_path_name(const string& path)
+{
+  map<string, string>::iterator p = _unescape_path_name_cache.find(path);
+  if (p != _unescape_path_name_cache.end()) {
+    // found unescaped string in cache. just return it.
+    return _unescape_path_name_cache[path];
+  }
+
+  // assume all escape patterns are 3-char
+  string npath = "";
+  for (unsigned int i = 0; i < path.size(); i++) {
+    if ((path.size() - i) < 3) {
+      npath += path.substr(i);
+      break;
+    }
+    string s = path.substr(i, 3);
+    map<string, char>::iterator p = _fs_unescape_chars.find(s);
+    if (p != _fs_unescape_chars.end()) {
+      char c = _fs_unescape_chars[s];
+      if (path.size() == 3 && c == -1) {
+        // special case for empty string
+        npath = "";
+        break;
+      }
+      npath += string(1, _fs_unescape_chars[s]);
+      // skip the escape sequence
+      i += 2;
+    } else {
+      npath += path.substr(i, 1);
+    }
+  }
+  // cache it before return
+  _unescape_path_name_cache[path] = npath;
+  return npath;
+}
+
+
+////// constructor/destructor
+/* "current session" constructor.
+ * this constructor sets up the object from environment.
+ * used when environment is already set up, i.e., when operating on the
+ * "current" config session. e.g., in the following scenarios
+ *   configure commands
+ *   perl module
+ *   shell "current session" api
+ *
+ * note: this also applies when using the cstore in operational mode,
+ *       in which case only the template root and the active root will be
+ *       valid.
+ */
+UnionfsCstore::UnionfsCstore(bool use_edit_level)
+{
+  // set up root dir strings
+  char *val;
+  if ((val = getenv(C_ENV_TMPL_ROOT.c_str()))) {
+    tmpl_path = val;
+  } else {
+    tmpl_path = C_DEF_TMPL_ROOT;
+  }
+  tmpl_root = tmpl_path; // save a copy of tmpl root
+  if ((val = getenv(C_ENV_WORK_ROOT.c_str()))) {
+    work_root = val;
+  }
+  if ((val = getenv(C_ENV_TMP_ROOT.c_str()))) {
+    tmp_root = val;
+  }
+  if ((val = getenv(C_ENV_ACTIVE_ROOT.c_str()))) {
+    active_root = val;
+  } else {
+    active_root = C_DEF_ACTIVE_ROOT;
+  }
+  if ((val = getenv(C_ENV_CHANGE_ROOT.c_str()))) {
+    change_root = val;
+  }
+
+  /* note: the original perl API module does not use the edit levels
+   *       from environment. only the actual CLI operations use them.
+   *       so here make it an option.
+   */
+  if (use_edit_level) {
+    // set up path strings
+    if ((val = getenv(C_ENV_EDIT_LEVEL.c_str()))) {
+      mutable_cfg_path = val;
+    }
+    if ((val = getenv(C_ENV_TMPL_LEVEL.c_str()))) {
+      tmpl_path /= val;
+    }
+  }
+  _init_fs_escape_chars();
+}
+
+/* "specific session" constructor.
+ * this constructor sets up the object for the specified session ID and
+ * returns an environment string that can be "evaled" to set up the
+ * shell environment.
+ *
+ * used when the session environment needs to be established. this is
+ * mainly for the shell functions that set up configuration sessions.
+ * i.e., the "vyatta-cfg-cmd-wrapper" (on boot or for GUI etc.) and
+ * the cfg completion script (when entering configure mode).
+ *
+ *   sid: session ID.
+ *   env: (output) environment string.
+ *
+ * note: this does NOT set up the session. caller needs to use the
+ *       explicit session setup/teardown functions as needed.
+ */
+UnionfsCstore::UnionfsCstore(const string& sid, string& env)
+  : Cstore(env)
+{
+  tmpl_root = C_DEF_TMPL_ROOT;
+  tmpl_path = tmpl_root;
+  active_root = C_DEF_ACTIVE_ROOT;
+  work_root = (C_DEF_WORK_PREFIX + sid);
+  change_root = (C_DEF_CHANGE_PREFIX + sid);
+  tmp_root = (C_DEF_TMP_PREFIX + sid);
+
+  string declr = " declare -x -r "; // readonly vars
+  env += " umask 002; {";
+  env += (declr + C_ENV_ACTIVE_ROOT + "=" + active_root.file_string());
+  env += (declr + C_ENV_CHANGE_ROOT + "=" + change_root.file_string() + ";");
+  env += (declr + C_ENV_WORK_ROOT + "=" + work_root.file_string() + ";");
+  env += (declr + C_ENV_TMP_ROOT + "=" + tmp_root.file_string() + ";");
+  env += (declr + C_ENV_TMPL_ROOT + "=" + tmpl_root.file_string() + ";");
+  env += " } >&/dev/null || true";
+
+  // set up path strings using level vars
+  char *val;
+  if ((val = getenv(C_ENV_EDIT_LEVEL.c_str()))) {
+    mutable_cfg_path = val;
+  }
+  if ((val = getenv(C_ENV_TMPL_LEVEL.c_str()))) {
+    tmpl_path /= val;
+  }
+
+  _init_fs_escape_chars();
+}
+
+UnionfsCstore::~UnionfsCstore()
+{
+}
+
+
+////// public virtual functions declared in base class
+bool
+UnionfsCstore::markSessionUnsaved()
+{
+  b_fs::path marker = work_root / C_MARKER_UNSAVED;
+  if (b_fs::exists(marker)) {
+    // already marked. treat as success.
+    return true;
+  }
+  if (!create_file(marker.file_string())) {
+    output_internal("failed to mark unsaved [%s]\n",
+                    marker.file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+bool
+UnionfsCstore::unmarkSessionUnsaved()
+{
+  b_fs::path marker = work_root / C_MARKER_UNSAVED;
+  if (!b_fs::exists(marker)) {
+    // not marked. treat as success.
+    return true;
+  }
+  try {
+    b_fs::remove(marker);
+  } catch (...) {
+    output_internal("failed to unmark unsaved [%s]\n",
+                    marker.file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+bool
+UnionfsCstore::sessionUnsaved()
+{
+  b_fs::path marker = work_root / C_MARKER_UNSAVED;
+  return b_fs::exists(marker);
+}
+
+bool
+UnionfsCstore::sessionChanged()
+{
+  b_fs::path marker = work_root / C_MARKER_CHANGED;
+  return b_fs::exists(marker);
+}
+
+/* set up the session associated with this object.
+ * the session comes from either the environment or the session ID
+ * (see the two different constructors).
+ */
+bool
+UnionfsCstore::setupSession()
+{
+  if (!b_fs::exists(work_root)) {
+    // session doesn't exist. create dirs.
+    try {
+      b_fs::create_directories(work_root);
+      b_fs::create_directories(change_root);
+      b_fs::create_directories(tmp_root);
+      if (!b_fs::exists(active_root)) {
+        // this should only be needed on boot
+        b_fs::create_directories(active_root);
+      }
+    } catch (...) {
+      output_internal("setup session failed to create session directories\n");
+      return false;
+    }
+
+    // union mount
+    string mopts = ("dirs=" + change_root.file_string() + "=rw:"
+                    + active_root.file_string() + "=ro");
+    if (mount("unionfs", work_root.file_string().c_str(), "unionfs", 0,
+              mopts.c_str()) != 0) {
+      output_internal("setup session mount failed [%s][%s]\n",
+                      strerror(errno), work_root.file_string().c_str());
+      return false;
+    }
+  } else if (!b_fs::is_directory(work_root)) {
+    output_internal("setup session not dir [%s]\n",
+                    work_root.file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+/* tear down the session associated with this object.
+ * the session comes from either the environment or the session ID
+ * (see the two different constructors).
+ */
+bool
+UnionfsCstore::teardownSession()
+{
+  // check if session exists
+  string wstr = work_root.file_string();
+  if (wstr.empty() || wstr.find(C_DEF_WORK_PREFIX) != 0
+      || !b_fs::exists(work_root) || !b_fs::is_directory(work_root)) {
+    // no session
+    output_internal("teardown invalid session [%s]\n", wstr.c_str());
+    return false;
+  }
+
+  // unmount the work root (union)
+  if (umount(wstr.c_str()) != 0) {
+    output_internal("teardown session umount failed [%s][%s]\n",
+                    strerror(errno), wstr.c_str());
+    return false;
+  }
+
+  // remove session directories
+  bool ret = false;
+  try {
+    if (b_fs::remove_all(work_root) != 0
+        && b_fs::remove_all(change_root) != 0
+        && b_fs::remove_all(tmp_root) != 0) {
+      ret = true;
+    }
+  } catch (...) {
+  }
+  if (!ret) {
+    output_internal("failed to remove session directories\n");
+  }
+  return ret;
+}
+
+/* whether an actual config session is associated with this object.
+ * the session comes from either the environment or the session ID
+ * (see the two different constructors).
+ */
+bool
+UnionfsCstore::inSession()
+{
+  string wstr = work_root.file_string();
+  return (!wstr.empty() && wstr.find(C_DEF_WORK_PREFIX) == 0
+          && b_fs::exists(work_root) && b_fs::is_directory(work_root));
+}
+
+
+////// virtual functions defined in base class
+/* check if current tmpl_path is a valid tmpl dir.
+ * return true if valid. otherwise return false.
+ */
+bool
+UnionfsCstore::tmpl_node_exists()
+{
+  return (b_fs::exists(tmpl_path) && b_fs::is_directory(tmpl_path));
+}
+
+/* parse template at current tmpl_path.
+ *   def: for storing parsed template.
+ * return true if successful. otherwise return false.
+ */
+bool
+UnionfsCstore::tmpl_parse(vtw_def& def)
+{
+  push_tmpl_path(DEF_NAME);
+  bool ret = (b_fs::exists(tmpl_path) && b_fs::is_regular(tmpl_path)
+              && parse_def(&def, tmpl_path.file_string().c_str(), FALSE) == 0);
+  pop_tmpl_path();
+  return ret;
+}
+
+bool
+UnionfsCstore::cfg_node_exists(bool active_cfg)
+{
+  b_fs::path p = (active_cfg ? get_active_path() : get_work_path());
+  return (b_fs::exists(p) && b_fs::is_directory(p));
+}
+
+bool
+UnionfsCstore::add_node()
+{
+  bool ret = true;
+  try {
+    if (!b_fs::create_directory(get_work_path())) {
+      // already exists. shouldn't call this function.
+      ret = false;
+    }
+  } catch (...) {
+    ret = false;
+  }
+  if (!ret) {
+    output_internal("failed to add node [%s]\n",
+                    get_work_path().file_string().c_str());
+  }
+  return ret;
+}
+
+bool
+UnionfsCstore::remove_node()
+{
+  if (!b_fs::exists(get_work_path()) || !b_fs::is_directory(get_work_path())) {
+    output_internal("remove non-existent node [%s]\n",
+                    get_work_path().file_string().c_str());
+    return false;
+  }
+  bool ret = false;
+  try {
+    if (b_fs::remove_all(get_work_path()) != 0) {
+      ret = true;
+    }
+  } catch (...) {
+    ret = false;
+  }
+  if (!ret) {
+    output_internal("failed to remove node [%s]\n",
+                    get_work_path().file_string().c_str());
+  }
+  return ret;
+}
+
+void
+UnionfsCstore::get_all_child_node_names_impl(vector<string>& cnodes,
+                                             bool active_cfg)
+{
+  b_fs::path p = (active_cfg ? get_active_path() : get_work_path());
+  get_all_child_dir_names(p, cnodes);
+
+  /* XXX special cases to emulate original perl API behavior.
+   *     original perl listNodes() and listOrigNodes() return everything
+   *     under a node (except for ".*"), including "node.val" and "def".
+   *
+   *     perl API should operate at abstract level and should not access
+   *     such implementation-specific details. however, currently
+   *     things like config output depend on this behavior, so this
+   *     function needs to return them for now.
+   *
+   *     use a whilelist-approach, i.e., only add the following:
+   *       node.val
+   *       def
+   */
+  if (b_fs::exists(p / VAL_NAME) && b_fs::is_regular(p / VAL_NAME)) {
+    cnodes.push_back(VAL_NAME);
+  }
+  if (b_fs::exists(p / C_MARKER_DEF_VALUE)
+      && b_fs::is_regular(p / C_MARKER_DEF_VALUE)) {
+    cnodes.push_back(C_MARKER_DEF_VALUE);
+  }
+}
+
+bool
+UnionfsCstore::read_value_vec(vector<string>& vvec, bool active_cfg)
+{
+  push_cfg_path_val();
+  b_fs::path vpath = (active_cfg ? get_active_path() : get_work_path());
+  bool ret = false;
+  do {
+    string ostr;
+    if (!read_whole_file(vpath, ostr)) {
+      break;
+    }
+
+    /* XXX original implementation used to remove a trailing '\n' after
+     *     a read. it was only necessary because it was adding a '\n' when
+     *     writing the file. don't remove anything now since we shouldn't
+     *     be writing it any more.
+     */
+    // separate values using newline as delimiter
+    unsigned int start_idx = 0, idx = 0;
+    for (; idx < ostr.size(); idx++) {
+      if (ostr[idx] == '\n') {
+        // got a value
+        vvec.push_back(ostr.substr(start_idx, (idx - start_idx)));
+        start_idx = idx + 1;
+      }
+    }
+    if (start_idx < ostr.size()) {
+      vvec.push_back(ostr.substr(start_idx, (idx - start_idx)));
+    } else {
+      // last char is a newline => another empty value
+      vvec.push_back("");
+    }
+    ret = true;
+  } while (0);
+  pop_cfg_path();
+  return ret;
+}
+
+bool
+UnionfsCstore::write_value_vec(const vector<string>& vvec, bool active_cfg)
+{
+  push_cfg_path_val();
+  bool ret = false;
+  b_fs::path wp = (active_cfg ? get_active_path() : get_work_path());
+  do {
+    if (b_fs::exists(wp) && !b_fs::is_regular(wp)) {
+      // not a file
+      break;
+    }
+
+    string ostr = "";
+    for (unsigned int i = 0; i < vvec.size(); i++) {
+      if (i > 0) {
+        // subsequent values require delimiter
+        ostr += "\n";
+      }
+      ostr += vvec[i];
+    }
+
+    if (!write_file(wp.file_string().c_str(), ostr)) {
+      break;
+    }
+    ret = true;
+  } while (0);
+  pop_cfg_path();
+  if (!ret) {
+    output_internal("failed to write node value [%s]\n",
+                    wp.file_string().c_str());
+  }
+  return ret;
+}
+
+bool
+UnionfsCstore::rename_child_node(const string& oname, const string& nname)
+{
+  b_fs::path opath = get_work_path() / oname;
+  b_fs::path npath = get_work_path() / nname;
+  if (!b_fs::exists(opath) || !b_fs::is_directory(opath)
+      || b_fs::exists(npath)) {
+    output_internal("cannot rename node [%s,%s,%s]\n",
+                    get_work_path().file_string().c_str(),
+                    oname.c_str(), nname.c_str());
+    return false;
+  }
+  bool ret = true;
+  try {
+    /* somehow b_fs::rename() can't be used here as it considers the operation
+     * "Invalid cross-device link" and fails with an exception, probably due
+     * to unionfs in some way.
+     * do it the hard way.
+     */
+    recursive_copy_dir(opath, npath);
+    if (b_fs::remove_all(opath) == 0) {
+      ret = false;
+    }
+  } catch (...) {
+    ret = false;
+  }
+  if (!ret) {
+    output_internal("failed to rename node [%s,%s]\n",
+                    opath.file_string().c_str(),
+                    npath.file_string().c_str());
+  }
+  return ret;
+}
+
+bool
+UnionfsCstore::copy_child_node(const string& oname, const string& nname)
+{
+  b_fs::path opath = get_work_path() / oname;
+  b_fs::path npath = get_work_path() / nname;
+  if (!b_fs::exists(opath) || !b_fs::is_directory(opath)
+      || b_fs::exists(npath)) {
+    output_internal("cannot copy node [%s,%s,%s]\n",
+                    get_work_path().file_string().c_str(),
+                    oname.c_str(), nname.c_str());
+    return false;
+  }
+  try {
+    recursive_copy_dir(opath, npath);
+  } catch (...) {
+    output_internal("failed to copy node [%s,%s,%s]\n",
+                    get_work_path().file_string().c_str(),
+                    oname.c_str(), nname.c_str());
+    return false;
+  }
+  return true;
+}
+
+bool
+UnionfsCstore::mark_display_default()
+{
+  b_fs::path marker = get_work_path() / C_MARKER_DEF_VALUE;
+  if (b_fs::exists(marker)) {
+    // already marked. treat as success.
+    return true;
+  }
+  if (!create_file(marker.file_string())) {
+    output_internal("failed to mark default [%s]\n",
+                    get_work_path().file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+bool
+UnionfsCstore::unmark_display_default()
+{
+  b_fs::path marker = get_work_path() / C_MARKER_DEF_VALUE;
+  if (!b_fs::exists(marker)) {
+    // not marked. treat as success.
+    return true;
+  }
+  try {
+    b_fs::remove(marker);
+  } catch (...) {
+    output_internal("failed to unmark default [%s]\n",
+                    get_work_path().file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+bool
+UnionfsCstore::marked_display_default()
+{
+  b_fs::path marker = get_work_path() / C_MARKER_DEF_VALUE;
+  return b_fs::exists(marker);
+}
+
+bool
+UnionfsCstore::marked_deactivated(bool active_cfg)
+{
+  b_fs::path p = (active_cfg ? get_active_path() : get_work_path());
+  b_fs::path marker = p / C_MARKER_DEACTIVATE;
+  return b_fs::exists(marker);
+}
+
+bool
+UnionfsCstore::mark_deactivated()
+{
+  b_fs::path marker = get_work_path() / C_MARKER_DEACTIVATE;
+  if (b_fs::exists(marker)) {
+    // already marked. treat as success.
+    return true;
+  }
+  if (!create_file(marker.file_string())) {
+    output_internal("failed to mark deactivated [%s]\n",
+                    get_work_path().file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+bool
+UnionfsCstore::unmark_deactivated()
+{
+  b_fs::path marker = get_work_path() / C_MARKER_DEACTIVATE;
+  if (!b_fs::exists(marker)) {
+    // not deactivated. treat as success.
+    return true;
+  }
+  try {
+    b_fs::remove(marker);
+  } catch (...) {
+    output_internal("failed to unmark deactivated [%s]\n",
+                    get_work_path().file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+bool
+UnionfsCstore::unmark_deactivated_descendants()
+{
+  bool ret = false;
+  do {
+    // sanity check
+    if (!b_fs::is_directory(get_work_path())) {
+      break;
+    }
+
+    vector<b_fs::path> markers;
+    b_fs::recursive_directory_iterator di(get_work_path());
+    for (; di != b_fs::recursive_directory_iterator(); ++di) {
+      if (!b_fs::is_regular(di->path())
+          || di->path().filename() != C_MARKER_DEACTIVATE) {
+        // not marker
+        continue;
+      }
+      if (di->path().parent_path() == get_work_path()) {
+        // don't unmark the node itself
+        continue;
+      }
+      markers.push_back(di->path());
+    }
+    try {
+      for (unsigned int i = 0; i < markers.size(); i++) {
+        b_fs::remove(markers[i]);
+      }
+    } catch (...) {
+      break;
+    }
+    ret = true;
+  } while (0);
+  if (!ret) {
+    output_internal("failed to unmark deactivated descendants [%s]\n",
+                    get_work_path().file_string().c_str());
+  }
+  return ret;
+}
+
+bool
+UnionfsCstore::mark_changed()
+{
+  if (!mutable_cfg_path.has_parent_path()) {
+    /* at root, mark changed. root marker is needed by the original
+     * implementation as an indication of whether the whole config
+     * has changed.
+     */
+    b_fs::path marker = get_work_path() / C_MARKER_CHANGED;
+    if (b_fs::exists(marker)) {
+      // already marked. treat as success.
+      return true;
+    }
+    if (!create_file(marker.file_string())) {
+      output_internal("failed to mark changed [%s]\n",
+                      get_work_path().file_string().c_str());
+      return false;
+    }
+    return true;
+  }
+
+  /* XXX not at root => nop for now.
+   *     we should be marking changed here. however, as commit is still
+   *     using its own unionfs implementation, it will not understand the
+   *     markers and therefore will not perform the necessary cleanup when
+   *     it's done.
+   *
+   *     for now, don't mark anything besides root. the query function
+   *     will use unionfs-specific implementation (changes-only dir).
+   */
+  return true;
+}
+
+// remove the comment at the current work path
+bool
+UnionfsCstore::remove_comment()
+{
+  b_fs::path cfile = get_work_path() / C_COMMENT_FILE;
+  if (!b_fs::exists(cfile)) {
+    return false;
+  }
+  try {
+    b_fs::remove(cfile);
+  } catch (...) {
+    output_internal("failed to remove comment [%s]\n",
+                    cfile.file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+// set comment at the current work path
+bool
+UnionfsCstore::set_comment(const string& comment)
+{
+  b_fs::path cfile = get_work_path() / C_COMMENT_FILE;
+  return write_file(cfile.file_string(), comment);
+}
+
+// discard all changes in working config
+bool
+UnionfsCstore::discard_changes(unsigned long long& num_removed)
+{
+  // unionfs-specific implementation
+  vector<b_fs::path> files;
+  vector<b_fs::path> directories;
+  // iterate through all entries in change root
+  b_fs::directory_iterator di(change_root);
+  for (; di != b_fs::directory_iterator(); ++di) {
+    if (b_fs::is_directory(di->path())) {
+      directories.push_back(di->path());
+    } else {
+      files.push_back(di->path());
+    }
+  }
+
+  // remove and count
+  try {
+    num_removed = 0;
+    for (unsigned int i = 0; i < files.size(); i++) {
+      b_fs::remove(files[i]);
+      num_removed++;
+    }
+    for (unsigned int i = 0; i < directories.size(); i++) {
+      num_removed += b_fs::remove_all(directories[i]);
+    }
+  } catch (...) {
+    output_internal("discard failed [%s]\n",
+                    change_root.file_string().c_str());
+    return false;
+  }
+  return true;
+}
+
+// get comment at the current work or active path
+bool
+UnionfsCstore::get_comment(string& comment, bool active_cfg)
+{
+  b_fs::path cfile = (active_cfg ? get_active_path() : get_work_path());
+  cfile /= C_COMMENT_FILE;
+  return read_whole_file(cfile, comment);
+}
+
+bool
+UnionfsCstore::marked_changed()
+{
+  /* this function is only called by cfgPathChanged() in base class.
+   *
+   * XXX currently just use the changes_only dir for this query.
+   *     see explanation in mark_changed().
+   *
+   *     this implementation relies on the fact that cfgPathChanged()
+   *     includes deleted/added nodes (including deactivated/activated
+   *     nodes since it's NOT deactivate-aware). if that is not the case,
+   *     result will be different between deleted nodes (NOT IN
+   *     changes_only) and deactivated nodes (IN changes_only).
+   */
+  return b_fs::exists(get_change_path());
+}
+
+/* XXX currently "committed marking" is done inside commit.
+ *     TODO move "committed marking" out of commit and into low-level
+ *     implementation (here).
+ */
+/* return whether current "cfg path" has been committed, i.e., whether
+ * the set or delete operation on the path has been processed by commit.
+ *   is_set: whether the operation is set (for sanity check as there can
+ *           be only one operation on the path).
+ */
+bool
+UnionfsCstore::marked_committed(const vtw_def& def, bool is_set)
+{
+  b_fs::path cpath = mutable_cfg_path;
+  string com_str = cpath.file_string() + "/";
+  if (def.is_value && !def.tag) {
+    // path includes leaf value. construct the right string.
+    string val = _unescape_path_name(cpath.filename());
+    cpath = cpath.parent_path();
+    /* XXX current commit implementation escapes value strings for
+     *     single-value nodes but not for multi-value nodes for some
+     *     reason. the following match current behavior.
+     */
+    if (!def.multi) {
+      val = _escape_path_name(val);
+    }
+    com_str = cpath.file_string() + "/value:" + val;
+  }
+  com_str = (is_set ? "+ " : "- ") + com_str;
+  return committed_marker_exists(com_str);
+}
+
+bool
+UnionfsCstore::validate_val_impl(vtw_def *def, char *value)
+{
+  /* XXX filesystem paths/accesses are completely embedded in var ref lib.
+   *     for now, treat the lib as a unionfs-specific implementation.
+   *     generalizing it will need a rewrite.
+   * set the handle to be used during validate_value() for var ref
+   * processing. this is a global var in cli_new.c.
+   */
+  var_ref_handle = (void *) this;
+  bool ret = validate_value(def, value);
+  var_ref_handle = NULL;
+  return ret;
+}
+
+void
+UnionfsCstore::get_edit_level(vector<string>& pcomps) {
+  b_fs::path opath = mutable_cfg_path; // use a copy
+  while (opath.has_parent_path()) {
+    pcomps.insert(pcomps.begin(), pop_path(opath));
+  }
+}
+
+string
+UnionfsCstore::cfg_path_to_str() {
+  string cpath = mutable_cfg_path.file_string();
+  if (cpath.length() == 0) {
+    cpath = "/";
+  }
+  return cpath;
+}
+
+string
+UnionfsCstore::tmpl_path_to_str() {
+  // return only the mutable part
+  string tpath = tmpl_path.file_string();
+  tpath.erase(0, tmpl_root.file_string().length());
+  if (tpath.length() == 0) {
+    tpath = "/";
+  }
+  return tpath;
+}
+
+
+////// private functions
+void
+UnionfsCstore::push_path(b_fs::path& old_path, const string& new_comp)
+{
+  string comp = _escape_path_name(new_comp);
+  old_path /= comp;
+}
+
+string
+UnionfsCstore::pop_path(b_fs::path& path)
+{
+  string ret = _unescape_path_name(path.filename());
+  /* note: contrary to documentation, remove_filename() does not remove
+   *       trailing slash.
+   */
+  path = path.parent_path();
+  return ret;
+}
+
+void
+UnionfsCstore::get_all_child_dir_names(b_fs::path root, vector<string>& nodes)
+{
+  if (!b_fs::exists(root) || !b_fs::is_directory(root)) {
+    // not a valid root. nop.
+    return;
+  }
+  b_fs::directory_iterator di(root);
+  for (; di != b_fs::directory_iterator(); ++di) {
+    // must be directory
+    if (!b_fs::is_directory(di->path())) {
+      continue;
+    }
+    // name cannot start with "."
+    if (di->path().file_string().substr(0, 1) == ".") {
+      continue;
+    }
+    // found one
+    nodes.push_back(_unescape_path_name(di->path().filename()));
+  }
+}
+
+bool
+UnionfsCstore::write_file(const string& file, const string& data)
+{
+  try {
+    // make sure the path exists
+    b_fs::path fpath(file);
+    b_fs::create_directories(fpath.parent_path());
+
+    // write the file
+    ofstream fout;
+    fout.exceptions(ofstream::failbit | ofstream::badbit);
+    fout.open(file.c_str(), ios_base::out | ios_base::trunc);
+    fout << data;
+    fout.close();
+  } catch (...) {
+    return false;
+  }
+  return true;
+}
+
+bool
+UnionfsCstore::read_whole_file(const b_fs::path& fpath, string& data)
+{
+  /* must exist, be a regular file, and smaller than limit (we're going
+   * to read the whole thing).
+   */
+  if (!b_fs::exists(fpath) || !b_fs::is_regular(fpath)
+      || b_fs::file_size(fpath) > MAX_FILE_READ_SIZE) {
+    return false;
+  }
+  stringbuf sbuf;
+  ifstream fin(fpath.file_string().c_str());
+  fin >> &sbuf;
+  fin.close();
+  /* note: if file contains just a newline => (eof() && fail())
+   *       so only checking bad() and eof() (we want whole file).
+   */
+  if (fin.bad() || !fin.eof()) {
+    // read failed
+    return false;
+  }
+  data = sbuf.str();
+  return true;
+}
+
+/* return whether specified "commited marker" exists in the
+ * "committed marker file".
+ */
+bool
+UnionfsCstore::committed_marker_exists(const string& marker)
+{
+  bool ret = false;
+  ifstream fin(C_COMMITTED_MARKER_FILE.c_str());
+  while (!fin.eof() && !fin.bad() && !fin.fail()) {
+    string line;
+    getline(fin, line);
+    if (line == marker) {
+      ret = true;
+      break;
+    }
+  }
+  fin.close();
+  return ret;
+}
+
+/* recursively copy source directory to destination.
+ * will throw exception (from b_fs) if fail.
+ */
+void
+UnionfsCstore::recursive_copy_dir(const b_fs::path& src, const b_fs::path& dst)
+{
+  string src_str = src.file_string();
+  string dst_str = dst.file_string();
+  b_fs::create_directory(dst);
+
+  b_fs::recursive_directory_iterator di(src);
+  for (; di != b_fs::recursive_directory_iterator(); ++di) {
+    b_fs::path opath = di->path();
+    string nname = opath.file_string();
+    nname.replace(0, src_str.length(), dst_str);
+    b_fs::path npath = nname;
+    if (b_fs::is_directory(opath)) {
+      b_fs::create_directory(npath);
+    } else {
+      b_fs::copy_file(opath, npath);
+    }
+  }
+}
+