src/eval_man/pdl.c

#include "pdl.h"

/* Lex/Yacc stuff */
extern FILE *               yyin;
extern unsigned int         lineno;
extern int                  yyparse(void);
extern int                  yylex(void);

/* Lex/Yacc cleanup functions */
extern void                 delete_lex_buffer(void);
#if HAVE_YYLEX_DESTROY
extern int                  yylex_destroy(void);
#endif

/* internal data */
static const char*          config_file_s; 
FILE*                       config_file_fp;
static char*                _pdl_path;

var_t*                      variables_list;
var_t*                      variables_list_last;
var_t*                      current_variable;

rule_t*                     rules_list;
rule_t*                     rules_list_last;
rule_t*                     current_rule;

policy_t*                   policies_list;
policy_t*                   policies_list_last;
policy_t*                   current_policy;

/*! initializes the parsing of the configuration file */
EES_RC pdl_init(const char* config_file_name){
  eef_plugindl_t* temp_plugin = NULL;
  config_file_s = config_file_name;

  if((config_file_fp = fopen(config_file_s,"r")) != NULL){
    yyin = config_file_fp;
    yyparse();
    /*print_policies();*/
    if(add_plugins() == EES_SUCCESS){
      /* this is a callout to the plugin manager, which calls dlopen(), dlsym() and the plugin's initialize function */
      if(initialize_plugins() == EES_SUCCESS){
        temp_plugin = build_plugin_tree(policies_list);
        print_plugin_tree_recursive(temp_plugin, 0);

        return EES_SUCCESS;
      } else {
        eef_log(LOG_ERR, "Failed to initialize plug-ins from policy config file %s\n", config_file_s);
      }
    } else {
      eef_log(LOG_ERR, "Failed to load plug-ins from policy config file %s\n", config_file_s);
    }
  } else {
    eef_log(LOG_ERR, "Failed to open policy config file %s", config_file_s);
  }
  return EES_FAILURE;
}

/* TODO fix this */
/* builds a tree of eef_plugindl_t structs, which hold pointers to initialized plugins retrieved from the plugin manager */
eef_plugindl_t* build_plugin_tree(policy_t* policies){
  policy_t        *temp_policy        = policies;
  eef_plugindl_t  *temp_plugin_rule   = NULL , *temp_plugin_rule_last = NULL, *plugin_tree  = NULL, *plugin_tree_last = NULL, *temp_plugin_node = NULL;
  rule_t          *temp_rule          = NULL;
  /*plugin_tree = calloc(1,sizeof(eef_plugindl_t));*/
  char**    argv;
  int       argc;

  while(temp_policy){
    temp_rule = temp_policy->rules;
    eef_log(LOG_DEBUG, "Policy: %s\n", temp_policy->name);
    while(temp_rule){
      argv = _var_to_argv(get_variable_by_name(temp_rule->state)->value, &argc);
      temp_plugin_node = get_plugin(argv[0]);
      free_args(argc, argv);
      if(temp_plugin_rule){
        temp_plugin_rule_last->next = temp_plugin_node;
      } else {
        temp_plugin_rule = temp_plugin_node;
      }
      temp_plugin_rule_last = temp_plugin_node;

      eef_log(LOG_DEBUG, "  | Rule %s\n", temp_rule->state);
      /*eef_log(LOG_DEBUG, "ARGV[0]: %s\n", argv[0]);*/
      eef_log(LOG_DEBUG, "  -------------------------\n");

      if(temp_plugin_rule_last){
        if(temp_rule->true_branch){
          eef_log(LOG_DEBUG, "   True branch:  %s\n", temp_rule->true_branch->state); 
          argv = _var_to_argv(get_variable_by_name(temp_rule->true_branch->state)->value, &argc);
          /*eef_log(LOG_DEBUG, "ARGV[0]: %s\n", argv[0]);*/
          temp_plugin_rule_last->true_branch = get_plugin(argv[0]);
          free_args(argc, argv);
        }

        if(temp_rule->false_branch){
          eef_log(LOG_DEBUG, "   False branch: %s\n", temp_rule->false_branch->state); 
          argv = _var_to_argv(get_variable_by_name(temp_rule->false_branch->state)->value, &argc);
          /*eef_log(LOG_DEBUG, "ARGV[0]: %s\n", argv[0]);*/
          temp_plugin_rule_last->false_branch = get_plugin(argv[0]);
          free_args(argc, argv);
        }
      }

      eef_log(LOG_DEBUG, "\n");

      /* iterate to next rule */
      temp_rule = temp_rule->next;
    } 

    /* iterate to next policy */
    temp_policy = temp_policy->next;

    /* append to the end of the list */
    if(plugin_tree){
      plugin_tree_last->next = temp_plugin_rule;
    } else {
      plugin_tree = temp_plugin_rule;
    }
    plugin_tree_last = temp_plugin_rule;

  }
  return plugin_tree;
}

void free_args(int argc, char** argv){
  for(; argc > 0; argc--){
    free(argv[argc-1]);
  }
  free(argv);
}

void print_plugin_tree_recursive(eef_plugindl_t* plugin_tree, int depth){
  int depth_cache;
  int num_policy = 1;

  while(plugin_tree){
    if(depth==0){
      printf("Policy %i\n", num_policy);
    }

    for(depth_cache = depth; depth_cache > 0; depth_cache--){
      printf("  ");
    }
    printf("| Rule %s\n", plugin_tree->pluginname);
    for(depth_cache = depth; depth_cache > 0; depth_cache--){
      printf("  ");
    }
    printf("-------------------------\n");
    if(plugin_tree->true_branch){
      printf("True: \n");
      print_plugin_tree_recursive(plugin_tree->true_branch, depth+1); 
    }
    if(plugin_tree->false_branch){
      printf("False: \n");
      print_plugin_tree_recursive(plugin_tree->false_branch, depth+1); 
    }
    printf("\n");

    if(depth==0){
      num_policy++;
      /* only iterate top level plugins as only they can be considered policies - that is, they have branches */
      if(plugin_tree->next){
        if(!plugin_tree->next->true_branch || !plugin_tree->next->false_branch){
          plugin_tree = NULL;
        } else {
          plugin_tree = plugin_tree->next;
        }
      }
    } else {
      /* prevent recursive printing of everything below top level plugins */
      plugin_tree = NULL;
    }
  }

}

/*! sets the path to modules directory */
void set_pdl_path(record_t* path){
  size_t path_size = 0;
  size_t string_size = (sizeof(char) * (strlen(path->string)+2)); /* size of string + extra slash + null byte */
  _pdl_path = "";

  /*struct stat sb;*/
  /*if stat(MODUL*/

  if(string_size < FILENAME_MAX){
    path_size = string_size;
  } else {
    path_size = FILENAME_MAX;
  }

  if((_pdl_path = calloc(1, path_size))){
    strncpy(_pdl_path, path->string, path_size);
                strncat(_pdl_path, "/", 1);
  }

  eef_log(LOG_DEBUG, "Found a new modules path: %s\n", _pdl_path);

  free(path->string);
  free(path);
}

/*! Handles a variable representing a plug-in; creates a structure containing its values and adds it to the list of var_t structs variables_list */
void add_variable(record_t* name, record_t* value){
  eef_log(LOG_DEBUG, "Added variable name: %s\n", name->string);
  eef_log(LOG_DEBUG, "Added variable value: %s\n", value->string);

  /* allocate struct and populate fields */
  if((current_variable = calloc(1,sizeof(var_t)))){
    current_variable->name = strdup(name->string);
    current_variable->value = strdup(value->string);
    current_variable->lineno = name->lineno;
    current_variable->next = NULL;
  } else {
    eef_log(LOG_ERR, "Out of memory!");
  }

  /* append to the end of the list */
  if(variables_list){
    variables_list_last->next = current_variable;
  } else {
    variables_list = current_variable;
  }
  variables_list_last = current_variable;

  /* clean up */
  free(name->string);
  free(name);
  free(value->string);
  free(value);
}

/* TODO I think this function is a bit of a kludge and could probably be rewritten to be more efficient and more legible - I think it might do too much, so extracting some functions might help */
/*! Appends a rule to the global rules_list, which is to be added to a policy when add_policy is called
 Will return an error when:
 - adding the rule to the list will create a recursion in the tree of rules
 - an unknown variable is referenced
*/
rule_t* add_rule(record_t* state, record_t* true_branch, record_t* false_branch){
  rule_t *new_rule = NULL, *new_false_branch = NULL, *new_true_branch = NULL, *recursive_rule = NULL;
  var_t  *temp_var = NULL;
  char *unknown_var_format_string = "Unknown variable %s at line %i in config file %s";

  if((new_rule = find_state(rules_list, state->string))){
    eef_log(LOG_WARNING, "State %s at line %i is already in use at line %i.\n", state->string, state->lineno, new_rule->lineno);
  } else {
    /*find variables for rule */
    temp_var = get_variable_by_name(state->string);
    if(temp_var == NULL){
      /* Errorous state - variable referenced in rule not previously defined */
      eef_log(LOG_ERR, unknown_var_format_string, state->string, state->lineno, config_file_s);
    }
    if(temp_var != NULL){
      if((new_rule = calloc(1, sizeof(rule_t)))){
        /* populate fields of current state */
        new_rule->state = strdup(state->string);
        new_rule->lineno = state->lineno;

        /* populate fields of branches */
        if(false_branch){
          temp_var = get_variable_by_name(false_branch->string);
          if(temp_var == NULL){
            /* Errorous state - variable referenced in rule not previously defined */
            eef_log(LOG_ERR, unknown_var_format_string, false_branch->string, false_branch->lineno, config_file_s);
            return NULL;
          }
          if((new_false_branch = calloc(1, sizeof(rule_t)))){
            new_false_branch->state = strdup(false_branch->string);
            new_false_branch->lineno = false_branch->lineno;
            new_rule->false_branch = new_false_branch;
          }
        }

        if(true_branch){
          temp_var = get_variable_by_name(true_branch->string);
          if(temp_var == NULL){
            /* Errorous state - variable referenced in rule not previously defined */
            eef_log(LOG_ERR, unknown_var_format_string, true_branch->string, true_branch->lineno, config_file_s);
            return NULL;
          }
          if((new_true_branch = calloc(1, sizeof(rule_t)))){
            new_true_branch->state = strdup(true_branch->string);
            new_true_branch->lineno = true_branch->lineno;
            new_rule->true_branch = new_true_branch;
          }
        }

        /* check for recursion */
        if((recursive_rule = check_for_recursion(rules_list, new_rule))){
          eef_log(LOG_WARNING, "Rule %s at line %i leads to recursion into state %s", new_rule->state, new_rule->lineno, recursive_rule->state);
        } else {
          /* add new rule at the end of the rules list */
          if(rules_list){
            rules_list_last->next = new_rule;
          } else {
            rules_list = new_rule;
          }
          rules_list_last = new_rule;
          /*eef_log(LOG_DEBUG, "Added a new rule: %s\n", new_rule->state);*/
        }

      } else {
        eef_log(LOG_ERR, "Out of memory!");
      }
    }
  }

  /* clean up */
  if(state != NULL){
    free(state->string);
    free(state);
  }
  if(true_branch != NULL){
    free(true_branch->string);
    free(true_branch);
  }
  if(false_branch != NULL){
    free(false_branch->string);
    free(false_branch);
  }

  return new_rule;
}

/* Tries to find a recursion in the list of rules by iterating through all the tree branches. When the same rule is encountered in the current list a recursion has been found */
rule_t* check_for_recursion(rule_t* rule_l, rule_t* rule_r){
  rule_t* temp_rule = rule_l;

  /* right hand rule leads to its own recursive state */
  /* still need to find a way to reuse the code from the while loop to do this check */
  if(rule_r){
    if(rule_r->true_branch){
      if(strcmp(rule_r->state, rule_r->true_branch->state) == 0){
        return rule_r->true_branch;
      }
    }

    if(rule_r->false_branch){
      if(strcmp(rule_r->state, rule_r->false_branch->state) == 0){
        return rule_r->false_branch;
      }
    }
  }

  /* iterate list of rules */
  while(temp_rule){
    if((temp_rule != NULL) && (rule_r != NULL)){
      /* left hand and right hand state are equal */
      if(strcmp(temp_rule->state, rule_r->state) == 0){
        return rule_r;
      }

      /* start state and true branch of right hand rule are equal */
      if(rule_r->true_branch){
        if(strcmp(temp_rule->state, rule_r->true_branch->state) == 0){
          return rule_r->true_branch;
        }
      }

      /* start state and false branch of right hand side are equal */
      if(rule_r->false_branch){
        if(strcmp(temp_rule->state, rule_r->false_branch->state) == 0){
          return rule_r->false_branch;
        }
      }
    }

    /* move to next rule */
    temp_rule = temp_rule->next;
  }
  return NULL;
}

/*! Tries to find specified state in the rules_list */
rule_t* find_state(rule_t* rule, const char* state){
  if(!rule || !state){
    return NULL;
  }

  /* iterate while the rule isn't associated with the given state */
  while(rule && strcmp(state, rule->state)){
    rule = rule->next;
  }
  return rule;
}

/*! Adds a new policy_t structure to the policies_list which will hold the current rules_list. rules_list is nulled after creating a policy so a new list can be created for the next policy */
void add_policy(record_t* policy, rule_t* top_rule){
  policy_t* new_policy = NULL;
  /*eef_log(LOG_DEBUG, "Found a new policy: %s\n", policy->string);*/

  if((new_policy = calloc(1, sizeof(policy_t)))){
    new_policy->name = strdup(policy->string);
    new_policy->lineno = policy->lineno;
    new_policy->rules = top_rule;
  }

  /* append to the end of the list */
  if(policies_list){
    policies_list_last->next = new_policy;
  } else {
    policies_list = new_policy;
  }
  policies_list_last = new_policy;

  rules_list = NULL;

  free(policy->string);
  free(policy);
}


void print_policies(){
  rule_t*   temp_rule = NULL;
  policy_t* temp_policy = policies_list;

  while(temp_policy){
    temp_rule = temp_policy->rules;
    eef_log(LOG_DEBUG, "Policy: %s\n", temp_policy->name);
    while(temp_rule){
      eef_log(LOG_DEBUG, "  | Rule %s\n", temp_rule->state);
      eef_log(LOG_DEBUG, "  -------------------------\n");
      if(temp_rule->true_branch){
        eef_log(LOG_DEBUG, "   True branch:  %s\n", temp_rule->true_branch->state); 
      }
      /*if(temp_rule->true_branch && temp_rule->false_branch){*/
      /*}*/
      if(temp_rule->false_branch){
        eef_log(LOG_DEBUG, "   False branch: %s\n", temp_rule->false_branch->state); 
      }
      eef_log(LOG_DEBUG, "\n");
      temp_rule = temp_rule->next;
    } 
    temp_policy = temp_policy->next;
  }
}

/*! concatenates two strings */
record_t* concat_strings(record_t* r1, record_t* r2){
  record_t* new_record;
  /*eef_log(LOG_DEBUG, "Concating: %s with %s\n", r1->string, r2->string);*/
  if((new_record = malloc(sizeof(record_t)))){
    if((new_record->string =
        calloc(1, sizeof(char)*(strlen(r1->string) + strlen(r2->string)+1)))){
      strncat(new_record->string, r1->string, strlen(r1->string));
      strncat(new_record->string, r2->string, strlen(r2->string));
      free(r1->string);
      free(r1);
      free(r2->string);
      free(r2);
      return new_record;
    }
  }
  return NULL;
}

/*! concatenates two strings with a space in between */
record_t* concat_strings_with_space(record_t *r1, record_t* r2){
  record_t *r;
  /*eef_log(LOG_DEBUG, "Concating: %s with %s with spaces\n", r1->string, r2->string);*/
  if((r = malloc(sizeof(record_t)))){
      r->string = calloc(1,(sizeof(char)*(strlen(r1->string)+strlen(r2->string)+2)));
      strncat(r->string, r1->string, strlen(r1->string));
      strncat(r->string, " ", 1);
      strncat(r->string, r2->string, strlen(r2->string));
      free(r1->string);
      free(r1);
      free(r2->string);
      free(r2);
    return r;
  }
  return NULL;
}

/*! logs errors encountered during parsing */
int yyerror(char* string){
  eef_log(LOG_ERR, "Parse error: %s at line %i in config file %s", string, lineno, config_file_s);
  return 0;
}

/*! get variable from list */
var_t* get_variable_by_name(char* name){
  for(current_variable = variables_list; current_variable != NULL; current_variable = current_variable->next){
    if(!strncmp(name, current_variable->name, strlen(current_variable->name))){
      return current_variable;
    }
  }
  return NULL;
}

/*TODO*/
/*! Removes a policy from the list of policies */
void remove_policy(record_t* policy){
  eef_log(LOG_DEBUG, "Deleted policy: %s\n", policy->string);
  free(policy->string);
  free(policy);
}

/*! converts a string to an array of strings by splitting it at each \t delimiter
  - overwrites the second argument with a pointer to the number of elements in the array */
char** _var_to_argv(char* value, int *argc){
  char *start_of_arg = NULL, *copy_of_value = NULL, **argv = NULL;
  char *delimiters = " \t";
  size_t size_of_arg = 0, size_of_array, i = 0;
  char *str_ptr;
  copy_of_value = strdup(value);
  size_of_array = (sizeof(char)*(strlen(copy_of_value)+1));
  if((argv = calloc(1, size_of_array)) != NULL){
    start_of_arg = strtok_r(copy_of_value, delimiters, &str_ptr);
    while(start_of_arg != NULL){
      size_of_arg = (sizeof(char)*(strlen(start_of_arg)+1));
      if((argv[i] = calloc(1, size_of_arg))){
        memcpy(argv[i], start_of_arg, size_of_arg);
        start_of_arg = strtok_r(NULL, delimiters, &str_ptr);
        i++;
      }
    }
  }
  free(copy_of_value);
  if(i < ARG_MAX){
    *argc = i;
  } else {
    *argc = ARG_MAX;
  }
  return argv;
}

/*! returns pdl path found in parsed config file */
const char* get_pdl_path(){
  return _pdl_path;
}

/*! Iterates list of policies and the rules they contain and tries to add the specified plug-ins to the plugin manager */
EES_RC add_plugins(){
  char**    argv;
  int       argc;
  EES_RC    plugin_initialized_ok = EES_SUCCESS;
  /*policy_t *temp_policy = policies_list, *last_policy = NULL;*/
  /*rule_t   *temp_rule = NULL;*/
  var_t    *temp_var = variables_list;

  while((temp_var != NULL) && (plugin_initialized_ok == EES_SUCCESS)){
    /*printf("Var: %s\n", temp_var->name);*/
    /*printf("Plug-in: %s\n", temp_var->value);*/
    argv = _var_to_argv(temp_var->value, &argc);

    /* this is a callout to the plug-in manager, which adds a single plug-in to its list */
    plugin_initialized_ok = add_plugin(argc, argv);

    /* Move to next variable */
    temp_var = temp_var->next;
  }

  return plugin_initialized_ok;
}

/*! Iterates the list of var_t structures and tries to free them */
EES_RC clean_variables_list(){
  current_variable = variables_list;
  while(current_variable){
    free(current_variable->name);
    free(current_variable->value);

    /* Move to next variable */
    variables_list_last = current_variable;
    current_variable = current_variable->next;

    /* Clean last variable struct */
    free(variables_list_last);
  } 
  return EES_SUCCESS;
}

/*! Iterates the list of rule_t structures starting with the passed rule and tries to free them and their true/false branches */
EES_RC clean_rules_list(rule_t* top_rule){
  rule_t* temp_rule = top_rule;
  rule_t* last_rule;
  while(temp_rule){
    /* Clean rules in true branch */
    if(temp_rule->true_branch){
      clean_rules_list(temp_rule->true_branch);
    }

    /* Clean rules in false branch */
    if(temp_rule->false_branch){
      clean_rules_list(temp_rule->false_branch);
    }

    /* Clean rule state */
    free(temp_rule->state);

    /* Move to next rule */
    last_rule = temp_rule;
    temp_rule = temp_rule->next;

    /* Clean rule struct */
    free(last_rule);
  } 
  return EES_SUCCESS;
}

/*! Iterates the list of policy_t structures and tries to free them and their rules */
EES_RC clean_policies_list(){
  policy_t *temp_policy = policies_list, *last_policy = NULL;
  while(temp_policy){
    /* Clean policy fields */
    clean_rules_list(temp_policy->rules);
    free(temp_policy->name);

    /* Move to next policy */
    last_policy = temp_policy;
    temp_policy = temp_policy->next;
    free(last_policy);
  }
  return EES_SUCCESS;
}

/*! Terminates the parser and tries to free all used memory */
EES_RC pdl_term(){
  clean_variables_list();
  clean_policies_list();
  free(_pdl_path);

  if(config_file_fp != NULL){
    /* This is the preferred way of cleaning up various flex versions - See: http://flex.sourceforge.net/manual/Memory-leak-_002d-16386-bytes-allocated-by-malloc_002e.html#Memory-leak-_002d-16386-bytes-allocated-by-malloc_002e */
    #if HAVE_YYLEX_DESTROY /* macro set by configure script */
      yylex_destroy();
    #else
      /*eef_log(LOG_WARNING, "Lex function yylex_destroy() not available - possibly unable to free allocated memory for evaluation manager\n");*/
      #if HAVE_FLEX
        delete_lex_buffer(); /* this function is defined in pdl_lex.l */
        /*eef_log(LOG_INFO, "Managed to free allocated memory for evaluation manager\n"); */
      #else
        eef_log(LOG_WARNING, "Lex functions yylex_destroy() and yy_delete_buffer() are both not available - unable to free allocated memory for evaluation manager\n");
      #endif
    #endif

    if((fclose(config_file_fp)==0) ){
      return EES_SUCCESS;
    }
  }
  return EES_FAILURE;
}

/*! TODO */
EES_RC allow_rules(int val){
  /*printf("Allowed rules: %i\n", val);*/
  return EES_SUCCESS;
}

/*! TODO */
EES_RC allowed_policy_rule(const char* label){
  /*printf("Allowed policy rule: %s\n", label);*/
  return EES_SUCCESS;  
}
grid.support@nikhef.nl	ViewVC Help
Powered by ViewVC 1.1.28