path: root/src/cnode/cnode-algorithm.cpp

/*
 * 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 <cstore/cstore.hpp>
#include <cnode/cnode.hpp>
#include <cnode/cnode-algorithm.hpp>

using namespace std;
using namespace cnode;


////// constants
static const string PFX_DIFF_ADD = "+"; // added
static const string PFX_DIFF_DEL = "-"; // deleted
static const string PFX_DIFF_UPD = ">"; // changed
static const string PFX_DIFF_NONE = " ";
static const string PFX_DIFF_NULL = "";

static const string PFX_DEACT_D = "!";  // deactivated
static const string PFX_DEACT_DP = "D"; // deactivate pending
static const string PFX_DEACT_AP = "A"; // activate pending
static const string PFX_DEACT_NONE = " ";


////// static (internal) functions
static void
_show_diff(CfgNode *cfg1, CfgNode *cfg2, int level, bool show_def,
           bool hide_secret);

static void
_print_value_str(const string& name, const char *vstr, bool hide_secret)
{
  // handle secret hiding first
  if (hide_secret) {
    static const char *sname[] = { "passphrase", "password",
                                   "pre-shared-secret", "key", NULL };
    static size_t slen[] = { 10, 8, 17, 3, 0 };
    size_t nlen = name.length();
    for (size_t i = 0; sname[i]; i++) {
      if (nlen < slen[i]) {
        // can't match
        continue;
      }
      if (name.find(sname[i], nlen - slen[i]) != name.npos) {
        // found secret
        printf("****************");
        return;
      }
    }
  }

  const char *quote = "";
  size_t vlen = strlen(vstr);
  if (*vstr == 0 || strcspn(vstr, "*}{;\011\012\013\014\015 ") < vlen) {
    quote = "\"";
  }
  printf("%s%s%s", quote, vstr, quote);
}

static void
_diff_print_indent(CfgNode *cfg1, CfgNode *cfg2, int level,
                   const char *pfx_diff)
{
  const char *pfx_deact = PFX_DEACT_NONE.c_str();
  if (cfg1 && cfg2) {
    if (cfg1->isDeactivated()) {
      if (cfg2->isDeactivated()) {
        pfx_deact = PFX_DEACT_D.c_str();
      } else {
        pfx_deact = PFX_DEACT_AP.c_str();
      }
    } else {
      if (cfg2->isDeactivated()) {
        pfx_deact = PFX_DEACT_DP.c_str();
      }
      // 4th case handled by default
    }
  }

  printf("%s %s", pfx_deact, pfx_diff);
  for (int i = 0; i < level; i++) {
    printf("    ");
  }
}

static void
_diff_print_comment(CfgNode *cfg1, CfgNode *cfg2, int level)
{
  const char *pfx_diff = PFX_DIFF_NONE.c_str();
  string comment = "";
  if (cfg1 != cfg2) {
    string c1 = (cfg1 ? cfg1->getComment() : "");
    string c2 = (cfg2 ? cfg2->getComment() : "");
    if (c1 != "") {
      if (c2 != "") {
        // in both
        comment = c2;
        if (c1 != c2) {
          pfx_diff = PFX_DIFF_UPD.c_str();
        }
      } else {
        // only in cfg1
        comment = c1;
        pfx_diff = PFX_DIFF_DEL.c_str();
      }
    } else {
      if (c2 != "") {
        // only in cfg2
        comment = c2;
        pfx_diff = PFX_DIFF_ADD.c_str();
      }
      // 4th case handled by default
    }
  } else {
    // same node => no diff
    pfx_diff = PFX_DIFF_NULL.c_str();
    comment = cfg1->getComment();
  }
  if (comment == "") {
    // no comment
    return;
  }
  _diff_print_indent(cfg1, cfg2, level, pfx_diff);
  printf("/* %s */\n", comment.c_str());
}

static bool
_diff_check_and_show_leaf(CfgNode *cfg1, CfgNode *cfg2, int level,
                          bool show_def, bool hide_secret)
{
  if ((cfg1 && !cfg1->isLeaf()) || (cfg2 && !cfg2->isLeaf())) {
    // not a leaf node
    return false;
  }

  CfgNode *cfg = NULL;
  const char *force_pfx_diff = NULL;
  if (!cfg1) {
    cfg = cfg2;
    force_pfx_diff = PFX_DIFF_ADD.c_str();
  } else {
    cfg = cfg1;
    if (!cfg2) {
      force_pfx_diff = PFX_DIFF_DEL.c_str();
    } else if (cfg1 == cfg2) {
      force_pfx_diff = PFX_DIFF_NULL.c_str();
    }
  }

  if (cfg->isMulti()) {
    // multi-value node
    _diff_print_comment(cfg1, cfg2, level);
    if (force_pfx_diff) {
      // simple case: just use the same diff prefix for all values
      const vector<string>& vvec = cfg->getValues();
      for (size_t i = 0; i < vvec.size(); i++) {
        _diff_print_indent(cfg1, cfg2, level, force_pfx_diff);
        printf("%s ", cfg->getName().c_str());
        _print_value_str(cfg->getName(), vvec[i].c_str(), hide_secret);
        printf("\n");
      }
    } else {
      // need to actually do a diff.
      // this follows the original perl logic.
      const vector<string>& ovec = cfg1->getValues();
      const vector<string>& nvec = cfg1->getValues();
      vector<string> values;
      vector<const char *> pfxs;
      Cstore::MapT<string, bool> nmap;
      for (size_t i = 0; i < nvec.size(); i++) {
        nmap[nvec[i]] = true;
      }
      Cstore::MapT<string, bool> omap;
      for (size_t i = 0; i < ovec.size(); i++) {
        omap[ovec[i]] = true;
        if (nmap.find(ovec[i]) == nmap.end()) {
          values.push_back(ovec[i]);
          pfxs.push_back(PFX_DIFF_DEL.c_str());
        }
      }

      for (size_t i = 0; i < nvec.size(); i++) {
        values.push_back(nvec[i]);
        if (omap.find(nvec[i]) == omap.end()) {
          pfxs.push_back(PFX_DIFF_ADD.c_str());
        } else if (i < ovec.size() && nvec[i] == ovec[i]) {
          pfxs.push_back(PFX_DIFF_NONE.c_str());
        } else {
          pfxs.push_back(PFX_DIFF_UPD.c_str());
        }
      }

      for (size_t i = 0; i < values.size(); i++) {
        _diff_print_indent(cfg1, cfg2, level, pfxs[i]);
        printf("%s ", cfg->getName().c_str());
        _print_value_str(cfg->getName(), values[i].c_str(), hide_secret);
        printf("\n");
      }
    }
  } else {
    // single-value node
    if (show_def || !cfg->isDefault()) {
      const string& val = cfg->getValue();
      if (!force_pfx_diff) {
        const string& val1 = cfg1->getValue();
        if (val == val1) {
          force_pfx_diff = PFX_DIFF_NONE.c_str();
        } else {
          force_pfx_diff = PFX_DIFF_UPD.c_str();
        }
      }
      _diff_print_indent(cfg1, cfg2, level, force_pfx_diff);
      printf("%s ", cfg->getName().c_str());
      _print_value_str(cfg->getName(), val.c_str(), hide_secret);
      printf("\n");
    }
  }

  return true;
}

static bool
_diff_check_and_show_tag(CfgNode *cfg1, CfgNode *cfg2, int level,
                         bool show_def, bool hide_secret)
{
  if ((cfg1 && !cfg1->isTag()) || (cfg2 && !cfg2->isTag())) {
    // not a tag node
    return false;
  }

  vector<CfgNode *> vals1, vals2;
  if (cfg1) {
    vals1 = cfg1->getTagValues();
  }
  if (cfg2) {
    vals2 = cfg2->getTagValues();
  }

  Cstore::MapT<string, bool> vmap;
  Cstore::MapT<string, CfgNode *> vnmap1, vnmap2;
  for (size_t i = 0; i < vals1.size(); i++) {
    vmap[vals1[i]->getValue()] = true;
    vnmap1[vals1[i]->getValue()] = vals1[i];
  }
  for (size_t i = 0; i < vals2.size(); i++) {
    vmap[vals2[i]->getValue()] = true;
    vnmap2[vals2[i]->getValue()] = vals2[i];
  }

  vector<string> values;
  Cstore::MapT<string, bool>::iterator it = vmap.begin();
  for (; it != vmap.end(); ++it) {
    values.push_back((*it).first);
  }
  Cstore::sortNodes(values);

  for (size_t i = 0; i < values.size(); i++) {
    bool in1 = (vnmap1.find(values[i]) != vnmap1.end());
    bool in2 = (vnmap2.find(values[i]) != vnmap2.end());
    CfgNode *c1 = (in1 ? vnmap1[values[i]] : NULL);
    CfgNode *c2 = (in2 ? vnmap2[values[i]] : NULL);
    /* note: if the root is a tag node (level == -1), then need to make
     *       level 0 when calling tag values' show().
     */
    _show_diff(c1, c2, ((level >= 0) ? level : 0), show_def, hide_secret);
  }
  return true;
}

static void 
_diff_show_other(CfgNode *cfg1, CfgNode *cfg2, int level, bool show_def,
                 bool hide_secret)
{
  CfgNode *cfg = NULL;
  const char *pfx_diff = PFX_DIFF_NONE.c_str();
  if (!cfg1) {
    cfg = cfg2;
    pfx_diff = PFX_DIFF_ADD.c_str();
  } else {
    cfg = cfg1;
    if (!cfg2) {
      pfx_diff = PFX_DIFF_DEL.c_str();
    } else if (cfg1 == cfg2) {
      pfx_diff = PFX_DIFF_NULL.c_str();
    }
  }

  const string& name = cfg->getName();
  bool print_this = (level >= 0 && name.size() > 0);
  if (print_this) {
    _diff_print_comment(cfg1, cfg2, level);
    _diff_print_indent(cfg1, cfg2, level, pfx_diff);
    if (cfg->isValue()) {
      // at tag value
      printf("%s %s", name.c_str(), cfg->getValue().c_str());
    } else {
      // at intermediate node
      printf("%s", name.c_str());
    }
    printf("%s\n", (cfg->isLeafTypeless() ? "" : " {"));
  }

  vector<CfgNode *> cnodes1, cnodes2;
  if (cfg1) {
    cnodes1 = cfg1->getChildNodes();
  }
  if (cfg2) {
    cnodes2 = cfg2->getChildNodes();
  }

  Cstore::MapT<string, bool> map;
  Cstore::MapT<string, CfgNode *> nmap1, nmap2;
  for (size_t i = 0; i < cnodes1.size(); i++) {
    map[cnodes1[i]->getName()] = true;
    nmap1[cnodes1[i]->getName()] = cnodes1[i];
  }
  for (size_t i = 0; i < cnodes2.size(); i++) {
    map[cnodes2[i]->getName()] = true;
    nmap2[cnodes2[i]->getName()] = cnodes2[i];
  }

  vector<string> cnodes;
  Cstore::MapT<string, bool>::iterator it = map.begin();
  for (; it != map.end(); ++it) {
    cnodes.push_back((*it).first);
  }
  Cstore::sortNodes(cnodes);

  for (size_t i = 0; i < cnodes.size(); i++) {
    bool in1 = (nmap1.find(cnodes[i]) != nmap1.end());
    bool in2 = (nmap2.find(cnodes[i]) != nmap2.end());
    CfgNode *c1 = (in1 ? nmap1[cnodes[i]] : NULL);
    CfgNode *c2 = (in2 ? nmap2[cnodes[i]] : NULL);
    _show_diff(c1, c2, level + 1, show_def, hide_secret);
  }

  if (print_this && !cfg->isLeafTypeless()) {
    _diff_print_indent(cfg1, cfg2, level, pfx_diff);
    printf("}\n");
  }
}

static void
_show_diff(CfgNode *cfg1, CfgNode *cfg2, int level, bool show_def,
           bool hide_secret)
{
  /* cfg1 and cfg2 point to the same config node in two configs. a "diff"
   * output is shown comparing the two configs recursively with this node
   * as the root of the config tree.
   *
   * there are four possible scenarios:
   *   (1) (cfg1 && cfg2) && (cfg1 != cfg2): node exists in both config.
   *   (2) (cfg1 && cfg2) && (cfg1 == cfg2): the two point to the same config.
   *       this will be just a "show".
   *   (3) (!cfg1 && cfg2): node exists in cfg2 but not in cfg1 (added).
   *   (4) (cfg1 && !cfg2): node exists in cfg1 but not in cfg1 (deleted).
   *
   * calling this with both NULL is invalid.
   */
  if (!cfg1 && !cfg2) {
    fprintf(stderr, "_show_diff error (both config NULL)\n");
    exit(1);
  }

  if (_diff_check_and_show_leaf(cfg1, cfg2, level, show_def, hide_secret)) {
    // leaf node has been shown. done.
    return;
  } else if (_diff_check_and_show_tag(cfg1, cfg2, level, show_def,
                                      hide_secret)) {
    // tag node has been shown. done.
    return;
  } else {
    // intermediate node or tag value
    _diff_show_other(cfg1, cfg2, level, show_def, hide_secret);
  }
}


////// algorithms
void
cnode::show_diff(const CfgNode& cfg1, const CfgNode& cfg2, bool show_def,
                 bool hide_secret)
{
  if (cfg1.isInvalid() || cfg2.isInvalid()) {
    printf("Specified configuration path is not valid\n");
    return;
  }
  if (cfg1.isEmpty() && cfg2.isEmpty()) {
    printf("Configuration under specified path is empty\n");
    return;
  }
  _show_diff(const_cast<CfgNode *>(&cfg1), const_cast<CfgNode *>(&cfg2), -1,
             show_def, hide_secret);
}