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){
config_file_s = config_file_name;

  if((config_file_fp = fopen(config_file_s,"r")) != NULL){
    yyin = config_file_fp;
    yyparse();
    if(add_prepared_plugins() == EES_SUCCESS){
      return EES_SUCCESS;
    } 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;
}

policy_t* get_policies(){
  return policies_list;
}

/*! 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);
  path->string = NULL;
  free(path);
  path = NULL;
}

/*! 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);
  name->string = NULL;
  free(name);
  name = NULL;
  free(value->string);
  value->string = NULL;
  free(value);
  value = NULL;
}

/* 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 = get_rule(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);
          new_rule = NULL;
        } 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;
}

void link_dead_end_rules_in_policy(policy_t* policy){
  policy_t* temp_policy = policy;
  while(temp_policy){
    link_dead_end_rules(temp_policy, temp_policy->rules);
    temp_policy = temp_policy->next;
  }
}

void link_dead_end_rules(policy_t* policy, rule_t* rule){
  rule_t *temp_rule = rule, *true_rule, *false_rule;
  while(temp_rule){
    if(temp_rule->true_branch){
      if((true_rule = get_rule(policy->rules, temp_rule->true_branch->state))){
        eef_log(LOG_DEBUG, "Overwriting rule %s with %s\n", temp_rule->true_branch->state, true_rule->state);
        clean_rules_list(temp_rule->true_branch);
        temp_rule->true_branch = true_rule;
      }
    }
    if(temp_rule->false_branch){
      if((false_rule = get_rule(policy->rules, temp_rule->false_branch->state))){
        eef_log(LOG_DEBUG, "Overwriting rule %s with %s\n", temp_rule->false_branch->state, false_rule->state);
        clean_rules_list(temp_rule->false_branch);
        temp_rule->false_branch = false_rule;
      }
    }
    temp_rule = temp_rule->next; 
  }
}

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

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

/*! 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;
    new_policy->next = NULL;
  }

  /* 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;

  /* start a new rules list */
  rules_list = NULL;

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

/* prints the list of policies */
void print_policies(policy_t* policies){
  policy_t* temp_policy = policies;
  while(temp_policy){
    eef_log(LOG_DEBUG, "Policy: %s\n", temp_policy->name);
    print_rules(temp_policy, temp_policy->rules);
    temp_policy = temp_policy->next;
  }
  return;
}


/* prints the list of rules */
void print_rules(policy_t* policy, rule_t* rule){
  if(rule){
    eef_log(LOG_DEBUG, "  | Rule %s\n", rule->state);
    eef_log(LOG_DEBUG, "  -------------------------\n");
    if(rule->true_branch){
      print_rules(policy, get_rule(policy->rules, rule->true_branch->state));
    }
    if(rule->false_branch){
      print_rules(policy, get_rule(policy->rules, rule->false_branch->state));
    }
  } 
  return;
}

/* tries to link all policy rules to a plugin in the plugin manager */
EES_RC link_rules_to_plugins(policy_t* policies){
  policy_t *temp_policy = policies;

  while(temp_policy){
    link_rule_to_plugin(temp_policy, temp_policy->rules);
    temp_policy = temp_policy->next;
  }
  return EES_SUCCESS;
}

void link_rule_to_plugin(policy_t *policy, rule_t *rule){
  var_t    *temp_var    = NULL;
  char**    argv;
  int       argc;

  eef_plugindl_t *temp_plugin = NULL;
  if(rule){
    eef_log(LOG_DEBUG, "Got rule: %s\n", rule->state);
    if(!rule->plugin){
      temp_var = get_variable_by_name(rule->state);
      if(temp_var){
        argv = _var_to_argv(temp_var->value, &argc);
        eef_log(LOG_DEBUG, "Trying to find plugin: %s\n", argv[0]);

        temp_plugin = get_plugin(argv[0]);
        if(temp_plugin){
          rule->plugin = temp_plugin;
        } else {
          eef_log(LOG_DEBUG, "Unknown plugin in variable %s\n", temp_var->value);
        }
        free_args(argc, argv);
      }
    } else {
      eef_log(LOG_DEBUG, "Plugin already linked?\n");
    }
    link_rule_to_plugin(policy, rule->true_branch);
    link_rule_to_plugin(policy, rule->false_branch);
  }
  return;
}

/* iterates the policies and removes those that are not explicitly named in the passed array of strings */
policy_t** reduce_policy_tree(policy_t** policies, int number_of_policies, char* names_of_policies[]){
  int i, policy_should_be_removed;
  policy_t *temp_policy = NULL, *previous_policy = NULL;

  for(temp_policy = *policies; temp_policy != NULL; previous_policy = temp_policy, temp_policy = temp_policy->next){
    policy_should_be_removed = 1;
    eef_log(LOG_DEBUG, "Checking policy: %s\n", (temp_policy)->name);
    for(i = 0; i < number_of_policies; i++){
      if(strcmp(temp_policy->name, names_of_policies[i]) == 0){
        /* if the policy is in the named list, we can continue to the next plugin */
        eef_log(LOG_DEBUG, "Allowed policy: %s\n", names_of_policies[i]);
        policy_should_be_removed = 0;
        break;
      }
    }

    if(policy_should_be_removed){
      eef_log(LOG_DEBUG, "Removing not-allowed policy: %s\n", temp_policy->name);

      /* if the head node is deleted, overwrite it with the next node */
      if(previous_policy == NULL){
        *policies = temp_policy->next;
      } else {
        previous_policy->next = temp_policy->next; 
      }

      /* Clean policy fields */
      eef_log(LOG_DEBUG, "Deleted policy: %s\n", temp_policy->name);
      temp_policy->rules = clean_rules_list(temp_policy->rules);
      free(temp_policy->name);
      free(temp_policy);
    }
  }

  return policies;
}

/*! 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;
}

/*! Removes a policy from the list of policies */
void remove_policy(record_t* policy){
  policy_t *temp_policy = policies_list, *next_policy = NULL;
  eef_log(LOG_DEBUG, "Deleted policy: %s\n", policy->string);

  while(temp_policy){
    if(strcmp(temp_policy->name, policy->string) == 0){
      /* target policy was found */
      next_policy = temp_policy->next;

      /* Clean policy fields */
      temp_policy->rules = clean_rules_list(temp_policy->rules);
      free(temp_policy->name);
      temp_policy->name = NULL;
      free(temp_policy);
      temp_policy = NULL;
    }

    /* Move to next policy */
    temp_policy = next_policy;
  }

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

/*! Removes a policy from the list of policies */
policy_t* remove_policy_by_name(policy_t* policies, char* policy){
  policy_t *temp_policy = policies, *next_policy = NULL;

  while(temp_policy){
    printf("Iterating to %s\n", temp_policy->name);
    next_policy = temp_policy->next;

    if(strcmp(temp_policy->name, policy) == 0){
      /* target policy was found */

      /* if the head node is deleted, overwrite it with the next node */
      if(temp_policy == policies){
        policies = next_policy;
      }

      /* Clean policy fields */
      temp_policy->rules = clean_rules_list(temp_policy->rules);
      eef_log(LOG_DEBUG, "Deleted policy: %s\n", policy);
      free(temp_policy->name);
      free(temp_policy);
      /*break;*/
    }

    /* Move to next policy */
    temp_policy = next_policy;
  }

  printf("Done removing %s, here is the list\n", policy);
  print_policies(policies);
  free(policy);
  return policies;
}

/*! 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);
  copy_of_value = NULL;
  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 let the plugin manager prepare plugin structs*/
EES_RC add_prepared_plugins(){
  char**    argv;
  int       argc;
  EES_RC    plugin_initialized_ok = EES_SUCCESS;
  var_t    *temp_var = variables_list;

  while((temp_var != NULL) && (plugin_initialized_ok == EES_SUCCESS)){
    argv = _var_to_argv(temp_var->value, &argc);

    /* this is a callout to the plug-in manager, which adds a struct describing a single plug-in to its list */
    plugin_initialized_ok = add_prepared_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);
    current_variable->name = NULL;
    free(current_variable->value);
    current_variable->value = NULL;

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

    /* Clean last variable struct */
    free(variables_list_last);
    variables_list_last = NULL;
  } 
  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 */
rule_t* clean_rules_list(rule_t* top_rule){
  rule_t* temp_rule = top_rule;
  if(temp_rule){
    free(temp_rule->state);

    clean_rules_list(temp_rule->true_branch);

    clean_rules_list(temp_rule->false_branch);

    free(temp_rule);
    temp_rule = NULL;
  } 
  return top_rule;
}

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

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

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

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

  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){
  /*eef_log(LOG_DEBUG, "Allowed rule: %i\n", val);*/
  return EES_SUCCESS;
}

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