summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/commit2.c755
-rw-r--r--src/common/common.c11
-rw-r--r--src/common/common.h53
-rw-r--r--src/common/defs.h72
-rw-r--r--src/common/priority3
-rw-r--r--src/common/unionfs.c1086
-rw-r--r--src/common/unionfs.h49
-rw-r--r--src/dump_session.c166
-rw-r--r--src/exe_action.c122
9 files changed, 2317 insertions, 0 deletions
diff --git a/src/commit2.c b/src/commit2.c
new file mode 100644
index 0000000..dffdb02
--- /dev/null
+++ b/src/commit2.c
@@ -0,0 +1,755 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <glib-2.0/glib.h>
+#include "common/common.h"
+
+boolean g_debug = FALSE;
+boolean g_display_error_node = FALSE;
+boolean g_coverage = FALSE;
+
+char* ActionNames[top_act] = {
+ "delete",
+ "create",
+ "activate",
+ "update",
+ "syntax",
+ "commit",
+ "begin",
+ "end"
+};
+
+extern boolean
+check_syn(vtw_node *cur);
+
+GNode*
+get_transactions(GNode*, boolean priority);
+
+boolean
+complete(GNode *node, boolean test_mode);
+
+gboolean
+sort_func(GNode *node, gpointer data, boolean priority_mode);
+
+gboolean
+sort_func_priority(GNode *node, gpointer data);
+
+gboolean
+sort_func_simple(GNode *node, gpointer data);
+
+void
+cleanup(GNode *root_node);
+
+gboolean
+dump_func(GNode *node, gpointer data);
+
+static gboolean
+enclosing_process_func(GNode *node, gpointer data);
+
+static gboolean
+process_func(GNode *node, gpointer data);
+
+boolean
+process_priority_node(GNode *priority_node);
+
+static gboolean
+enclosing_process_func(GNode *node, gpointer data);
+/*
+NOTES: reverse: use the n-nary tree in commit2.c and only encapuslate data store. pass in func pointer for processing of commands below.
+
+also, the algorithm for collapsing the tree into a transaction list is:
+1) iterate through tree and mark all explicit transactions
+2) when done, prune the tree of all root explicit transactions
+3) Now iterate through remaining tree and remove each node and append to transaction list.
+
+
+TODO:
+> Implement transactional sorting functions (test)
+> possibly add back validation sequence (difference in committing failed user w/o pw)
+> memory handling code (i.e. all the frees I left out)
+> test on boot by having boot call load rather than running through boot (and adding priority file)
+>
+
+ */
+
+/**
+ *
+ *
+ **/
+void
+usage()
+{
+ printf("commit2\n");
+ printf("-d\t\tdebug mode\n");
+ printf("-s\t\tdump sorted transactions and exit\n");
+ printf("-p\t\tdisable priority mode\n");
+ printf("-t\t\ttest mode (don't apply directory modifications)\n");
+ printf("-e\t\tprint node where error occurred\n");
+ printf("-c\t\tdump node coverage and execution times\n");
+ printf("-h\t\thelp\n");
+}
+
+/**
+ *
+ *
+ **/
+int
+main(int argc, char** argv)
+{
+ int ch;
+ boolean dump_trans = TRUE;
+ boolean priority_mode = TRUE;
+ boolean test_mode = FALSE;
+
+ //grab inputs
+ while ((ch = getopt(argc, argv, "dpthsec")) != -1) {
+ switch (ch) {
+ case 'd':
+ g_debug = TRUE;
+ break;
+ case 'h':
+ usage();
+ exit(0);
+ break;
+ case 'p':
+ priority_mode = FALSE;
+ break;
+ case 't':
+ test_mode = TRUE;
+ break;
+ case 's':
+ dump_trans = TRUE;
+ break;
+ case 'e':
+ g_display_error_node = TRUE;
+ break;
+ case 'c':
+ g_coverage = TRUE;
+ break;
+ default:
+ usage();
+ exit(0);
+ }
+ }
+
+ initialize_output();
+ init_paths(TRUE);
+ if (g_debug) {
+ printf("commit2: starting up\n");
+ }
+
+ //get local session data plus configuration data
+ GNode *config_data = common_get_local_session_data();
+ if (g_node_n_children(config_data) == 0) {
+ common_commit_clean_temp_config(test_mode);
+ fprintf(out_stream, "No configuration changes to commit\n");
+ return 0;
+ }
+
+ // Get collection of transactions, i.e. trans nodes that have been activated.
+ GNode *trans_coll = get_transactions(config_data, priority_mode);
+ if (trans_coll == NULL) {
+ printf("commit2: transactions collection is empty, exiting\n");
+ exit(0);
+ }
+
+ if (dump_trans == TRUE) {
+ printf("Dumping transactions\n");
+ //iterate over config_data and dump...
+ g_node_traverse(trans_coll,
+ G_PRE_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)dump_func,
+ (gpointer)NULL);
+ // exit(0);
+ }
+
+ GNode *trans_child_node = (GNode*)g_node_first_child(trans_coll);
+ if (trans_child_node == NULL) {
+ printf("commit2: No child nodes to process, exiting\n");
+ exit(0);
+ }
+
+ boolean no_errors = TRUE;
+ set_in_commit(TRUE);
+ int i = 0;
+ do {
+ boolean success = TRUE;
+ if (g_debug == TRUE) {
+ printf("commit2: Starting new transaction processing pass on root\n");
+ }
+
+ //on each priority node now execute actions
+ if ((success = process_priority_node(trans_child_node)) == TRUE) {
+ //this below copies the node directory from the local to active location
+ success = complete(trans_child_node, test_mode);
+ }
+
+ if (success == FALSE) {
+ no_errors = FALSE;
+ if (g_debug == TRUE) {
+ printf("commit2: Failed in processing node\n");
+ }
+ }
+ ++i;
+ } while ((trans_child_node = (GNode*)g_node_nth_child((GNode*)trans_coll,(guint)i)) != NULL);
+
+ if (no_errors == TRUE) {
+ common_commit_clean_temp_config(test_mode);
+ if (g_debug == TRUE) {
+ printf("commit2: successful commit, now cleaning up temp directories\n");
+ }
+ }
+ set_in_commit(FALSE);
+
+ cleanup(config_data);
+ cleanup(trans_child_node);
+
+ if (g_debug) {
+ printf("DONE\n");
+ }
+ exit(0);
+}
+
+/**
+ *
+ *
+ **/
+static gboolean
+process_func(GNode *node, gpointer data)
+{
+ if (node == NULL) {
+ return TRUE;
+ }
+
+ struct Result *result = (struct Result*)data;
+ gpointer gp = ((GNode*)node)->data;
+ struct Config *c = &((struct VyattaNode*)gp)->_config;
+ struct Data *d = &((struct VyattaNode*)gp)->_data;
+
+ int status = 0;
+ if (c->_def.actions &&
+ c->_def.actions[result->_action].vtw_list_head){
+
+ if (g_debug) {
+ if (d->_name != NULL) {
+ printf("commit2::process_func(), calling process on : %s for action %d, type: %d, operation: %d, path: %s\n",d->_name,result->_action,c->_def.def_type, d->_operation, d->_path);
+ }
+ else {
+ printf("commit2::process_func(), calling process on : [n/a] for action %d, operation: %d, path: %s\n",result->_action, d->_operation, d->_path);
+ }
+ }
+
+ /*
+ Needs to be cleaned up a bit such that this convoluted if clause is easier to read. Basically
+ is says:
+ if a node is SET, is not ACTIVE and is not a DELETE ACTION
+ or
+ if a node is SET, is ACTIVE, is not a DELETE ACTION or a CREATE ACTION
+ or
+ if a node is DELETE, is a DELETE ACTION or a END ACTION, or a BEGIN ACTION
+ */
+ if ((IS_SET(d->_operation) && !IS_ACTIVE(d->_operation) && (result->_action != delete_act && result->_action != create_act)) ||
+ (IS_CREATE(d->_operation) && !IS_ACTIVE(d->_operation) && (result->_action == syntax_act || result->_action == begin_act || result->_action == end_act || result->_action == create_act || (result->_action == update_act && !c->_def.actions[create_act].vtw_list_head))) ||
+ (IS_SET_OR_CREATE(d->_operation) && IS_ACTIVE(d->_operation) && ((result->_action != delete_act) && (result->_action != create_act))) ||
+ // (IS_DELETE(d->_operation) && ((result->_action == delete_act) || (result->_action == syntax_act) || (result->_action == begin_act) || (result->_action == end_act)) )) {
+ (IS_DELETE(d->_operation) && ((result->_action == delete_act) || (result->_action == begin_act) || (result->_action == end_act)) )) {
+ //NEED TO ADD IF CREATE, THEN CREATE OR UPDATE
+ //IF SET THEN UPDATE
+
+ //let's skip the case where this is active and it's a delete--shouldn't be done, but needs to be include in the rule set above
+ if (IS_DELETE(d->_operation) && IS_ACTIVE(d->_operation) && result->_action == delete_act) {
+ return FALSE;
+ }
+
+ //look at parent for multi tag
+ if (d->_value && d->_name) {
+ if (g_debug) {
+ printf("commit2::process_func(): @ value: %s\n",(char*)clind_unescape(d->_name));
+ }
+ set_at_string((char*)clind_unescape(d->_name)); //embedded multinode value
+ }
+ else {
+ if (g_debug) {
+ printf("commit2::process_func(): boolean value is: %d\n",d->_value);
+ if (node->parent != NULL && ((struct VyattaNode*)(node->parent->data))->_data._name != NULL) {
+ printf("commit2::process_func(): parent has a name and it is: %s\n",((struct VyattaNode*)(node->parent->data))->_data._name);
+ }
+ printf("commit2::process_func(): @ value: [NULL]\n");
+ }
+ }
+
+ common_set_context(c->_path,d->_path);
+ if (g_debug) {
+ printf("Executing %s on this node\n", ActionNames[result->_action]);
+ }
+
+ if (g_coverage) {
+ struct timeval t;
+ gettimeofday(&t,NULL);
+ printf("[START] %lu, %s@%s",(unsigned long)t.tv_sec,ActionNames[result->_action],d->_path);
+ }
+
+ if (result->_action == delete_act) {
+ set_in_delete_action(TRUE);
+ }
+ status = execute_list(c->_def.actions[result->_action].vtw_list_head,&c->_def);
+ if (result->_action == delete_act) {
+ set_in_delete_action(FALSE);
+ }
+
+ if (g_coverage) {
+ struct timeval t;
+ gettimeofday(&t,NULL);
+ printf("[END] %lu\n",t.tv_sec);
+ }
+
+ if (!status) { //EXECUTE_LIST RETURNS FALSE ON FAILURE....
+ if (g_display_error_node) {
+ fprintf(out_stream,"%s:[%s]\n",ActionNames[result->_action],d->_path);
+ }
+ result->_err_code = 1;
+ if (g_debug) {
+ printf("commit2::process_func(): FAILURE: status: %d\n",status);
+ }
+ return TRUE; //WILL STOP AT THIS POINT
+ }
+ }
+ }
+ return FALSE;
+}
+
+
+/**
+ *
+ **/
+boolean
+complete(GNode *node, boolean test_mode)
+{
+ gpointer gp = ((GNode*)node)->data;
+ if (g_debug) {
+ if (((struct VyattaNode*)gp)->_data._name != NULL) {
+ printf("commit2::complete(): %s\n",((struct VyattaNode*)gp)->_data._name);
+ }
+ else {
+ printf("commit2::complete()\n");
+ }
+ }
+ //on transactional nodes only, note to avoid calling this if a headless root
+ common_commit_copy_to_live_config(((struct VyattaNode*)gp)->_data._path, test_mode);
+ return TRUE;
+}
+
+
+/**
+ *
+ *
+ **/
+gboolean
+sort_func_priority(GNode *node, gpointer data)
+{
+ return sort_func(node,data,TRUE);
+}
+
+/**
+ *
+ *
+ **/
+gboolean
+sort_func_simple(GNode *node, gpointer data)
+{
+ return sort_func(node,data,FALSE);
+}
+
+
+
+/**
+ *
+ *
+ **/
+gboolean
+sort_func(GNode *node, gpointer data, boolean priority_mode)
+{
+ gpointer gp = ((GNode*)node)->data;
+ GNode *root_node = (GNode*)data;
+ if (g_debug) {
+ if (((struct VyattaNode*)gp)->_data._name != NULL) {
+ printf("commit2::sort_func(): %s, node count: %d\n",((struct VyattaNode*)gp)->_data._name,g_node_n_children(root_node));
+ }
+ else {
+ printf("commit2::sort_func(): [n/a], node count: %d\n",g_node_n_children(root_node));
+ }
+ }
+
+ //change action state of node according to enclosing behavior
+ if ((G_NODE_IS_ROOT(node) == FALSE) &&
+ ((IS_SET_OR_CREATE(((struct VyattaNode*)gp)->_data._operation)) ||
+ (IS_DELETE(((struct VyattaNode*)gp)->_data._operation))) &&
+ (IS_NOOP(((struct VyattaNode*)(node->parent->data))->_data._operation))) {
+
+ //first check if there is enclosing behavior
+ boolean enclosing = FALSE;
+ GNode *n = node;
+ while (TRUE) {
+ n = n->parent;
+ vtw_def def = ((struct VyattaNode*)(n->data))->_config._def;
+ if (def.actions[end_act].vtw_list_head || def.actions[begin_act].vtw_list_head ||
+ (def.actions[syntax_act].vtw_list_head && def.actions[syntax_act].vtw_list_head->vtw_node_aux == 1)) {
+ enclosing = TRUE;
+ break;
+ }
+ if (G_NODE_IS_ROOT(n) == TRUE) {
+ break;
+ }
+ }
+
+ //walk back up and flip operations until enclosing behavior
+ if (enclosing == TRUE) {
+ GNode *n = node;
+ while (TRUE) {
+ n = n->parent;
+ vtw_def def = ((struct VyattaNode*)(n->data))->_config._def;
+ ((struct VyattaNode*)(n->data))->_data._operation = ((struct VyattaNode*)gp)->_data._operation | K_ACTIVE_OP;
+ if (def.actions[end_act].vtw_list_head || def.actions[begin_act].vtw_list_head ||
+ (def.actions[syntax_act].vtw_list_head && def.actions[syntax_act].vtw_list_head->vtw_node_aux == 1)) {
+ break;
+ }
+ if (G_NODE_IS_ROOT(n) == TRUE) {
+ break;
+ }
+ }
+ }
+ }
+
+ if (priority_mode) {
+ if (((struct VyattaNode*)gp)->_priority < LOWEST_PRIORITY) { //only if priority is specified.
+ //unlink from original tree
+ g_node_unlink(node);
+
+ GNode *new_node = g_node_copy(node);
+ GNode *sibling = root_node->children;
+ //now iterate through siblings of root_node and compare priority
+
+ while (sibling != NULL && ((struct VyattaNode*)gp)->_priority > ((struct VyattaNode*)(sibling->data))->_priority) {
+ sibling = sibling->next;
+ if (sibling == NULL || ((struct VyattaNode*)gp)->_priority < ((struct VyattaNode*)(sibling->data))->_priority) {
+ break;
+ }
+ }
+
+ if (g_debug) {
+ int pri = LOWEST_PRIORITY;
+ if (sibling != NULL) {
+ pri = ((struct VyattaNode*)(sibling->data))->_priority;
+ }
+ printf("commit2::sort_func(): inserting %s into transaction, priority: %d BEFORE %d\n", ((struct VyattaNode*)gp)->_data._name, ((struct VyattaNode*)gp)->_priority, pri);
+ }
+ g_node_insert_before(root_node,sibling,new_node);
+ }
+ }
+ else {
+ if (g_node_depth(node) == 2) {
+ if (g_debug) {
+ printf("commit2::sort_func(): inserting %s into transaction\n", ((struct VyattaNode*)gp)->_data._name);
+ }
+ GNode *new_node = g_node_copy(node);
+ g_node_insert(root_node,-1,new_node); //make a flat structure for now
+ }
+ }
+ return FALSE;
+}
+
+
+/**
+ * Gets a flat collection of nodes, sorted by priority
+ *
+ *
+ **/
+GNode*
+get_transactions(GNode *config, boolean priority_mode)
+{
+ if (g_debug) {
+ printf("commit2::get_transactions()\n");
+ }
+
+ if (config == NULL) {
+ return NULL;
+ }
+
+ gpointer gp = ((GNode*)config)->data;
+
+ GNode *trans_root = g_node_new(gp);
+ if (priority_mode) {
+ g_node_traverse(config,
+ G_POST_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)sort_func_priority,
+ (gpointer)trans_root);
+
+ //only do this if the root isn't empty
+ if (g_node_n_children(config) != 0) {
+ g_node_insert(trans_root,-1,config); //add what's left
+ }
+ }
+ else {
+ g_node_traverse(config,
+ G_IN_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)sort_func_simple,
+ (gpointer)trans_root);
+ }
+ return trans_root;
+}
+
+
+/**
+ *
+ *
+ **/
+static gboolean
+cleanup_func(GNode *node, gpointer data)
+{
+ struct VyattaNode *vn = ((struct VyattaNode*)(node->data));
+ if (vn->_data._name) {
+ free(vn->_data._name);
+ }
+ if (vn->_data._path) {
+ free(vn->_data._path);
+ }
+ if (vn->_config._help) {
+ free(vn->_config._help);
+ }
+ if (vn->_config._default) {
+ free(vn->_config._default);
+ }
+ if (vn->_config._path) {
+ free(vn->_config._path);
+ }
+ return FALSE;
+}
+
+/**
+ *
+ *
+ **/
+void
+cleanup(GNode *root_node)
+{
+ if (root_node == NULL) {
+ return;
+ }
+
+ g_node_traverse(root_node,
+ G_IN_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)cleanup_func,
+ (gpointer)NULL);
+
+ g_node_destroy(root_node);
+}
+
+/**
+ *
+ **/
+gboolean
+dump_func(GNode *node, gpointer data)
+{
+ if (node != NULL) {
+ guint depth = g_node_depth(node);
+
+ if (depth == 2) {
+ printf("NEW TRANS\n");
+ }
+
+ gpointer gp = ((GNode*)node)->data;
+ if (((struct VyattaNode*)gp)->_data._name != NULL) {
+ int i;
+
+ if (IS_DELETE(((struct VyattaNode*)gp)->_data._operation)) {
+ printf("-");
+ }
+ else if (IS_CREATE(((struct VyattaNode*)gp)->_data._operation)) {
+ printf("+");
+ }
+ else if (IS_SET(((struct VyattaNode*)gp)->_data._operation)) {
+ printf(">");
+ }
+ else {
+ printf(" ");
+ }
+ for (i = 0; i < depth; ++i) {
+ printf(" ");
+ }
+ printf("%s (t: %d, p: %d)", ((struct VyattaNode*)gp)->_data._name,((struct VyattaNode*)gp)->_config._def.def_type,((struct VyattaNode*)gp)->_priority);
+ if (((struct VyattaNode*)gp)->_data._value == TRUE) {
+ printf(" [VALUE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._multi == TRUE) {
+ printf(" [MULTI]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[syntax_act].vtw_list_head &&
+ ((struct VyattaNode*)gp)->_config._def.actions[syntax_act].vtw_list_head->vtw_node_aux == 0) {
+ printf(" [SYNTAX]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[create_act].vtw_list_head) {
+ printf(" [CREATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[activate_act].vtw_list_head) {
+ printf(" [ACTIVATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[update_act].vtw_list_head) {
+ printf(" [UPDATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[delete_act].vtw_list_head) {
+ printf(" [DELETE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[syntax_act].vtw_list_head &&
+ ((struct VyattaNode*)gp)->_config._def.actions[syntax_act].vtw_list_head->vtw_node_aux == 1) {
+ printf(" [COMMIT]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[begin_act].vtw_list_head) {
+ printf(" [BEGIN]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[end_act].vtw_list_head) {
+ printf(" [END]");
+ }
+ if (((struct VyattaNode*)gp)->_config._help != NULL) {
+ // printf("[help: %s]",((struct VyattaNode*)gp)->_config._help);
+ }
+ printf("\n");
+ }
+
+ }
+ return FALSE;
+}
+
+
+/**
+ *
+ **/
+boolean
+process_priority_node(GNode *priority_node)
+{
+ //on each node that is deleted run the delete action within the context of the transaction
+ struct Result result;
+ result._err_code = 0;
+
+ if (priority_node == NULL) {
+ return FALSE;
+ }
+
+ //if this node is an enclosing node, we'll skip this iteration
+ gpointer gp = ((GNode*)priority_node)->data;
+ struct Config *c = &((struct VyattaNode*)gp)->_config;
+ //does this node contain a begin or end statement?
+ boolean priority_node_is_enclosing_node = FALSE;
+ if (c->_def.actions &&
+ (c->_def.actions[end_act].vtw_list_head || c->_def.actions[begin_act].vtw_list_head)){
+ priority_node_is_enclosing_node = TRUE;
+ }
+
+ if (priority_node_is_enclosing_node == FALSE) {
+ //traverse priority node from children up
+ g_node_traverse((GNode*)priority_node,
+ G_POST_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)enclosing_process_func,
+ (gpointer)&result);
+
+ if (result._err_code != 0) {
+ return FALSE;
+ }
+ }
+ //now perform processing on what's left outside of the enclosing begin/end statements
+ int i;
+ for (i = 0; i < top_act; ++i) {
+ int order;
+ if (i != delete_act) {
+ order = G_PRE_ORDER;
+ }
+ else {
+ order = G_POST_ORDER;
+ }
+
+ result._action = i;
+ g_node_traverse((GNode*)priority_node,
+ order,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)process_func,
+ (gpointer)&result);
+ }
+
+ if (result._err_code != 0) {
+ if (g_debug) {
+ printf("commit2::process_priority_node(): failure on processing pass: %d\n", i);
+ }
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/**
+ * Look for begin/end statements to begin processing
+ * of actions.
+ **/
+static gboolean
+enclosing_process_func(GNode *node, gpointer data)
+{
+ if (node == NULL) {
+ return TRUE;
+ }
+
+ struct Result *result = (struct Result*)data;
+ gpointer gp = ((GNode*)node)->data;
+ struct Config *c = &((struct VyattaNode*)gp)->_config;
+ struct Data *d = &((struct VyattaNode*)gp)->_data;
+
+ //does this node contain a begin or end statement?
+ if (c->_def.actions &&
+ (c->_def.actions[end_act].vtw_list_head || c->_def.actions[begin_act].vtw_list_head)){
+ //gotten to this point need to do a call around this enclosing being/end node
+ g_node_unlink(node); //removed this...
+
+ if (g_debug) {
+ printf("commit2::enclosing_process_func(): enclosing statement found on: %s\n",d->_path);
+ }
+ //perform recursive calling on new process node...
+
+ int i;
+ for (i = 0; i < top_act; ++i) {
+ int order;
+ if (i != delete_act) {
+ order = G_PRE_ORDER;
+ }
+ else {
+ order = G_POST_ORDER;
+ }
+
+ result->_action = i;
+ g_node_traverse((GNode*)node,
+ order,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)process_func,
+ (gpointer)result);
+ }
+
+ if (result->_err_code != 0) { //EXECUTE_LIST RETURNS FALSE ON FAILURE....
+ if (g_debug) {
+ printf("commit2::enclosing_process_func(): FAILURE: status: %d\n",result->_err_code);
+ }
+ return TRUE; //WILL STOP AT THIS POINT
+ }
+ }
+ return FALSE;
+}
+
+
diff --git a/src/common/common.c b/src/common/common.c
new file mode 100644
index 0000000..6cdf3e7
--- /dev/null
+++ b/src/common/common.c
@@ -0,0 +1,11 @@
+#include <glib-2.0/glib.h>
+#include "common.h"
+
+
+
+
+boolean
+execute(char *cmd)
+{
+ return TRUE;
+}
diff --git a/src/common/common.h b/src/common/common.h
new file mode 100644
index 0000000..c9cacc8
--- /dev/null
+++ b/src/common/common.h
@@ -0,0 +1,53 @@
+#ifndef __COMMON_H__
+#define __COMMON_H__
+
+#include "defs.h"
+#include "unionfs.h"
+
+
+boolean
+execute(char *cmd);
+
+/**
+ *
+ **/
+GNode*
+common_get_local_session_data();
+
+/**
+ * flushes local session
+ **/
+void
+common_clear_local_session();
+
+/**
+ * brings over local session conf to main config
+ **/
+void
+commmon_copy_local_to_main();
+
+/**
+ * sets system context for operation (i.e. hack for unionfs implementation)
+ **/
+void
+common_set_context(char *cpath, char *dpath);
+
+/**
+ * sets system parent context for operation (i.e. hack for unionfs implementation)
+ **/
+void
+common_set_parent_context(char *cpath, char *dpath);
+
+/**
+ *
+ **/
+void
+common_commit_copy_to_live_config(char *path, boolean test_mode);
+
+/**
+ *
+ **/
+void
+common_commit_clean_temp_config(boolean test_mode);
+
+#endif //__COMMON_H__
diff --git a/src/common/defs.h b/src/common/defs.h
new file mode 100644
index 0000000..b489919
--- /dev/null
+++ b/src/common/defs.h
@@ -0,0 +1,72 @@
+#ifndef __DEFS_H__
+#define __DEFS_H__
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "cli_val.h"
+
+#define boolean int
+
+#define LOWEST_PRIORITY 1000
+
+#define MAX_DEPTH 128
+
+struct Result
+{
+ int _err_code;
+ char *_err_str;
+ int _action;
+};
+
+typedef enum {
+ K_NO_OP = 0x01,
+ K_ACTIVE_OP = 0x02, //as a result of an already created node, but assuming action
+ K_SET_OP = 0x04,
+ K_CREATE_OP = 0x08,
+ K_DEL_OP = 0x10
+} NODE_OPERATION;
+
+#define IS_SET(op) (op & K_SET_OP)
+#define IS_ACTIVE(op) (op & K_ACTIVE_OP)
+#define IS_CREATE(op) (op & K_CREATE_OP)
+#define IS_DELETE(op) (op & K_DEL_OP)
+#define IS_NOOP(op) (op & K_NO_OP)
+#define IS_SET_OR_CREATE(op) ((op & K_SET_OP) || (op & K_CREATE_OP))
+
+/**
+ * keeps both configuration and template data in single structure
+ *
+ **/
+
+/*
+TODO: either port over to new system or retain complete set of cli_val definiaitons.
+remove _actions and rely on def in the future.
+ */
+struct Config
+{
+ boolean _multi;
+ vtw_def _def; //keep this here
+ char* _help;
+ char* _default;
+ char* _path;
+};
+
+/*
+ * is used to define embedded nodes (multi) and leafs
+ */
+struct Data
+{
+ char* _name; //name of this node
+ boolean _value; //is this a value?
+ char* _path;
+ NODE_OPERATION _operation; //no-op, set, or delete
+};
+
+struct VyattaNode
+{
+ struct Data _data;
+ struct Config _config;
+ int _priority; //used for setting priority
+};
+
+#endif //__DEFS_H__
diff --git a/src/common/priority b/src/common/priority
new file mode 100644
index 0000000..ce7800b
--- /dev/null
+++ b/src/common/priority
@@ -0,0 +1,3 @@
+200 firewall
+300 interfaces
+400 system
diff --git a/src/common/unionfs.c b/src/common/unionfs.c
new file mode 100644
index 0000000..e325058
--- /dev/null
+++ b/src/common/unionfs.c
@@ -0,0 +1,1086 @@
+#include <string.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <glib-2.0/glib.h>
+#include "common/defs.h"
+#include "common/unionfs.h"
+
+extern boolean g_debug;
+
+extern vtw_path m_path;
+extern vtw_path t_path;
+
+void
+retrieve_data(char* rel_data_path, GNode *node, char* root, NODE_OPERATION op);
+
+void
+apply_priority(GNode *root_node);
+
+void
+set_path(char *path, boolean config);
+
+struct VyattaNode*
+copy_vyatta_node(struct VyattaNode* vn);
+
+void
+get_term_data_values(GNode *node);
+
+void
+dlist_test_func(GQuark key_id,gpointer data,gpointer user_data);
+
+void
+match_priority_node(GNode *node, gchar** tok_str, int pri);
+
+GNode*
+insert_sibling_in_order(GNode *parent, GNode *child);
+
+void
+piecewise_remove(char* cbuf_root, char* abuf_root, char* path, boolean test_mode);
+/**
+ *
+ *
+ Data is stored on the path:
+
+ /opt/vyatta/config/tmp/new_config_5425/system/login/user/foo/authentication/plaintext-password
+
+ Config is stored along this path:
+
+ /opt/vyatta/config/template/vyatta-cfg/system/login/user/node.tag/authentication/plaintext-password
+
+ 1) Need to split out relative path
+
+ 2) if node is *MULTI* then the path value is the actual value
+
+ 3) For the config copy the pointer from an existing config value for each multinode
+<Need to figure out how this is going to happen>
+
+This should allow a combined data/config tree
+
+ *
+ *
+ *
+ **/
+char*
+get_config_path(GNode *node)
+{
+ char *buf;
+ buf = malloc(MAX_LENGTH_DIR_PATH*sizeof(char));
+ buf[0] = '/';
+ buf[1] = '\0';
+ if (node == NULL) {
+ return NULL;
+ }
+
+ GNode *n = node;
+ while (G_NODE_IS_ROOT(n) != TRUE) {
+ struct VyattaNode *d = (struct VyattaNode*)n->data;
+ if (d == NULL) {
+ if (g_debug) {
+ printf("unionfs::get_config_path(): data ptr is null\n");
+ }
+ return NULL;
+ }
+
+ //if not found, mark current node as multinode
+ if (d->_data._name != NULL) {
+ char tmp[MAX_LENGTH_DIR_PATH];
+ strcpy(tmp,buf);
+
+ //need to check the configuration location for the existance of this node to determine if it's a multi
+ if (G_NODE_IS_ROOT(n->parent) != TRUE &&
+ ((struct VyattaNode*)(n->parent->data))->_config._multi == TRUE) {
+ sprintf(buf,"node.tag/%s",tmp);
+ }
+ else {
+ sprintf(buf,"%s/%s",d->_data._name,tmp);
+ }
+ }
+ n = n->parent;
+ }
+ return buf;
+}
+
+
+/**
+ * Recurse from node identified as deleted
+ **/
+void
+retrieve_delete_data(char* rel_data_path, GNode *node)
+{
+ //switch root
+
+ return;
+}
+
+/**
+ *
+ **/
+void
+retrieve_data(char* rel_data_path, GNode *node, char* root, NODE_OPERATION op)
+{
+ boolean final_node = FALSE;
+
+ if (node == NULL) {
+ return;
+ }
+
+ char *tmp = root;//get_cdirp();
+ char full_data_path[sizeof(char)*MAX_LENGTH_DIR_PATH];
+ strcpy(full_data_path,tmp);
+ if (rel_data_path != NULL) {
+ strcat(full_data_path,rel_data_path);
+ }
+
+ if (g_debug) {
+ printf("unionfs::retrieve_data(): %s\n", full_data_path);
+ }
+
+
+ //WE'LL WANT TO DO SOMETHING LIKE--IS THIS NODE A VALUE NODE, THEN PROCESS.
+
+ //now check for value at this node and copy
+ char *cp = NULL;
+ //data_path needs to be of type vtw_path!!
+ vtw_path vpath;
+ init_path(&vpath, full_data_path);
+ //lstat for value file BEFORE retrieving
+ if (value_exists(full_data_path) && get_value(&cp, &vpath) == 0) {
+ //terminating value need to create new terminating node here!
+ struct VyattaNode *vn = calloc(1,sizeof(struct VyattaNode));
+ GNode *new_node = g_node_new(vn);
+ new_node = insert_sibling_in_order(node,new_node);
+ // new_node = g_node_insert(node, -1, new_node);
+ vn->_data._name = cp;
+ vn->_data._value = FALSE;//TRUE; //data value
+ vn->_data._operation = op;
+ vn->_priority = LOWEST_PRIORITY;
+ vn->_data._path = malloc(MAX_LENGTH_DIR_PATH*sizeof(char));
+ sprintf(vn->_data._path,"%s",rel_data_path);
+ final_node = TRUE;
+ }
+ /*
+ NOTE: will need to implement ptr copy over for the config data that
+ traverses up multi-nodes. Currently this will just read the data from
+ the parser AGAIN, but in the name of memory and performance efficiency
+ this should be a copy of the already processed data.
+ */
+
+ //Now dig up the configuration data
+ char *config_path = get_config_path(node);
+
+ if (config_path != NULL) {
+ char *conf_base = (char*)get_tdirp();
+ char buf[MAX_LENGTH_HELP_STR];
+ sprintf(buf,"%s/%snode.def",conf_base,config_path);
+ struct stat s;
+ if (g_debug) {
+ printf("unionfs::retrieve_data(): config path: %s\n",buf);
+ }
+
+ struct VyattaNode* vn = (struct VyattaNode*)node->data;
+ vtw_def def;
+ memset(&def, 0, sizeof(def));
+ if ((lstat(buf,&s) == 0) && S_ISREG(s.st_mode)) {
+ if (parse_def(&def, buf, FALSE) == 0) {
+ if (g_debug) {
+ printf("[FOUND node.def]");
+ }
+ //either multi or tag--shouldn't have made a difference, but arkady was confused.
+ vn->_config._multi = (def.tag | def.multi);
+ }
+ }
+
+ vn->_config._def = def;
+ vn->_config._path = config_path;
+ char *tmp = malloc(sizeof(char)*MAX_LENGTH_DIR_PATH);
+ strcpy(tmp,rel_data_path);
+ strcat(tmp,"/");
+ vn->_data._path = tmp;
+
+ //will stamp an embedded node as a value node
+ if (G_NODE_IS_ROOT(node) == FALSE) {
+ struct VyattaNode* vn_parent = (struct VyattaNode*)node->parent->data;
+ if (vn_parent->_config._multi == TRUE) {
+ ((struct VyattaNode*)node->data)->_data._value = TRUE;
+
+ //now let's patch up the def multi-nodes
+ //move the def for the multinode from the parent to the value node
+ struct VyattaNode* vn2 = (struct VyattaNode*)node->data;
+ if (final_node == FALSE) { //non-term multi
+ if (g_node_n_children(node->parent) == 1) {
+ vn2->_config._def = ((struct VyattaNode*)node->parent->data)->_config._def;
+ memset(&((struct VyattaNode*)node->parent->data)->_config._def, 0, sizeof(vtw_def));
+ }
+ else { //find node other than myself to copy defs across
+ GNode *first_child = g_node_first_child(node->parent);
+ if (first_child == node) {
+ first_child = g_node_next_sibling(first_child);
+ }
+ vn2->_config._def = ((struct VyattaNode*)first_child->data)->_config._def;
+ }
+ }
+ }
+ }
+
+ if (g_debug) {
+ printf("\n");
+ }
+ }
+
+ if (final_node == TRUE) {
+ //move defs to child...
+ get_term_data_values(node);
+
+ //fix operation on parent because this is a final node
+ char buf[MAX_LENGTH_HELP_STR];
+ sprintf(buf,"%s/%s",get_adirp(),rel_data_path);
+ struct stat s;
+ if ((lstat(buf,&s) != 0) && S_ISREG(s.st_mode)) {
+ struct VyattaNode* vn = (struct VyattaNode*)node->data;
+ vn->_data._operation = K_CREATE_OP;
+ }
+ return;
+ }
+
+ //iterate over directory here
+ DIR *dp;
+ if ((dp = opendir(full_data_path)) == NULL){
+ if (g_debug) {
+ //could also be a terminating value now
+ printf("unionfs::retrieve_data(), failed to open directory: %s\n", full_data_path);
+ }
+ return;
+ }
+ //finally iterate over valid child directory entries
+
+ boolean processed = FALSE;
+ struct dirent *dirp = NULL;
+ while ((dirp = readdir(dp)) != NULL) {
+ if (strcmp(dirp->d_name, ".") != 0 &&
+ strcmp(dirp->d_name, "..") != 0 &&
+ strcmp(dirp->d_name, MODIFIED_FILE) != 0 &&
+ strcmp(dirp->d_name, DEF_FILE) != 0 &&
+ strcmp(dirp->d_name, WHITEOUT_FILE) != 0 &&
+ strcmp(dirp->d_name, VALUE_FILE) != 0) {
+ processed = TRUE;
+ char *data_buf = malloc(MAX_LENGTH_DIR_PATH*sizeof(char));
+ if (strncmp(dirp->d_name,DELETED_NODE,4) == 0) {
+ strcpy(data_buf,dirp->d_name+4); //SKIP THE .WH.
+
+ //create new node and insert...
+ struct VyattaNode *vn = calloc(1,sizeof(struct VyattaNode));
+ vn->_data._name = data_buf;
+ vn->_data._value = FALSE;
+ vn->_data._operation = K_DEL_OP;
+ vn->_priority = LOWEST_PRIORITY;
+
+ char new_data_path[MAX_LENGTH_DIR_PATH];
+ sprintf(new_data_path,"%s/%s",rel_data_path,data_buf);
+
+ GNode *new_node = g_node_new(vn);
+ // new_node = g_node_insert(node, -1, new_node);
+ new_node = insert_sibling_in_order(node,new_node);
+
+ //will need to enter a special recursion against the active configuration to mark nested delete nodes
+ retrieve_data(new_data_path,new_node,get_adirp(),K_DEL_OP);
+ }
+ else {
+ strcpy(data_buf,dirp->d_name);
+ //create new node and insert...
+ struct VyattaNode *vn = calloc(1,sizeof(struct VyattaNode));
+ vn->_data._name = data_buf;
+ vn->_data._value = FALSE;
+ vn->_priority = LOWEST_PRIORITY;
+
+ char new_data_path[MAX_LENGTH_DIR_PATH];
+ sprintf(new_data_path,"%s/%s",rel_data_path,data_buf);
+
+ char active_data_path[MAX_LENGTH_DIR_PATH];
+ sprintf(active_data_path,"%s%s",get_adirp(),rel_data_path);
+ struct stat s;
+
+ if (lstat(active_data_path,&s) == 0) {
+ vn->_data._operation = K_NO_OP;
+ }
+ else {
+ vn->_data._operation = K_CREATE_OP;
+ ((struct VyattaNode*)node->data)->_data._operation = K_CREATE_OP;
+ }
+ //set recursed entry op to del
+ if (op == K_DEL_OP) {
+ vn->_data._operation = K_DEL_OP;
+ }
+ GNode *new_node = g_node_new(vn);
+ // new_node = g_node_insert(node, -1, new_node);
+ new_node = insert_sibling_in_order(node,new_node);
+ retrieve_data(new_data_path,new_node,root,vn->_data._operation);
+ }
+ }
+ }
+ //catch hanging case where embedded multinode is new with no children
+ if (processed == FALSE) {
+ char active_data_path[MAX_LENGTH_DIR_PATH];
+ sprintf(active_data_path,"%s/%s",get_adirp(),rel_data_path);
+ struct stat s;
+ if ((lstat(active_data_path,&s) != 0)) {
+ ((struct VyattaNode*)node->data)->_data._operation = K_CREATE_OP;
+ }
+ }
+
+ closedir(dp);
+ return;
+}
+
+
+/**
+ *
+ **/
+GNode*
+common_get_local_session_data()
+{
+ //get root directory
+ char *data_path = malloc(sizeof(char)*MAX_LENGTH_DIR_PATH);
+ data_path[0] = '\0';
+
+ struct VyattaNode *vn = calloc(1,sizeof(struct VyattaNode));
+ vn->_data._name = NULL; //root node has null
+ vn->_data._operation = K_NO_OP;
+ vn->_priority = LOWEST_PRIORITY;
+
+ //create first node
+ GNode *root_node = g_node_new(vn);
+
+ //iterate through recursive calls to parse_new() calls (see original commit())
+ retrieve_data(data_path,root_node,get_cdirp(),K_SET_OP);
+
+ apply_priority(root_node);
+
+ return root_node;
+}
+
+
+/**
+ *
+ **/
+boolean
+value_exists(char *path)
+{
+ char buf[MAX_LENGTH_DIR_PATH];
+ sprintf(buf, "%s/%s",path,VALUE_FILE);
+ struct stat stat_buf;
+ return !stat(buf,&stat_buf);
+}
+
+/**
+ * need to compute parent as it might not be in the node structure
+ *
+ **/
+void
+common_set_parent_context(char *cpath, char *dpath)
+{
+ printf("common_set_parent_context(incoming): %s, %s\n",cpath,dpath);
+ //strip off last path and set
+ int index = strlen(cpath)-1;
+ if (cpath[index] == '/') {
+ while (TRUE) {
+ if (cpath[--index] != '/') {
+ cpath[index] = '\0';
+ break;
+ }
+ }
+ }
+ char *ptr = rindex(cpath,'/');
+ if (ptr != NULL) {
+ *ptr = '\0';
+ }
+ set_path(cpath,TRUE);
+
+ index = strlen(dpath)-1;
+ if (dpath[index] == '/') {
+ while (TRUE) {
+ if (dpath[--index] != '/') {
+ dpath[index] = '\0';
+ break;
+ }
+ }
+ }
+ ptr = rindex(dpath,'/');
+ if (ptr != NULL) {
+ *ptr = '\0';
+ }
+ set_path(dpath,FALSE);
+ printf("common_set_parent_context: %s, %s\n",cpath,dpath);
+}
+
+/**
+ *
+ **/
+void
+common_set_context(char *cpath, char *dpath)
+{
+ printf("common_set_context: %s, %s\n",cpath,dpath);
+ set_path(cpath,TRUE);
+ set_path(dpath,FALSE);
+}
+
+/**
+ *
+ **/
+void
+set_path(char *path, boolean config)
+{
+ //set t_path, m_path
+ //tokenize path and iterate
+ if (config == FALSE) {
+ init_path(&m_path, get_mdirp());
+ }
+ else {
+ init_path(&t_path, get_tdirp());
+ }
+
+ char* start_ptr = NULL;
+ char* end_ptr = NULL;
+
+ if (path == NULL) {
+ if (g_debug) {
+ printf("unionfs::set_path() null value on entry\n");
+ }
+ return;
+ }
+
+ start_ptr = path;
+ while((end_ptr = index(start_ptr+1,'/')) != NULL) {
+ char tmp[1024];
+
+ if (*start_ptr == '/') {
+ ++start_ptr;
+ }
+
+ int size = end_ptr-start_ptr;
+ if (size < 1 || size > 1024) {
+ /*
+ if (g_debug) {
+ if (config == FALSE) {
+ printf("unionfs::set_path(): %s, %s\n", path,m_path.path);
+ }
+ else {
+ printf("unionfs::set_path(): %s, %s\n", path,t_path.path);
+ }
+ }
+ */
+ return;
+ }
+
+ memcpy(tmp, start_ptr, size);
+ tmp[size] = '\0';
+
+ if (config == FALSE) {
+ push_path_no_escape(&m_path, tmp); //data
+ }
+ else {
+ push_path_no_escape(&t_path, tmp); //config
+ }
+ start_ptr = end_ptr;
+ }
+ /*
+ if (g_debug) {
+ if (config == FALSE) {
+ printf("unionfs::set_path(): %s, %s\n", path,m_path.path);
+ }
+ else {
+ printf("unionfs::set_path(): %s, %s\n", path,t_path.path);
+ }
+ }
+ */
+}
+
+/**
+ * NEED TO PROTECT AGAINST NESTED COMMIT NODES. CANNOT BE SUPPORTED
+ * IN CURRENT HIERARCHICAL STRUCTURE WITHOUT CHANGING HOW UNDERLYING
+ * SYSTEM MAINTAINS DATA.
+ *
+original commands:
+ static const char format1[]="cp -r -f %s/* %s"; //mdirp, tmpp
+ static const char format2[]="sudo umount %s"; //mdirp
+ static const char format3[]="rm -f %s/" MOD_NAME " >&/dev/null ; /bin/true";
+ //tmpp
+ static const char format4[]="rm -rf %s/{.*,*} >&/dev/null ; /bin/true"; //cdirp
+ static const char format5[]="rm -rf %s/{.*,*} >&/dev/null ; /bin/true"; //adirp
+ static const char format6[]="mv -f %s/* -t %s";//tmpp, adirp
+ static const char format7[]="sudo mount -t $UNIONFS -o dirs=%s=rw:%s=ro $UNIONFS %s"; //cdirp, adirp, mdirp
+ *
+ **/
+void
+common_commit_copy_to_live_config(char *path, boolean test_mode)
+{
+ //first check for existence of path before committing
+
+ if (g_debug) {
+ printf("common_commit_copy_to_live_config(): %s\n",path);
+ }
+ char *command = malloc(MAX_LENGTH_DIR_PATH);
+ static const char format0[]="mkdir -p %s ; /bin/true";
+ static const char format1[]="cp -r -f %s/* %s"; /*mdirp, tmpp*/
+
+ static const char format2[]="sudo umount %s"; //mdirp
+
+ static const char format4[]="rm -rf %s/{.*,*} >&/dev/null ; /bin/true"; /*cdirp*/
+
+ //walk up tree until diverge or skip
+ static const char format6[]="cp -rf %s/* -t %s";/*tmpp, adirp*/
+
+ static const char format7[]="rm -fr %s >&/dev/null ; /bin/true"; /*tmpp*/
+
+ static const char format8[]="sudo mount -t unionfs -o dirs=%s=rw:%s=ro unionfs %s"; //cdirp, adirp, mdirp
+
+ set_echo(TRUE);
+
+ char mbuf[MAX_LENGTH_DIR_PATH];
+ sprintf(mbuf,"%s%s",get_mdirp(),path);
+ char cbuf[MAX_LENGTH_DIR_PATH];
+ sprintf(cbuf,"%s%s",get_cdirp(),path);
+ char tbuf[MAX_LENGTH_DIR_PATH];
+ sprintf(tbuf,"%s%s",get_tmpp(),path);
+ char abuf[MAX_LENGTH_DIR_PATH];
+ sprintf(abuf,"%s%s",get_adirp(),path);
+
+ char mbuf_root[MAX_LENGTH_DIR_PATH];
+ sprintf(mbuf_root,"%s",get_mdirp());
+ char cbuf_root[MAX_LENGTH_DIR_PATH];
+ sprintf(cbuf_root,"%s",get_cdirp());
+ char tbuf_root[MAX_LENGTH_DIR_PATH];
+ sprintf(tbuf_root,"%s",get_tmpp());
+ char abuf_root[MAX_LENGTH_DIR_PATH];
+ sprintf(abuf_root,"%s",get_adirp());
+
+ //only operate on path if it exists
+ struct stat s;
+ if ((lstat(mbuf,&s) != 0) && S_ISREG(s.st_mode)) {
+ printf("common_commit_copy_to_live_config(): failed to find: %s, aborting copy\n",mbuf);
+ return;
+ }
+
+ sprintf(command,format0,tbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ sprintf(command, format1, mbuf, tbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ sprintf(command, format2, mbuf_root);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ sprintf(command,format0,abuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ piecewise_remove(cbuf_root,abuf_root,path,test_mode);
+
+ sprintf(command, format4, cbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+ /*
+ sprintf(command, format5, abuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+ */
+ //special piecewise operation
+ //walk down tree and perform command where siblings diverge btwn tbuf and abuf
+
+ sprintf(command, format6, tbuf, abuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+
+ sprintf(command, format7, tbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ sprintf(command, format8, cbuf_root,abuf_root,mbuf_root);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ fflush(NULL);
+
+ free(command);
+ return;
+}
+
+/**
+ *
+ **/
+void
+common_commit_clean_temp_config(boolean test_mode)
+{
+ if (g_debug) {
+ printf("common_commit_clean_temp_config()\n");
+ }
+ //first clean up the root
+ // common_commit_copy_to_live_config("/");
+
+ char *command;
+ command = malloc(MAX_LENGTH_DIR_PATH);
+ static const char format2[]="sudo umount %s"; //mdirp
+ static const char format3[]="rm -f %s/" MOD_NAME " >&/dev/null ; /bin/true"; /*tmpp*/
+ static const char format5[]="rm -fr %s/{.*,*} >&/dev/null ; /bin/true"; /*cdirp*/
+ static const char format7[]="sudo mount -t unionfs -o dirs=%s=rw:%s=ro unionfs %s"; //cdirp, adirp, mdirp
+
+
+ char tbuf[MAX_LENGTH_DIR_PATH];
+ sprintf(tbuf,"%s",get_tmpp());
+ char cbuf[MAX_LENGTH_DIR_PATH];
+ sprintf(cbuf,"%s",get_cdirp());
+ char mbuf[MAX_LENGTH_DIR_PATH];
+ sprintf(mbuf,"%s",get_mdirp());
+ char abuf[MAX_LENGTH_DIR_PATH];
+ sprintf(abuf,"%s",get_adirp());
+
+ set_echo(TRUE);
+
+ sprintf(command, format2, mbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ sprintf(command, format3, tbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ sprintf(command, format3, cbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ sprintf(command, format5, cbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ sprintf(command, format7, cbuf,abuf,mbuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+
+ /* notify other users in config mode */
+ system("/opt/vyatta/sbin/vyatta-cfg-notify");
+
+ free(command);
+ return;
+}
+
+
+void
+match_priority_node(GNode *node, gchar** tok_str, int pri)
+{
+ int index = g_node_depth(node)-1;
+ if (tok_str[index] == NULL) {
+ //MATCHED TO THE END
+ ((struct VyattaNode*)node->data)->_priority = pri;
+ return;
+ }
+ //iterate over children for a potential match
+ GNode *child = g_node_first_child(node);
+ while (child != NULL) {
+ char *compval = ((struct VyattaNode*)child->data)->_data._name;
+ if (strncmp(compval,tok_str[index],strlen(compval)) == 0) {
+ match_priority_node(child,tok_str,pri);
+ }
+ else if (strncmp(NODE_TAG_FILE,tok_str[index],strlen(NODE_TAG_FILE)) == 0) {
+ match_priority_node(child,tok_str,pri);
+ }
+ child = g_node_next_sibling(child);
+ }
+ return;
+}
+
+/**
+ *
+ *
+ **/
+void
+set_node_priority(GNode *root_node,char* path,unsigned long pri)
+{
+ if (root_node == NULL) {
+ return;
+ }
+ gchar** tok_str = g_strsplit(path,"/",MAX_DEPTH);
+
+ struct PriData pri_data;
+
+ pri_data._pri = pri;
+ pri_data._tok_str = tok_str;
+
+ match_priority_node(root_node,tok_str,pri);
+
+ g_strfreev(tok_str);
+ return;
+}
+
+
+/**
+ *
+ **/
+void
+apply_priority(GNode *root_node)
+{
+ //parse file and find node and set value
+ FILE *fp = fopen(NODE_PRIORITY_FILE, "r");
+ if (fp != NULL) {
+ if (g_debug) {
+ printf("unionfs::apply_priority(), found priority file\n");
+ }
+
+ char str[1025];
+ while (fgets(str, 1024, fp) != 0) {
+ gchar** tok_str = g_strsplit(str," ",3);
+ char *path = tok_str[1];
+ if (g_debug) {
+ printf("unionfs::apply_priority(), working on this %s\n",path);
+ }
+
+ //now apply to node
+ set_node_priority(root_node,path,strtoul(tok_str[0],NULL,10));
+ g_strfreev(tok_str);
+ }
+ fclose(fp);
+ }
+}
+
+/**
+ *
+ **/
+struct VyattaNode*
+copy_vyatta_node(struct VyattaNode* vn)
+{
+ struct VyattaNode *new_vn = calloc(1,sizeof(struct VyattaNode));
+
+ if (vn->_data._name != NULL) {
+ new_vn->_data._name = malloc(MAX_LENGTH_DIR_PATH*sizeof(char));
+ strcpy(new_vn->_data._name,vn->_data._name);
+ }
+ new_vn->_data._value = vn->_data._value;
+ if (vn->_data._path != NULL) {
+ new_vn->_data._path = malloc(MAX_LENGTH_DIR_PATH*sizeof(char));
+ strcpy(new_vn->_data._path,vn->_data._path);
+ }
+ new_vn->_data._operation = vn->_data._operation;
+ new_vn->_priority = vn->_priority;
+
+ new_vn->_config._multi = new_vn->_config._multi;
+ // new_vn->_config._def = new_vn->_config._def; //cpy this?
+ if (vn->_config._default != NULL) {
+ new_vn->_config._default = malloc(MAX_LENGTH_DIR_PATH*sizeof(char));
+ strcpy(new_vn->_config._default,vn->_config._default);
+ }
+ if (vn->_config._path != NULL) {
+ new_vn->_config._path = malloc(MAX_LENGTH_DIR_PATH*sizeof(char));
+ strcpy(new_vn->_config._path,vn->_config._path);
+ }
+ return new_vn;
+}
+
+/**
+ *
+ **/
+void
+get_term_data_values(GNode *node)
+{
+ struct VyattaNode* vn = (struct VyattaNode*)node->data;
+ char full_new_data_path[MAX_LENGTH_DIR_PATH];
+ char full_active_data_path[MAX_LENGTH_DIR_PATH];
+ sprintf(full_active_data_path,"%s/%s",get_adirp(),vn->_data._path);
+ sprintf(full_new_data_path,"%s/%s",get_mdirp(),vn->_data._path);
+
+ GData *datalist;
+ g_datalist_init(&datalist);
+
+ //now check for value at this node and copy
+ char *cp = NULL;
+ //data_path needs to be of type vtw_path!!
+ vtw_path vpath;
+ //lstat for value file BEFORE retrievin
+ gchar **tok_str_new = NULL;
+ gchar **tok_str_active = NULL;
+
+ //create full_data_path here
+
+ init_path(&vpath, full_active_data_path);
+ if (value_exists(full_active_data_path) && get_value(&cp, &vpath) == 0) {
+ tok_str_active = g_strsplit(cp,"\n",0);
+ }
+
+
+ init_path(&vpath, full_new_data_path);
+ if (value_exists(full_new_data_path) && get_value(&cp, &vpath) == 0) {
+ tok_str_new = g_strsplit(cp,"\n",0);
+ }
+
+ if (vn->_config._multi == TRUE) {
+ //add active elements
+ int i;
+ for (i = 0; tok_str_active != NULL && tok_str_active[i] != NULL; ++i) {
+ struct ValueData *data;
+ data = (struct ValueData*)calloc(1, sizeof(struct ValueData));
+ //HANDLE EMPTY NEW CONFIG
+ data->_state = K_DEL_OP;
+ g_datalist_set_data(&datalist, tok_str_active[i], data);
+ }
+
+ //add value elements not found in set yet
+ for (i = 0; tok_str_new != NULL && tok_str_new[i] != NULL; ++i) {
+ gpointer g;
+ if ((g = g_datalist_get_data(&datalist,tok_str_new[i])) == NULL) {
+ struct ValueData *data;
+ data = (struct ValueData*)calloc(1, sizeof(struct ValueData));
+ data->_state = K_CREATE_OP;
+ g_datalist_set_data(&datalist, tok_str_new[i], data);
+ }
+ else {
+ ((struct ValueData*)g)->_state = K_NO_OP;
+ }
+ }
+ }
+ else { //leaf
+ struct ValueData *data;
+ data = (struct ValueData*)calloc(1, sizeof(struct ValueData));
+ if ((tok_str_active == NULL || tok_str_active[0] == NULL) &&
+ (tok_str_new == NULL || tok_str_new[0] == NULL)) {
+ // data->_state = K_NO_OP;
+ // g_datalist_set_data(&datalist, tok_str_active[0], data);
+ }
+ else if (tok_str_active == NULL || tok_str_active[0] == NULL) {
+ data->_state = K_CREATE_OP;
+ g_datalist_set_data(&datalist, tok_str_new[0], data);
+ }
+ else if (tok_str_new == NULL || tok_str_new[0] == NULL) {
+ data->_state = K_DEL_OP;
+ g_datalist_set_data(&datalist, tok_str_active[0], data);
+ }
+ else {
+ if (strcmp(tok_str_active[0],tok_str_new[0]) != 0) {
+ data->_state = K_SET_OP;
+ g_datalist_set_data(&datalist, tok_str_new[0], data);
+ }
+ else {
+ data->_state = K_NO_OP;
+ g_datalist_set_data(&datalist, tok_str_new[0], data);
+ }
+ }
+ }
+
+ //now let's process the node's values....
+
+ g_datalist_foreach(&datalist, dlist_test_func, node);
+ struct VyattaNode *vn_parent = (struct VyattaNode*)node->data;
+ memset(&vn_parent->_config._def, 0, sizeof(vtw_def));
+
+ g_strfreev(tok_str_new);
+ g_strfreev(tok_str_active);
+
+ // g_dataset_destroy(&datalist);
+
+ return;
+}
+
+/**
+ *
+ **/
+void
+dlist_test_func(GQuark key_id,gpointer data,gpointer user_data)
+{
+ if (key_id == 0) {
+ return;
+ }
+ GNode *node = (GNode*)user_data;
+ struct VyattaNode *vn = (struct VyattaNode*)node->children->data;
+ struct VyattaNode *vn_parent = (struct VyattaNode*)node->data;
+ struct VyattaNode *new_vn = NULL;
+ //single entry has alread been created.
+
+
+ if (vn->_data._value == TRUE) {
+ new_vn = copy_vyatta_node(vn);
+ GNode *new_node = g_node_new(new_vn);
+ //g_node_insert(node, -1, new_node);
+ insert_sibling_in_order(node,new_node);
+ new_vn->_config._def = vn->_config._def;
+ // strcat(new_vn->_data._path,"/value");
+ }
+ else {
+ new_vn = vn;
+ strcat(new_vn->_data._path,"/value");
+ }
+ new_vn->_data._value = TRUE;
+ strcpy(new_vn->_data._name,(char*)g_quark_to_string(key_id));
+ new_vn->_config._path = malloc(MAX_LENGTH_DIR_PATH*sizeof(char));
+ sprintf(new_vn->_config._path,"%s/node.tag",vn_parent->_config._path);
+ new_vn->_data._operation = ((struct ValueData*)data)->_state;
+ new_vn->_config._def = vn_parent->_config._def;
+}
+
+/**
+ *
+ **/
+void
+piecewise_remove(char* cbuf_root, char* abuf_root, char* path, boolean test_mode)
+{
+ char cbuf[MAX_LENGTH_DIR_PATH];
+ char abuf[MAX_LENGTH_DIR_PATH];
+
+ sprintf(cbuf,"%s/%s",cbuf_root,path);
+ sprintf(abuf,"%s/%s",abuf_root,path);
+
+ //iterate over directory here
+ DIR *dp;
+ if ((dp = opendir(cbuf)) == NULL){
+ if (g_debug) {
+ //could also be a terminating value now
+ printf("piecewise_remove(), failed to open directory: %s\n", cbuf);
+ }
+
+ //if failed, then check if this is a whiteout directory itself, if so remove and return
+ //only can really happen on initial call
+ char tmp[MAX_LENGTH_DIR_PATH];
+ sprintf(tmp,"%s/%s%s",cbuf_root,DELETED_NODE,path+1); //need to skip first slash
+ tmp[strlen(tmp)-1] = '\0'; //drop last slash too
+ struct stat s;
+ if ((lstat(tmp,&s) == 0) && S_ISREG(s.st_mode)) {
+ //whiteout root, remove and return
+ static const char format5[]="rm -fr %s >&/dev/null ; /bin/true"; /*adirp*/
+ //remove these guys
+ char command[MAX_LENGTH_DIR_PATH];
+ sprintf(command, format5, abuf);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+ }
+ return;
+ }
+
+ //finally iterate over valid child directory entries
+ struct dirent *dirp = NULL;
+ char local_path[MAX_LENGTH_DIR_PATH];
+ while ((dirp = readdir(dp)) != NULL) {
+
+ // printf("F: comparing: %s to %s up to %d\n",DELETED_NODE, dirp->d_name, strlen(DELETED_NODE));
+ if (strncmp(DELETED_NODE,dirp->d_name,strlen(DELETED_NODE)) == 0) {
+ static const char format5[]="rm -fr %s >&/dev/null ; /bin/true"; /*adirp*/
+ //remove these guys
+ char command[MAX_LENGTH_DIR_PATH];
+ char tmp[MAX_LENGTH_DIR_PATH];
+ sprintf(tmp,"%s/%s",abuf,dirp->d_name+strlen(DELETED_NODE));
+
+ sprintf(command, format5, tmp);
+ if (g_debug) {
+ printf("%s\n",command);
+ fflush(NULL);
+ }
+ if (test_mode == FALSE) {
+ system(command);
+ }
+ }
+ else if (strcmp(dirp->d_name, ".") != 0 &&
+ strcmp(dirp->d_name, "..") != 0 &&
+ strcmp(dirp->d_name, MODIFIED_FILE) != 0 &&
+ strcmp(dirp->d_name, DEF_FILE) != 0 &&
+ strcmp(dirp->d_name, VALUE_FILE) != 0) {
+ sprintf(local_path,"%s/%s",path,dirp->d_name);
+ piecewise_remove(cbuf_root,abuf_root,local_path,test_mode);
+ }
+ }
+ closedir(dp);
+}
+
+/**
+ *
+ **/
+GNode*
+insert_sibling_in_order(GNode *parent, GNode *child)
+{
+ //find alphabetical order to insert child into sibling
+ GNode *sibling = parent->children;
+ while (sibling != NULL) {
+ if (strcmp((((struct VyattaNode*)(child->data))->_data._name),((struct VyattaNode*)(sibling->data))->_data._name) > 0) {
+ break;
+ }
+ sibling = sibling->next;
+ }
+ GNode *new_node = g_node_insert_after(parent, sibling, child);
+ return new_node;
+}
diff --git a/src/common/unionfs.h b/src/common/unionfs.h
new file mode 100644
index 0000000..098ac41
--- /dev/null
+++ b/src/common/unionfs.h
@@ -0,0 +1,49 @@
+#ifndef __UNIONFS_HH__
+#define __UNIONFS_HH__
+
+#include <glib-2.0/glib.h>
+#include <stdio.h>
+#include "defs.h"
+#include "../cli_val.h"
+#include "../cli_objects.h"
+
+/* names of VYATTA env vars */
+#define ENV_EDIT_LEVEL "VYATTA_EDIT_LEVEL"
+#define ENV_TEMPLATE_LEVEL "VYATTA_TEMPLATE_LEVEL"
+#define ENV_A_DIR "VYATTA_ACTIVE_CONFIGURATION_DIR"
+#define ENV_C_DIR "VYATTA_CHANGES_ONLY_DIR"
+#define ENV_M_DIR "VYATTA_TEMP_CONFIG_DIR"
+#define ENV_T_DIR "VYATTA_CONFIG_TEMPLATE"
+#define ENV_TMP_DIR "VYATTA_CONFIG_TMP"
+#define DEF_A_DIR "/opt/vyatta/config/active"
+#define DEF_T_DIR "/opt/vyatta/share/ofr/template"
+#define ENV_OLD_PS1 "VYATTA_OLD_PS1"
+#define NODE_PRIORITY_FILE "/opt/vyatta/share/vyatta-cfg/priority"
+
+#define NODE_TAG_FILE "node.tag"
+#define VALUE_FILE "node.val"
+#define MODIFIED_FILE ".modified"
+#define DEF_FILE "def"
+#define WHITEOUT_FILE ".wh.__dir_opaque"
+#define DELETED_NODE ".wh."
+
+#define MAX_LENGTH_DIR_PATH 1024
+#define MAX_LENGTH_HELP_STR 1024
+
+boolean
+value_exists(char *path);
+
+struct PriData {
+ unsigned long _pri;
+ gchar **_tok_str;
+};
+
+
+struct ValueData
+{
+ boolean _leaf;
+ NODE_OPERATION _state;
+};
+
+
+#endif //__UNIONFS_HH__
diff --git a/src/dump_session.c b/src/dump_session.c
new file mode 100644
index 0000000..d6b85cf
--- /dev/null
+++ b/src/dump_session.c
@@ -0,0 +1,166 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <glib-2.0/glib.h>
+#include "common/common.h"
+
+boolean g_debug = FALSE;
+boolean g_verbose = FALSE;
+
+static gboolean
+dump_func(GNode *node, gpointer data);
+
+extern GNode*
+common_get_local_session_data();
+
+/*
+NOTES: reverse: use the n-nary tree in commit2.c and only encapuslate data store. pass in func pointer for processing of commands below.
+
+also, the algorithm for collapsing the tree into a transaction list is:
+1) iterate through tree and mark all explicit transactions
+2) when done, prune the tree of all root explicit transactions
+3) Now iterate through remaining tree and remove each node and append to transaction list.
+
+
+ */
+
+/**
+ *
+ *
+ **/
+void
+usage()
+{
+ printf("dump_session\n");
+ printf("-d\t\tdebug mode\n");
+ printf("-v\t\tverbose mode\n");
+ printf("-h\t\thelp\n");
+}
+
+/**
+ *
+ *
+ **/
+int
+main(int argc, char** argv)
+{
+ int ch;
+ //grab inputs
+ while ((ch = getopt(argc, argv, "dvh")) != -1) {
+ switch (ch) {
+ case 'd':
+ g_debug = TRUE;
+ break;
+ case 'v':
+ g_verbose = TRUE;
+ break;
+ case 'h':
+ usage();
+ exit(0);
+ break;
+ default:
+ usage();
+ exit(0);
+ }
+ }
+
+ //get local session data plus configuration data
+ GNode *config_root_node = common_get_local_session_data();
+ if (config_root_node == NULL) {
+ exit(0);
+ }
+
+ printf("Starting dump\n");
+
+ //iterate over config_data and dump...
+ g_node_traverse(config_root_node,
+ G_PRE_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)dump_func,
+ (gpointer)NULL);
+
+ return 0;
+ }
+
+
+static gboolean
+dump_func(GNode *node, gpointer data)
+{
+ if (node != NULL) {
+ guint depth = g_node_depth(node);
+
+ gpointer gp = ((GNode*)node)->data;
+ if (((struct VyattaNode*)gp)->_data._name != NULL) {
+ int i;
+
+ if (IS_DELETE(((struct VyattaNode*)gp)->_data._operation)) {
+ printf("-");
+ }
+ else if (IS_CREATE(((struct VyattaNode*)gp)->_data._operation)) {
+ printf("+");
+ }
+ else if (IS_SET(((struct VyattaNode*)gp)->_data._operation)) {
+ printf(">");
+ }
+ else {
+ printf(" ");
+ }
+ for (i = 0; i < depth; ++i) {
+ printf(" ");
+ }
+ printf("%s (t: %d, p: %d)", ((struct VyattaNode*)gp)->_data._name,((struct VyattaNode*)gp)->_config._def.def_type,((struct VyattaNode*)gp)->_priority);
+ if (((struct VyattaNode*)gp)->_data._value == TRUE) {
+ printf(" [VALUE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._multi == TRUE) {
+ printf(" [MULTI]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[syntax_act].vtw_list_head &&
+ ((struct VyattaNode*)gp)->_config._def.actions[syntax_act].vtw_list_head->vtw_node_aux == 0) {
+ printf(" [SYNTAX]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[create_act].vtw_list_head) {
+ printf(" [CREATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[activate_act].vtw_list_head) {
+ printf(" [ACTIVATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[update_act].vtw_list_head) {
+ printf(" [UPDATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[delete_act].vtw_list_head) {
+ printf(" [DELETE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[syntax_act].vtw_list_head &&
+ ((struct VyattaNode*)gp)->_config._def.actions[syntax_act].vtw_list_head->vtw_node_aux == 1) {
+ printf(" [COMMIT]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[begin_act].vtw_list_head) {
+ printf(" [BEGIN]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[end_act].vtw_list_head) {
+ printf(" [END]");
+ }
+
+ if (g_verbose == TRUE) {
+ printf("\n");
+ for (i = 0; i < depth; ++i) {
+ printf(" ");
+ }
+ printf("%s\n",((struct VyattaNode*)gp)->_config._path);
+ for (i = 0; i < depth; ++i) {
+ printf(" ");
+ }
+ printf("%s\n",((struct VyattaNode*)gp)->_data._path);
+ }
+
+ if (((struct VyattaNode*)gp)->_config._help != NULL) {
+ // printf("[help: %s]",((struct VyattaNode*)gp)->_config._help);
+ }
+ printf("\n");
+ }
+
+ }
+ return FALSE;
+}
diff --git a/src/exe_action.c b/src/exe_action.c
new file mode 100644
index 0000000..200ec2d
--- /dev/null
+++ b/src/exe_action.c
@@ -0,0 +1,122 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <glib-2.0/glib.h>
+#include "common/common.h"
+
+boolean g_debug = FALSE;
+
+/**
+ *
+ *
+ **/
+void
+usage()
+{
+ printf("exe_action\n");
+ printf("-p\t\trelative path to node.def\n");
+ printf("-a\t\taction (integer value)\n");
+ printf("-d\t\tdebug mode\n");
+ printf("-h\t\thelp\n");
+}
+
+
+/**
+ *
+ **/
+const char* get_tmpp(void) {
+
+ const char* tmpp=getenv(ENV_T_DIR);
+
+ if(!tmpp)
+ tmpp="";
+
+ return tmpp;
+}
+
+
+/**
+ *
+ *
+ **/
+int
+main(int argc, char** argv)
+{
+ int ch;
+ char *path = NULL;
+ unsigned long act = 0;
+
+ //grab inputs
+ while ((ch = getopt(argc, argv, "dhp:a:")) != -1) {
+ switch (ch) {
+ case 'd':
+ g_debug = TRUE;
+ break;
+ case 'h':
+ usage();
+ exit(0);
+ break;
+ case 'p':
+ path = optarg;
+ break;
+ case 'a':
+ act = strtoul(optarg,NULL,10);
+ break;
+ default:
+ usage();
+ exit(0);
+ }
+ }
+
+
+ vtw_def def;
+ struct stat s;
+ const char *root = get_tmpp();
+ char buf[2048];
+ sprintf(buf,"%s/%snode.def",root,path);
+ printf("%s\n",buf);
+ initialize_output();
+ init_paths(TRUE);
+
+ printf("[path: %s][act: %lu]\n",buf,act);
+
+ if ((lstat(buf,&s) == 0) && S_ISREG(s.st_mode)) {
+ memset(&def, 0, sizeof(def));
+ if (parse_def(&def,buf,FALSE) == 0) {
+ //execute
+ int status;
+ if (def.actions[act].vtw_list_head) {
+ set_in_commit(TRUE);
+
+ char foo[1024];
+ sprintf(foo,"b");
+ set_at_string(foo);
+
+ //BROKEN--NEEDS TO BE FIX BELOW FOR DPATH AND CPATH
+ common_set_context(path,path);
+
+ status = execute_list(def.actions[act].vtw_list_head,&def);
+ if (status == FALSE) {
+ printf("command failed! status: %d\n", status);
+ }
+ else {
+ printf("SUCCESS!\n");
+ }
+ set_in_commit(FALSE);
+ }
+ else {
+ printf("no action for this node\n");
+ }
+ }
+ else {
+ printf("failure to parse defination file\n");
+ }
+ }
+ else {
+ printf("node.def not found at: %s\n",buf);
+ }
+ return 0;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-14 16:26:20 +0000