summaryrefslogtreecommitdiff
path: root/src/commit2.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/commit2.cpp')
-rw-r--r--src/commit2.cpp1706
1 files changed, 1706 insertions, 0 deletions
diff --git a/src/commit2.cpp b/src/commit2.cpp
new file mode 100644
index 0000000..b0a57f4
--- /dev/null
+++ b/src/commit2.cpp
@@ -0,0 +1,1706 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <syslog.h>
+#include <string.h>
+#include <sys/time.h>
+#include <glib-2.0/glib.h>
+#include "common/common.h"
+#include "cli_path_utils.h"
+
+boolean g_debug = FALSE;
+boolean g_display_error_node = FALSE;
+boolean g_coverage = FALSE;
+boolean g_dump_trans = FALSE;
+boolean g_dump_actions = FALSE;
+boolean g_print_error_location_all = FALSE;
+boolean g_old_print_output = FALSE;
+
+#define g_num_actions 5
+
+extern "C" void g_type_init();
+
+const int ActionOrder[g_num_actions] = {
+ // 4, //syntax
+ // 5, //commit
+ 6,
+ 0,
+ 1,
+ // 2, //activate
+ 3,
+ 7
+};
+
+
+static const char* ActionNames[top_act] = {
+ "delete", //0
+ "create", //1
+ "activate", //2
+ "update", //3
+ "syntax", //4
+ "commit", //5
+ "begin", //6
+ "end" //7
+};
+
+GNode*
+get_transactions(GNode*, boolean priority);
+
+boolean
+complete(GSList *node_coll, boolean test_mode);
+
+gboolean
+sort_func(GNode *node, gpointer data, boolean priority_mode);
+
+gboolean
+sort_func_priority(GNode *node, gpointer data);
+
+gboolean
+sort_func_priority_extended(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);
+
+void
+execute_hook(const char* dir, const char* comment);
+
+static gboolean
+enclosing_process_func(GNode *node, gpointer data);
+
+static gboolean
+validate_func(GNode *node, gpointer data);
+
+static boolean
+validate_configuration(GNode *root_node, boolean mode,
+ GSList **nodes_visited_coll);
+
+static void
+update_change_file(FILE *fp, GSList *coll);
+
+static gboolean
+execute_hook_compare_func(gconstpointer a, gconstpointer b, gpointer data);
+
+static gboolean
+execute_hook_func(GNode *node, gpointer data);
+
+char*
+process_script_path(char* in);
+
+/*
+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(void)
+{
+ printf("commit2\n");
+ printf("\t-d\t\tdebug mode\n");
+ printf("\t-s\t\tdump sorted transactions and exit\n");
+ printf("\t-a\t\tdump ordered node actions and exit\n");
+ printf("\t-p\t\tdisable priority mode\n");
+ printf("\t-t\t\ttest mode (don't apply directory modifications)\n");
+ printf("\t-e\t\tprint node where error occurred\n");
+ printf("\t-c\t\tdump node coverage and execution times\n");
+ printf("\t-o\t\tdisable partial commit\n");
+ printf("\t-f\t\tfull iteration over configuration on commit check\n");
+ printf("\t-b [priority]\tbreak at priority node (debug mode)\n");
+ printf("\t-r\t\tdisable run hook script on finishing commit\n");
+ printf("\t-x\t\tdisable new print feature\n");
+ printf("\t-l\t\tforce commit through removal of commit lock\n");
+ printf("\t-h\t\thelp\n");
+}
+
+/**
+ *
+ *
+ **/
+int
+main(int argc, char** argv)
+{
+ int ch;
+ boolean priority_mode = TRUE;
+ boolean test_mode = FALSE;
+ boolean disable_partial_commit = FALSE;
+ boolean full_commit_check = FALSE;
+ boolean break_priority = FALSE;
+ int break_priority_node = -1;
+ boolean disable_hook = FALSE;
+ char *commit_comment = NULL;
+
+ /* this is needed before calling certain glib functions */
+ g_type_init();
+
+ //grab inputs
+ while ((ch = getopt(argc, argv, "xdpthsecoafb:rlC:")) != -1) {
+ switch (ch) {
+ case 'x':
+ g_old_print_output = TRUE;
+ break;
+ 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':
+ g_dump_trans = TRUE;
+ break;
+ case 'e':
+ g_display_error_node = TRUE;
+ break;
+ case 'c':
+ g_coverage = TRUE;
+ break;
+ case 'o':
+ disable_partial_commit = TRUE;
+ break;
+ case 'a':
+ g_dump_actions = TRUE;
+ break;
+ case 'f':
+ full_commit_check = TRUE;
+ break;
+ case 'b':
+ break_priority_node = strtoul(optarg,NULL,10);
+ break_priority = TRUE;
+ break;
+ case 'r':
+ disable_hook = TRUE;
+ break;
+ case 'C':
+ commit_comment = strdup(optarg);
+ break;
+ case 'l':
+ release_config_lock();
+ break;
+ default:
+ usage();
+ exit(0);
+ }
+ }
+
+ //can also be set via environment variable
+ if (getenv("VYATTA_OUTPUT_ERROR_LOCATION") != NULL) {
+ g_print_error_location_all = TRUE;
+ }
+
+
+ if (disable_hook == FALSE) {
+ execute_hook(PRE_COMMIT_HOOK_DIR,commit_comment);
+ }
+
+ initialize_output("Commit");
+ init_paths(TRUE);
+ if (g_debug) {
+ printf("commit2: starting up\n");
+ syslog(LOG_DEBUG,"commit2: starting up");
+ }
+
+ if (get_config_lock() != 0) {
+ fprintf(out_stream,"Configuration system temporarily locked due to another commit in progress\n");
+ exit(1);
+ }
+
+
+ //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(NULL, test_mode);
+ fprintf(out_stream, "No configuration changes to commit\n");
+ return 0;
+ }
+
+ GNode *orig_node_tree = g_node_copy(config_data);
+
+ // 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 (g_debug == TRUE || g_dump_trans == TRUE) {
+ if (g_dump_trans == TRUE) {
+ fprintf(out_stream,"Dumping transactions\n");
+ syslog(LOG_DEBUG,"Dumping transactions");
+ }
+ //iterate over config_data and dump...
+ g_node_traverse(trans_coll,
+ G_PRE_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)dump_func,
+ (gpointer)NULL);
+ if (g_dump_trans == TRUE) {
+ exit(0);
+ }
+ }
+
+ set_in_commit(TRUE);
+
+ 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);
+ }
+
+ //open the changes file and clear
+ FILE *fp_changes = fopen(COMMIT_CHANGES_FILE,"w");
+ if (fp_changes == NULL) {
+ printf("commit2: Cannot access changes file, exiting\n");
+ syslog(LOG_ERR,"commit2: Cannot access changes file, exiting");
+ exit(0);
+ }
+
+ GSList *completed_root_node_coll = NULL;
+ GSList *nodes_visited_coll = NULL;
+ int errors = 0;
+ int i = 0;
+ do {
+ boolean success = FALSE;
+ if (g_debug == TRUE) {
+ if (trans_child_node != NULL && trans_child_node->data != NULL && ((struct VyattaNode*)(trans_child_node->data))->_data._name != NULL) {
+ printf("commit2: Starting new transaction processing pass on root: %s\n", ((struct VyattaNode*)(trans_child_node->data))->_data._name);
+ syslog(LOG_DEBUG,"commit2: Starting new transaction processing pass on root: %s", ((struct VyattaNode*)(trans_child_node->data))->_data._name);
+ }
+ else {
+ printf("commit2: Starting new transaction processing pass on root:\n");
+ syslog(LOG_DEBUG,"commit2: Starting new transaction processing pass on root:");
+ }
+ }
+
+ if (break_priority) {
+ gpointer gp = ((GNode*)trans_child_node)->data;
+ long p = (long) ((struct VyattaNode*)gp)->_config._priority;
+ if (p >= break_priority_node) {
+ g_dump_trans = TRUE;
+ g_node_traverse(trans_child_node,
+ G_PRE_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)dump_func,
+ (gpointer)NULL);
+ g_dump_trans = FALSE;
+ fprintf(out_stream,"Press any key to commit...\n");
+
+ // Wait for single character
+ char input = getchar();
+ input = input; //to fix stupid compilier warning
+ }
+ }
+
+ //complete() now requires a undisturbed copy of the trans_child_node tree
+ GNode *comp_cp_node = g_node_copy(trans_child_node);
+
+ if (g_dump_actions == TRUE) {
+ fprintf(out_stream,"\n"); //add an extra line here
+ }
+
+ //on each priority node now execute actions
+
+ nodes_visited_coll = NULL;
+ if ((validate_configuration(trans_child_node, full_commit_check, &nodes_visited_coll) == TRUE) && (success = process_priority_node(trans_child_node)) == TRUE) {
+ //this below copies the node directory from the local to active location
+ //if this is true root skip
+ if (trans_child_node != NULL && trans_child_node->data != NULL && strcmp(((struct VyattaNode*)(trans_child_node->data))->_data._path,"/") == 0) {
+ //no op, need better way to define true root
+ }
+ else {
+ if (disable_partial_commit == FALSE && g_dump_actions == FALSE) {
+ // complete(comp_cp_node, test_mode);
+ completed_root_node_coll = g_slist_append(completed_root_node_coll,comp_cp_node);
+ }
+ }
+ }
+
+ if (g_dump_actions == TRUE) {
+ success = TRUE; //FORCE SUCCESS ON DISPLAY MODE OF ACTIONS
+ }
+
+ if (success == FALSE) {
+ errors |= 1;
+ if (g_debug == TRUE) {
+ printf("commit2: Failed in processing node\n");
+ syslog(LOG_DEBUG,"commit2: Failed in processing node\n");
+ }
+ }
+ else {
+ errors |= 2;
+ }
+
+ //now update the changes file
+ update_change_file(fp_changes,nodes_visited_coll);
+ fflush(fp_changes);
+
+ ++i;
+ } while ((trans_child_node = (GNode*)g_node_nth_child((GNode*)trans_coll,(guint)i)) != NULL);
+
+ if (errors == 2) {
+ // if (disable_partial_commit == TRUE && g_dump_actions == FALSE) {
+ // completed_root_node_coll = g_slist_append(completed_root_node_coll,orig_node_tree);
+ // }
+ /*
+ * Need to add to the following func below to clean up dangling .wh. files
+ */
+ if (g_dump_actions == FALSE) {
+ // complete(orig_node_tree, test_mode);
+ common_commit_copy_to_live_config(orig_node_tree, TRUE, test_mode);
+ common_commit_clean_temp_config(orig_node_tree, test_mode);
+ }
+ if (g_debug == TRUE) {
+ printf("commit2: successful commit, now cleaning up temp directories\n");
+ syslog(LOG_DEBUG,"commit2: successful commit, now cleaning up temp directories");
+ }
+ }
+ else {
+ fprintf(out_stream,"Commit failed\n");
+ complete(completed_root_node_coll, test_mode);
+ }
+
+ set_in_commit(FALSE);
+
+ // cleanup(config_data);
+ // cleanup(trans_child_node);
+
+ if (g_debug) {
+ printf("DONE\n");
+ syslog(LOG_DEBUG,"DONE");
+ }
+
+ if (fp_changes != NULL) {
+ fclose(fp_changes);
+ }
+
+ restore_output();
+ if (disable_hook == FALSE) {
+ if (errors == 2) {
+ setenv(ENV_COMMIT_STATUS,"SUCCESS",1);
+ }
+ else if (errors == 3) {
+ setenv(ENV_COMMIT_STATUS,"PARTIAL",1);
+ }
+ else {
+ setenv(ENV_COMMIT_STATUS,"FAILURE",1);
+ }
+ execute_hook(POST_COMMIT_HOOK_DIR,commit_comment);
+ unsetenv(ENV_COMMIT_STATUS);
+ }
+
+ //remove tmp changes file as all the work is now done
+ unlink(COMMIT_CHANGES_FILE);
+
+ exit (errors == 2 ? 0 : 1);
+}
+
+
+struct ExecuteHookData
+{
+ char *_dir;
+ char *_comment;
+};
+
+/**
+ *
+ *
+ **/
+void
+execute_hook(const char* dir, const char* comment)
+{
+ if (dir == NULL) {
+ return;
+ }
+
+ GPtrArray *gparray;
+ gparray = g_ptr_array_new();
+ DIR *dp;
+ if ((dp = opendir(dir)) == NULL){
+ if (g_debug) {
+ //could also be a terminating value now
+ printf("could not open hook directory\n");
+ syslog(LOG_DEBUG,"could not open hook directory");
+ }
+ return;
+ }
+
+ struct dirent *dirp = NULL;
+ while ((dirp = readdir(dp)) != NULL) {
+ if (strcmp(dirp->d_name, ".") != 0 &&
+ strcmp(dirp->d_name, "..") != 0) {
+
+ char *dirname = (char*)malloc(strlen(dirp->d_name)+1);
+ strcpy(dirname,dirp->d_name);
+ g_ptr_array_add (gparray, (gpointer) dirname);
+ }
+ }
+ //sort gparray here
+ g_ptr_array_sort(gparray,(GCompareFunc)execute_hook_compare_func);
+
+ struct ExecuteHookData ehd;
+ ehd._comment = (char*)comment;
+ ehd._dir = (char*)dir;
+
+ //now loop over gparray here
+ g_ptr_array_foreach(gparray,(GFunc)execute_hook_func,(gpointer)&ehd);
+
+ g_ptr_array_free (gparray, TRUE);
+ closedir(dp);
+}
+
+/**
+ *
+ *
+ **/
+gboolean
+execute_hook_compare_func(gconstpointer a, gconstpointer b, gpointer data)
+{
+ //just compare first two chars numerically
+ char* c_a = *(char**)a;
+ char* c_b = *(char**)b;
+ int i_a = strtoul(c_a,NULL,10);
+ int i_b = strtoul(c_b,NULL,10);
+ return (i_a >= i_b);
+}
+
+/**
+ *
+ *
+ **/
+gboolean
+execute_hook_func(GNode *node, gpointer data)
+{
+ const char *comment = ((struct ExecuteHookData*)data)->_comment;
+ char *dir = ((struct ExecuteHookData*)data)->_dir;
+ char *name = (char*)node;
+
+ if (name == NULL || dir == NULL) {
+ return FALSE;
+ }
+
+ char buf[MAX_LENGTH_DIR_PATH*sizeof(char)];
+ if (comment == NULL) {
+ comment="commit";
+ }
+
+ sprintf(buf,"%s/%s %s",dir,name, comment);
+ syslog(LOG_DEBUG,"Starting commit hook: %s",buf);
+
+ if (system(buf) == -1) {
+ syslog(LOG_WARNING,"Error on call to hook: %s", buf);
+ }
+ syslog(LOG_DEBUG,"Finished with commit hook: %s",buf);
+
+ //release directory name
+ free(name);
+
+ return FALSE;
+}
+
+
+/**
+ *
+ *
+ **/
+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;
+ struct Aux *a = &((struct VyattaNode*)gp)->_aux;
+ NODE_OPERATION op = d->_operation;
+
+ 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, disable state: %d\n",d->_name,result->_action,c->_def.def_type, op, d->_path,d->_disable_op);
+ syslog(LOG_DEBUG,"commit2::process_func(), calling process on : %s for action %d, type: %d, operation: %d, path: %s, disable state: %d",d->_name,result->_action,c->_def.def_type, op, d->_path,d->_disable_op);
+ }
+ else {
+ printf("commit2::process_func(), calling process on : [n/a] for action %d, operation: %d, path: %s, disable state: %d\n",result->_action, op, d->_path,d->_disable_op);
+ syslog(LOG_DEBUG,"commit2::process_func(), calling process on : [n/a] for action %d, operation: %d, path: %s, disable state: %d",result->_action, op, d->_path, d->_disable_op);
+ }
+ }
+
+ //FIRST LET'S COMPUTE THE DEACTIVATE->ACTIVATE OVERRIDE
+ if (d->_disable_op != K_NO_DISABLE_OP) {
+ if (IS_DELETE(op) && (d->_disable_op & K_ACTIVE_DISABLE_OP)) {
+ return FALSE; //if this was actively disabled and is being deleted do nothing.
+ }
+ else if ((d->_disable_op & K_LOCAL_DISABLE_OP) && (d->_disable_op & K_ACTIVE_DISABLE_OP)) {
+ //no state change: deactivated
+ return FALSE; //skip operation on node
+ }
+ else if (!(d->_disable_op & K_LOCAL_DISABLE_OP) && (d->_disable_op & K_ACTIVE_DISABLE_OP)) {
+ //node will be activated on commit
+ //LET'S SPOOF the operation... convert it to CREATE
+ op = K_CREATE_OP;
+ }
+ else if ((d->_disable_op & K_LOCAL_DISABLE_OP) && !(d->_disable_op & K_ACTIVE_DISABLE_OP)) {
+ //node will be deactivated on commit
+ //LET'S SPOOF the operation... convert it to DELETE
+ op = K_DEL_OP;
+ }
+ }
+ /*
+ 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(op) && !IS_ACTIVE(op) && (result->_action != delete_act && result->_action != create_act)) ||
+ (IS_CREATE(op) && !IS_ACTIVE(op) && (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_ACTIVE(op) && ((result->_action == begin_act) || (result->_action == end_act))) ||
+ (IS_DELETE(op) && ((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(op) && IS_ACTIVE(op) && result->_action == delete_act && d->_disable_op == K_NO_DISABLE_OP) { //only apply this when no disable operation is set
+ return FALSE;
+ }
+
+ //let's skip any multi-node that does not have have a value (an empty multi-node)
+ if (c->_multi && node->children == NULL) {
+ return FALSE;
+ }
+
+ //look at parent for multi tag
+ if (d->_value && d->_name) {
+ char *val = d->_name;
+ if (c->_def.tag) { //need to handle the embedded multinode as a special case--should be fixed!
+ val = (char*)clind_unescape(d->_name);
+ }
+ if (g_debug) {
+ printf("commit2::process_func(): @ value: %s\n",(char*)val);
+ syslog(LOG_DEBUG,"commit2::process_func(): @ value: %s",(char*)val);
+ }
+ set_at_string(val); //embedded multinode value
+ }
+ else {
+ if (g_debug) {
+ printf("commit2::process_func(): boolean value is: %d\n",d->_value);
+ syslog(LOG_DEBUG,"commit2::process_func(): boolean value is: %d",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);
+ syslog(LOG_DEBUG,"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");
+ syslog(LOG_DEBUG,"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]);
+ syslog(LOG_DEBUG,"Executing %s on this node\n", ActionNames[result->_action]);
+ }
+
+ if (g_coverage) {
+ struct timeval t;
+ gettimeofday(&t,NULL);
+ fprintf(out_stream,"[START] %lu:%lu, %s@%s",(unsigned long)t.tv_sec,(unsigned long)t.tv_usec,ActionNames[result->_action],d->_path);
+ }
+
+
+ if (result->_action == delete_act) {
+ set_in_delete_action(TRUE);
+ }
+
+ //set location env
+ setenv(ENV_DATA_PATH,d->_path,1);
+
+
+ if (a->_first && a->_last) {
+ setenv(ENV_SIBLING_POSITION,"FIRSTLAST",1);
+ }
+ else if (a->_first) {
+ setenv(ENV_SIBLING_POSITION,"FIRST",1);
+ }
+ else if (a->_last) {
+ setenv(ENV_SIBLING_POSITION,"LAST",1);
+ }
+
+ //do not set for promoted actions
+ if (!IS_ACTIVE(op)) {
+ if (IS_DELETE(op)) {
+ setenv(ENV_ACTION_NAME,ENV_ACTION_DELETE,1);
+ }
+ else {
+ setenv(ENV_ACTION_NAME,ENV_ACTION_SET,1);
+ }
+ }
+ else {
+ setenv(ENV_ACTION_NAME,ENV_ACTION_ACTIVE,1);
+ }
+
+ if (g_dump_actions == FALSE) {
+ //need to add g_print_error_location_all, and processed location
+ if (g_old_print_output == TRUE) {
+ status = execute_list(c->_def.actions[result->_action].vtw_list_head,&c->_def,NULL,g_print_error_location_all);
+ }
+ else {
+ char *p = process_script_path(d->_path);
+ status = execute_list(c->_def.actions[result->_action].vtw_list_head,&c->_def,p,g_print_error_location_all);
+ free(p);
+ }
+ // status = execute_list(c->_def.actions[result->_action].vtw_list_head,&c->_def,NULL,g_print_error_location_all);
+
+ /*
+ if (strlen(outbuf) > 0) {
+ if (strstr(outbuf,"_errloc_:[") != NULL) {
+ if (g_print_error_location_all == FALSE) { //EXECUTE_LIST RETURNS FALSE ON FAILURE....
+ fprintf(out_stream,"%s\n",outbuf+strlen("_errloc_:"));
+ }
+ else {
+ fprintf(out_stream,"%s\n",outbuf);
+ }
+ }
+ else {
+ //currently set to format option for GUI client.
+ if (p != NULL) {
+ if (g_print_error_location_all == FALSE) { //EXECUTE_LIST RETURNS FALSE ON FAILURE....
+ fprintf(out_stream,"[%s]\n%s\n",p,outbuf);
+ }
+ else {
+ fprintf(out_stream,"_errloc_:[%s]\n%s\n",p,outbuf);
+ }
+ }
+ }
+ }
+ */
+
+ }
+ else {
+ char buf[MAX_LENGTH_DIR_PATH*sizeof(char)];
+ sprintf(buf,"%s\t:\t%s",ActionNames[result->_action],d->_path);
+ if (c->_def.multi) { //need to handle the embedded multinode as a special case--should be fixed!
+ char *val = (char*)clind_unescape(d->_name);
+ strcat(buf,val);
+ free(val);
+ }
+ fprintf(out_stream,"%s\n",buf);
+ status = 1;
+ }
+ if (result->_action == delete_act) {
+ set_in_delete_action(FALSE);
+ }
+
+ unsetenv(ENV_ACTION_NAME);
+ unsetenv(ENV_SIBLING_POSITION);
+ unsetenv(ENV_DATA_PATH);
+
+ if (g_coverage) {
+ struct timeval t;
+ gettimeofday(&t,NULL);
+ fprintf(out_stream,"[END] %lu:%lu\n",t.tv_sec,t.tv_usec);
+ }
+
+ if (!status) { //EXECUTE_LIST RETURNS FALSE ON FAILURE....
+ syslog(LOG_ERR,"commit error for %s:[%s]\n",ActionNames[result->_action],d->_path);
+ if (g_display_error_node) {
+ fprintf(out_stream,"%s@_errloc_:[%s]\n",ActionNames[result->_action],d->_path);
+ }
+ result->_err_code = 1;
+ if (g_debug) {
+ printf("commit2::process_func(): FAILURE: status: %d\n",status);
+ syslog(LOG_DEBUG,"commit2::process_func(): FAILURE: status: %d",status);
+ }
+ return TRUE; //WILL STOP AT THIS POINT
+ }
+ }
+ }
+ return FALSE;
+}
+
+
+/**
+ *
+ **/
+char*
+process_script_path(char* in)
+{
+ if (in == NULL) {
+ return NULL;
+ }
+
+ //just need to convert slashes into spaces here
+ char path_buf[4096];
+ char tmp[4096];
+ char *ptr;
+ path_buf[0] = '\0';
+
+ strcpy(tmp,in);
+ ptr = (char*)tmp;
+ char *slash = strchr(tmp,'/');
+ if (slash == NULL) {
+ strcat(path_buf,in);
+ }
+ else {
+ do { //convert '/' to ' '
+ strncat(path_buf,ptr,slash - ptr);
+ strcat(path_buf," ");
+ ++slash;
+ ptr = slash;
+ } while ((slash = strchr(slash,'/')) != NULL);
+ }
+ char *p = clind_unescape(path_buf);
+
+ char tmp2[MAX_LENGTH_DIR_PATH*sizeof(char)];
+
+ strcpy(tmp2,p); //copy back
+ free(p);
+ if (strncmp(ptr,"value:",6) == 0) {
+ if (strlen(ptr)-6 > 0) {
+ strncat(tmp2,ptr+6,strlen(ptr)-6);
+ strcat(tmp2," ");
+ }
+ }
+ char *ret = (char *) malloc(strlen(tmp2)+1);
+ strcpy(ret,tmp2);
+ return ret;
+}
+
+
+
+
+/**
+ *
+ **/
+boolean
+complete(GSList *node_coll, boolean test_mode)
+{
+ GSList *l;
+ for (l = node_coll; l; l = g_slist_next (l)) {
+ gpointer gp = ((GNode*)l->data)->data;
+ if (g_debug) {
+ if (((struct VyattaNode*)gp)->_data._name != NULL) {
+ printf("commit2::complete():name: %s, path: %s\n",((struct VyattaNode*)gp)->_data._name,((struct VyattaNode*)gp)->_data._path);
+ syslog(LOG_DEBUG,"commit2::complete():name: %s, path: %s",((struct VyattaNode*)gp)->_data._name,((struct VyattaNode*)gp)->_data._path);
+ }
+ else {
+ printf("commit2::complete()\n");
+ syslog(LOG_DEBUG,"commit2::complete()");
+ }
+ }
+ //on transactional nodes only, note to avoid calling this if a headless root
+ common_commit_copy_to_live_config((GNode *) l->data, FALSE, 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_priority_extended(GNode *node, gpointer data)
+{
+ gpointer gp = ((GNode*)node)->data;
+ GNode *root_node = (GNode*)data;
+
+ //WILL STOP AT DEPTH OF 10 REFERENCES
+ //GET PARENT WORKING FIRST....
+
+ //change action state of node according to enclosing behavior
+ if (((struct VyattaNode*)gp)->_config._priority_extended != NULL) { //only if priority is specified.
+ GNode *new_node = g_node_copy(node);
+
+ //NOW, we need to figure out where this node belongs in the priority chain
+ if (strncmp(((struct VyattaNode*)gp)->_config._priority_extended,"PARENT",6) == 0) {
+ //needs to walk up parents until priority is found and insert there....
+
+ //walk up chain until priority is found.
+ GNode *n = node;
+ while (TRUE) {
+ n = n->parent;
+ if (n == NULL) {
+ break;
+ }
+ gpointer nd = ((GNode*)n)->data;
+ if (((struct VyattaNode*)nd)->_config._priority != LOWEST_PRIORITY) {
+ //means we are done--found anchor in parent
+ g_node_unlink(node);
+ if (IS_DELETE(((struct VyattaNode*)gp)->_data._operation)) {
+ g_node_insert_before(root_node,n,new_node);
+ }
+ else {
+ g_node_insert_after(root_node,n,new_node);
+ }
+ break;
+ }
+ /*
+ else if (((struct VyattaNode*)gp)->_config._priority_extended != NULL) {
+ //need to find references in other node tree....
+
+ //PARSE OUT EXTENDED REFERENCES...
+ for (int i = 0; i < ct; ++i) {
+ //get dependency...what to do with dependencies on dependencies... might get big. recursion buddy....
+ if (find_reference_anchor(orig_config, ((struct VyattaNode*)gp)->_config._priority_extended, cur_pri) != 0) {
+ cur_pri = LOWEST_PRIORITY;
+ }
+ }
+ break;
+ }
+ */
+ }
+ }
+ else {
+ /*
+ //multiple dependencies should be placed outside the earliest (delete) or latest (create) reference
+ if (find_reference_anchor(orig_config, ((struct VyattaNode*)gp)->_config._priority_extended, cur_pri) != 0) {
+ cur_pri = LOWEST_PRIORITY;
+ }
+ */
+ }
+ /*
+ //finds location for insertion
+ while (sibling != NULL && cur_pri > ((struct VyattaNode*)(sibling->data))->_config._priority * 10) {
+ sibling = sibling->next;
+ if (sibling == NULL || ((struct VyattaNode*)gp)->_config._priority < ((struct VyattaNode*)(sibling->data))->_config._priority) {
+ break;
+ }
+ }
+
+ //I think that's it then...
+ g_node_insert_before(root_node,sibling,new_node);
+ }
+ */
+ }
+ return 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));
+ syslog(LOG_DEBUG,"commit2::sort_func(): %s, node count: %d",((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));
+ syslog(LOG_DEBUG,"commit2::sort_func(): [n/a], node count: %d",g_node_n_children(root_node));
+ }
+ }
+
+ //FIRST LET'S COMPUTE THE DEACTIVATE->ACTIVATE OVERRIDE
+ struct Data *d = &((struct VyattaNode*)gp)->_data;
+ NODE_OPERATION op = d->_operation;
+ if (d->_disable_op != K_NO_DISABLE_OP) {
+ if (!(d->_disable_op & K_LOCAL_DISABLE_OP) && (d->_disable_op & K_ACTIVE_DISABLE_OP)) {
+ //node will be activated on commit
+ //LET'S SPOOF the operation... convert it to CREATE
+ op = K_CREATE_OP;
+ }
+ else if ((d->_disable_op & K_LOCAL_DISABLE_OP) && !(d->_disable_op & K_ACTIVE_DISABLE_OP)) {
+ //node will be deactivated on commit
+ //LET'S SPOOF the operation... convert it to DELETE
+ op = K_DEL_OP;
+ }
+ }
+
+ //change action state of node according to enclosing behavior
+ /* XXX this is ugly. originally the condition for the if is the following:
+ * (c1 && c2 || (c3 || c4) && c5)
+ *
+ * this causes compiler warning for mixing && and || without (). the
+ * previous warning removal attempt changed the condition to the
+ * following:
+ * ((c1 && c2) || (c3 || (c4 && c5)))
+ *
+ * which was incorrect (c3 and c4 should be at the same "level") and
+ * therefore was reverted.
+ *
+ * now changing the condition to the following to avoid compiler
+ * warning:
+ * ((c1 && c2) || ((c3 || c4) && c5))
+ *
+ * note that since the current goal is simply cleanup, no attempt is
+ * made to understand the logic here, and the change is purely based
+ * on operator precendence to maintain the original logic.
+ */
+ if (((/* c1 */ G_NODE_IS_ROOT(node) == FALSE)
+ && (/* c2 */ ((struct VyattaNode*)gp)->_data._disable_op
+ != K_NO_DISABLE_OP))
+ //added to support enclosing behavior of activated/deactivated
+ || (((/* c3 */ IS_SET_OR_CREATE(op)) || (/* c4 */ IS_DELETE(op)))
+ && (/* c5 */ 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) {
+ 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;
+ //DON'T set active when only in disable state...
+ // if (((struct VyattaNode*)(n->data))->_data._disable_op == K_NO_DISABLE_OP) {
+ if (((struct VyattaNode*)(n->data))->_data._operation == K_NO_OP) {
+ /* XXX this is ugly. _operation is intended to be a bitmap, in which
+ * case it doesn't make sense to make it an enum type (should
+ * just be, e.g., int). this causes g++ to (rightly) complain.
+ * work around it for now to avoid impacting other code since
+ * the current goal is simply cleanup.
+ */
+ int op = ((struct VyattaNode*)(n->data))->_data._operation;
+ op |= K_ACTIVE_OP;
+ ((struct VyattaNode*)(n->data))->_data._operation
+ = (NODE_OPERATION) op;
+ }
+ if (def.actions[end_act].vtw_list_head || def.actions[begin_act].vtw_list_head) {
+ break;
+ }
+ if (G_NODE_IS_ROOT(n) == TRUE) {
+ break;
+ }
+ }
+ }
+ }
+
+ if (priority_mode) {
+ if (((struct VyattaNode*)gp)->_config._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)->_config._priority > ((struct VyattaNode*)(sibling->data))->_config._priority) {
+ sibling = sibling->next;
+ if (sibling == NULL || ((struct VyattaNode*)gp)->_config._priority < ((struct VyattaNode*)(sibling->data))->_config._priority) {
+ break;
+ }
+ }
+
+ if (g_debug) {
+ int pri = LOWEST_PRIORITY;
+ if (sibling != NULL) {
+ pri = ((struct VyattaNode*)(sibling->data))->_config._priority;
+ }
+ printf("commit2::sort_func(): inserting %s into transaction, priority: %d BEFORE %d\n", ((struct VyattaNode*)gp)->_data._name, ((struct VyattaNode*)gp)->_config._priority, pri);
+ syslog(LOG_DEBUG,"commit2::sort_func(): inserting %s into transaction, priority: %d BEFORE %d\n", ((struct VyattaNode*)gp)->_data._name, ((struct VyattaNode*)gp)->_config._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);
+ syslog(LOG_DEBUG,"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");
+ syslog(LOG_DEBUG,"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
+ }
+
+ //now need pass to handle extended priority system
+ g_node_traverse(trans_root,
+ G_POST_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)sort_func_priority_extended,
+ (gpointer)trans_root);
+ }
+ 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)
+{
+ FILE *out;
+ if (g_dump_trans) {
+ out = out_stream;
+ }
+ else {
+ out = stdout;
+ }
+
+ if (node != NULL) {
+ guint depth = g_node_depth(node);
+
+ if (depth == 2) {
+ fprintf(out,"NEW TRANS\n");
+ }
+
+ gpointer gp = ((GNode*)node)->data;
+ if (((struct VyattaNode*)gp)->_data._name != NULL) {
+ unsigned int i;
+
+ char disable_op[2];
+ if (((struct VyattaNode*)gp)->_data._disable_op == (K_ACTIVE_DISABLE_OP | K_LOCAL_DISABLE_OP)) {
+ disable_op[0] = '!';
+ }
+ else if (((struct VyattaNode*)gp)->_data._disable_op == K_ACTIVE_DISABLE_OP) {
+ disable_op[0] = 'A';
+ }
+ else if (((struct VyattaNode*)gp)->_data._disable_op == K_LOCAL_DISABLE_OP) {
+ disable_op[0] = 'D';
+ }
+ else {
+ disable_op[0] = ' ';
+ }
+ disable_op[1] = '\0';
+
+ if (IS_ACTIVE(((struct VyattaNode*)gp)->_data._operation)) {
+ fprintf(out,"%s*",disable_op);
+ }
+ else if (IS_DELETE(((struct VyattaNode*)gp)->_data._operation)) {
+ fprintf(out,"%s-",disable_op);
+ }
+ else if (IS_CREATE(((struct VyattaNode*)gp)->_data._operation)) {
+ fprintf(out,"%s+",disable_op);
+ }
+ else if (IS_SET(((struct VyattaNode*)gp)->_data._operation)) {
+ fprintf(out,"%s>",disable_op);
+ }
+ else {
+ fprintf(out,"%s ",disable_op);
+ }
+
+ for (i = 0; i < depth; ++i) {
+ fprintf(out," ");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.def_type2 != ERROR_TYPE) {
+ fprintf(out,"%s (t: %d-%d, ", ((struct VyattaNode*)gp)->_data._name,((struct VyattaNode*)gp)->_config._def.def_type,((struct VyattaNode*)gp)->_config._def.def_type2);
+ }
+ else {
+ fprintf(out,"%s (t: %d, ", ((struct VyattaNode*)gp)->_data._name,((struct VyattaNode*)gp)->_config._def.def_type);
+ }
+ if (((struct VyattaNode*)gp)->_config._priority_extended != NULL) {
+ fprintf(out, "p: %s)",((struct VyattaNode*)gp)->_config._priority_extended);
+ }
+ else {
+ fprintf(out, "p: %d)",((struct VyattaNode*)gp)->_config._priority);
+ }
+
+ if (((struct VyattaNode*)gp)->_data._value == TRUE) {
+ fprintf(out," [VALUE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._multi == TRUE) {
+ fprintf(out," [MULTI(%d)]",((struct VyattaNode*)gp)->_config._limit);
+ }
+ 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) {
+ fprintf(out," [SYNTAX]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[create_act].vtw_list_head) {
+ fprintf(out," [CREATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[activate_act].vtw_list_head) {
+ fprintf(out," [ACTIVATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[update_act].vtw_list_head) {
+ fprintf(out," [UPDATE]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[delete_act].vtw_list_head) {
+ fprintf(out," [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) {
+ fprintf(out," [COMMIT]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[begin_act].vtw_list_head) {
+ fprintf(out," [BEGIN]");
+ }
+ if (((struct VyattaNode*)gp)->_config._def.actions[end_act].vtw_list_head) {
+ fprintf(out," [END]");
+ }
+ if (((struct VyattaNode*)gp)->_config._help != NULL) {
+ // fprintf(out,"[help: %s]",((struct VyattaNode*)gp)->_config._help);
+ }
+ fprintf(out,"\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 < g_num_actions; ++i) {
+ // now _this_ should be enum instead
+ GTraverseType order;
+ if (delete_act != ActionOrder[i]) {
+ order = G_PRE_ORDER;
+ }
+ else {
+ order = G_POST_ORDER;
+ }
+
+ result._action = ActionOrder[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);
+ syslog(LOG_DEBUG,"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);
+ syslog(LOG_DEBUG,"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 < g_num_actions; ++i) {
+ // again should be enum
+ GTraverseType order;
+ if (delete_act != ActionOrder[i]) {
+ order = G_PRE_ORDER;
+ }
+ else {
+ order = G_POST_ORDER;
+ }
+
+ result->_action = ActionOrder[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);
+ syslog(LOG_DEBUG,"commit2::enclosing_process_func(): FAILURE: status: %d\n",result->_err_code);
+ }
+ return TRUE; //WILL STOP AT THIS POINT
+ }
+ }
+ }
+ return FALSE;
+}
+
+
+
+/**
+ *
+ **/
+static boolean
+validate_configuration(GNode *root_node, boolean mode,
+ GSList **nodes_visited_coll)
+{
+ if (root_node == NULL) {
+ return FALSE;
+ }
+
+ struct Result result;
+ result._err_code = 0;
+ result._mode = (int)mode;
+ result._data = (void*)*nodes_visited_coll;
+
+ //handles both syntax and commit
+ result._action = syntax_act;
+ g_node_traverse((GNode*)root_node,
+ G_PRE_ORDER,
+ G_TRAVERSE_ALL,
+ -1,
+ (GNodeTraverseFunc)validate_func,
+ (gpointer)&result);
+
+ if (result._err_code != 0) {
+ if (g_debug) {
+ printf("commit2::process_priority_node(): failure on processing pass: %d\n", syntax_act);
+ syslog(LOG_DEBUG,"commit2::process_priority_node(): failure on processing pass: %d\n", syntax_act);
+ }
+ return FALSE;
+ }
+
+ GList **c_tmp = (GList**)result._data;
+ *nodes_visited_coll = (GSList*)c_tmp;
+ return TRUE;
+}
+
+
+/**
+ * Execute syntax and commit checks
+ *
+ **/
+static gboolean
+validate_func(GNode *node, gpointer data)
+{
+ if (node == NULL) {
+ return TRUE;
+ }
+
+ gpointer gp = ((GNode*)node)->data;
+ struct Config *c = &((struct VyattaNode*)gp)->_config;
+ struct Data *d = &((struct VyattaNode*)gp)->_data;
+ struct Aux *a = &((struct VyattaNode*)gp)->_aux;
+ struct Result *result = (struct Result*)data;
+
+
+
+
+ //let's mark first last nodes here for use later
+ //do first/last/only sibling check, restrict to nodes with operations defined
+ GNode *n_last_op = NULL;
+ GNode *n_first_op = NULL;
+
+ GNode *sib = g_node_first_sibling(node);
+ while (sib != NULL) {
+ if (IS_DELETE(((struct VyattaNode*)(sib->data))->_data._operation)) {
+ if (n_first_op == NULL) {
+ n_first_op = sib;
+ }
+ n_last_op = sib;
+ }
+ sib = sib->next;
+ }
+
+ sib = g_node_first_sibling(node);
+ while (sib != NULL) {
+ if (IS_SET_OR_CREATE(((struct VyattaNode*)(sib->data))->_data._operation)) {
+ if (n_first_op == NULL) {
+ n_first_op = sib;
+ }
+ n_last_op = sib;
+ }
+ sib = sib->next;
+ }
+
+ a->_first = (node == n_first_op);
+ a->_last = (node == n_last_op);
+
+
+ //since this visits all working nodes, let's maintain a set of nodes to commit
+ GSList *coll = (GSList*)result->_data;
+ if (d->_path != NULL) {
+
+ char buf[MAX_LENGTH_DIR_PATH*sizeof(char)];
+ if (IS_DELETE(d->_operation)) {
+ sprintf(buf,"- %s",d->_path);
+ if (c->_def.multi) { //need to handle the embedded multinode as a special case--should be fixed!
+ char *val = (char*)clind_unescape(d->_name);
+ strcat(buf,val);
+ free(val);
+ }
+ char *tmp = (char *) malloc(strlen(buf)+1);
+ strcpy(tmp,buf);
+ coll = g_slist_append(coll,tmp);
+ result->_data = (void*)coll;
+ }
+ else if (IS_SET_OR_CREATE(d->_operation)) {
+ sprintf(buf,"+ %s",d->_path);
+ if (c->_def.multi) { //need to handle the embedded multinode as a special case--should be fixed!
+ char *val = (char*)clind_unescape(d->_name);
+ strcat(buf,val);
+ free(val);
+ }
+
+ char *tmp = (char *) malloc(strlen(buf)+1);
+ strcpy(tmp,buf);
+ coll = g_slist_append(coll,tmp);
+ result->_data = (void*)coll;
+ }
+ }
+
+ //don't run syntax check on this node if it is unchanged.
+ if (IS_NOOP(d->_operation) && (c->_def.actions[syntax_act].vtw_list_head != NULL && c->_def.actions[syntax_act].vtw_list_head->vtw_node_aux == 0)) {
+ return FALSE;
+ }
+
+ //don't perform validation checks on disabled nodes
+ if ((d->_disable_op == K_LOCAL_DISABLE_OP) || (d->_disable_op == (K_LOCAL_DISABLE_OP | K_ACTIVE_DISABLE_OP))) {
+ return FALSE; //SHOULD only hit the case where the node is locally disabled or globally disabled and not in a transition to active state
+ }
+
+ if (IS_DELETE(d->_operation) && !IS_ACTIVE(d->_operation)) {
+ return FALSE; //will not perform validation checks on deleted nodes
+ }
+
+ if (!c->_def.actions ||
+ !c->_def.actions[result->_action].vtw_list_head){
+ return FALSE;
+ }
+
+ //will not call term multi if it is a noop--shouldn't show up in tree in the first place, but
+ //will require more rework of unionfs code to fix this.
+ if (c->_def.multi && IS_NOOP(d->_operation)) {
+ return FALSE;
+ }
+
+ //look at parent for multi tag
+ if (d->_value && d->_name) {
+ char *val = d->_name;
+ if (c->_def.tag) { //need to handle the embedded multinode as a special case--should be fixed!
+ val = (char*)clind_unescape(d->_name);
+ }
+ if (g_debug) {
+ printf("commit2::process_func(): @ value: %s\n",(char*)val);
+ syslog(LOG_DEBUG,"commit2::process_func(): @ value: %s",(char*)val);
+ }
+
+ set_at_string(val); //embedded multinode value
+ }
+ else {
+ if (g_debug) {
+ printf("commit2::process_func(): boolean value is: %d\n",d->_value);
+ syslog(LOG_DEBUG,"commit2::process_func(): boolean value is: %d",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);
+ syslog(LOG_DEBUG,"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");
+ syslog(LOG_DEBUG,"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]);
+ syslog(LOG_DEBUG,"Executing %s on this node\n", ActionNames[result->_action]);
+ }
+
+ if (g_coverage) {
+ struct timeval t;
+ gettimeofday(&t,NULL);
+ fprintf(out_stream,"[START] %lu:%lu, %s@%s",(unsigned long)t.tv_sec,(unsigned long)t.tv_usec,ActionNames[result->_action],d->_path);
+ }
+
+ boolean status = 1;
+ if (g_dump_actions == FALSE) {
+ //set location env
+ setenv(ENV_DATA_PATH,d->_path,1);
+ if (g_old_print_output == TRUE) {
+ status = execute_list(c->_def.actions[result->_action].vtw_list_head,&c->_def,NULL,g_print_error_location_all);
+ }
+ else {
+ char *p = process_script_path(d->_path);
+ status = execute_list(c->_def.actions[result->_action].vtw_list_head,&c->_def,p,g_print_error_location_all);
+ free(p);
+ }
+ unsetenv(ENV_DATA_PATH);
+ }
+ else {
+ char buf[MAX_LENGTH_DIR_PATH*sizeof(char)];
+ if (c->_def.actions[syntax_act].vtw_list_head) {
+ if (c->_def.actions[syntax_act].vtw_list_head->vtw_node_aux == 0) {
+ sprintf(buf,"syntax\t:\t%s",d->_path);
+ }
+ else {
+ sprintf(buf,"commit\t:\t%s",d->_path);
+ }
+ }
+ if (c->_def.multi) { //need to handle the embedded multinode as a special case--should be fixed!
+ char *val = (char*)clind_unescape(d->_name);
+ strcat(buf,val);
+ free(val);
+ }
+ fprintf(out_stream,"%s\n",buf);
+ status = 1;
+ }
+
+ if (g_coverage) {
+ struct timeval t;
+ gettimeofday(&t,NULL);
+ fprintf(out_stream,"[END] %lu:%lu\n",t.tv_sec,t.tv_usec);
+ }
+
+ if (!status) { //EXECUTE_LIST RETURNS FALSE ON FAILURE....
+ /*
+ char *p = process_script_path(d->_path);
+ if (p != NULL) {
+ if (strlen(outbuf) > 0) {
+ if (g_print_error_location_all == TRUE) {
+ fprintf(out_stream,"_errloc_:[%s]\n %s\n",p,outbuf);
+ }
+ else {
+ fprintf(out_stream,"[%s] \n %s\n",p,outbuf);
+ }
+ }
+ }
+ */
+ syslog(LOG_ERR,"commit error for %s:[%s]\n",ActionNames[result->_action],d->_path);
+ if (g_display_error_node) {
+ fprintf(out_stream,"%s@_errloc_:[%s]\n",ActionNames[result->_action],d->_path);
+ }
+ result->_err_code = 1;
+ if (g_debug) {
+ printf("commit2::validate_func(): FAILURE: status: %d\n",status);
+ syslog(LOG_DEBUG,"commit2::validate_func(): FAILURE: status: %d",status);
+ }
+ return result->_mode ? FALSE: TRUE; //WILL STOP AT THIS POINT if mode is not set for full syntax check
+ }
+ return FALSE;
+}
+
+/**
+ *
+ *
+ **/
+static void
+update_change_file(FILE *fp, GSList *coll)
+{
+ if (coll == NULL || fp == NULL) {
+ return;
+ }
+ GSList *l;
+ for (l = coll; l; l = g_slist_next (l)) {
+ if (l->data) {
+ char buf[MAX_LENGTH_DIR_PATH*sizeof(char)];
+ sprintf(buf,"%s\n",(char*)l->data);
+ fwrite(buf,1,strlen((char*)buf),fp);
+ free(l->data);
+ }
+ }
+ g_slist_free(coll);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-14 04:28:43 +0000