---

pdl_main.c

Go to the documentation of this file.

/*
 *   Copyright (c) 2003 EU DataGrid        http://www.eu-datagrid.org/
 *
 *   $Id: pdl_main.c,v 1.31 2003/09/11 11:20:28 venekamp Exp $
 *
 *   Copyright (c) 2003 by
 *      G.M. Venekamp <venekamp@nikhef.nl>
 *      NIKHEF Amsterdam, the Netherlands
 *
 *   This software is distributed under a BSD-style open source
 *   licence. For a complete description of the licence take a look
 *   at: http://eu-datagrid.web.cern.ch/eu-datagrid/license.html
 *
 */


#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "lcmaps_log.h"
#include "pdl.h"
#include "pdl_variable.h"
#include "pdl_policy.h"
#include "pdl_rule.h"

static const char* script_name  = NULL;           
static const char* d_path       = "/usr/lib";     
static const char* path         = 0;              
static int path_lineno          = 0;              
static plugin_t* top_plugin     = NULL;           
static BOOL default_path        = TRUE;           
static BOOL parse_error         = FALSE;          
static char* level_str[PDL_SAME];                 

unsigned int lineno = 1;   

void _set_path(const record_t* _path);
record_t* _concat_strings(const record_t* s1, const record_t* s2, const char* extra);
void reduce_policies(void);
void init_name_args(plugin_t** plugin, const rule_t* rule, rule_type_t type);
BOOL plugin_exists(const char* string);
int find_first_space(const char* string);


int pdl_init(const char* name)
{
  if (name) {
    FILE* file;

    script_name = strdup(name);

    file = fopen(name, "r");
    if (file)
      yyin = file;
    else {
      warning(PDL_ERROR, "Could not open file '%s'.", name);
      return -1;
    }
  }

  /*  Set the default path  */
  path = d_path;
  default_path = TRUE;

  /*
   *  Check if there are plugins, if so clear top_plugin and free
   *  all allocated memory.
   */
  while (top_plugin) {
    free(top_plugin->name);
    free(top_plugin->args);
    top_plugin = top_plugin->next;
  }

  /*  Init the levels with the appropriate print text.  */
  level_str[PDL_INFO]    = "info";
  level_str[PDL_WARNING] = "warning";
  level_str[PDL_ERROR]   = "error";
  level_str[PDL_UNKNOWN] = "<unknown>";

  parse_error = FALSE;

  return 0;
}


int yyparse_errors(void)
{
  return parse_error ? -1 : 0;
}


const plugin_t* get_plugins(void)
{
  plugin_t* plugin;
  policy_t* policy;

  /*
   *  Check if the policies have been reduced. If not, then getting
   *  the plugins and their arguments is useless; the variables have
   *  not been substituted yet.
   */
  if (!policies_have_been_reduced()) {
    lcmaps_log(1, "The policies have not been reduced. Probably the startElevaluationManager has failed or has not been called yet.\n");
    return 0;
  }

  /*
   *  Check if evaluation has been done before, if so use the old
   *  results.
   */
  if (top_plugin)
    return top_plugin;

  policy = get_policies();

  while (policy) {
    rule_t* rule = policy->rule;

    lcmaps_log_debug(1, "processing policy: %s\n", policy->name);
    while (rule) {
      lcmaps_log_debug(1, "  processing rule: %s -> %s | %s\n", rule->state, rule->true_branch, rule->false_branch);

      lcmaps_log_debug(1, "  get_plugins:  initializing...\n");
      init_name_args(&plugin, rule, STATE);
      init_name_args(&plugin, rule, TRUE_BRANCH);
      init_name_args(&plugin, rule, FALSE_BRANCH);
      lcmaps_log_debug(1, "  get_plugins:  initializing done.\n");

      rule = rule->next;
    }
    policy = policy->next;
  }
  
  return top_plugin;
}


BOOL plugin_exists(const char* string)
{
  int space, remainder;
  plugin_t *plugin;

  space     = find_first_space(string);
  remainder = strlen(string) - space - 1;
  plugin    = top_plugin;

  while (plugin) {
    if (plugin->name && strncmp(plugin->name, string, space)==0) {
      if (plugin->args)
        if (strncmp(plugin->args, string+space+1, remainder)!=0) {
          plugin = plugin->next;
          continue;
        }
      return TRUE;
    }
    plugin = plugin->next;
  }
  
  return FALSE;
}


void init_name_args(plugin_t** plugin, const rule_t* rule, rule_type_t type)
{
  int space, remainder;
  const char* string;

  switch (type) {
  case STATE:
    string = rule->state;
    break;
  case TRUE_BRANCH:
    string = rule->true_branch;
    break;
  case FALSE_BRANCH:
    string = rule->false_branch;
    break;
  default:
    warning(PDL_ERROR, "init_name_args: unknown type!");
    return;
  }

  lcmaps_log_debug(1, "  init_name_args: processing: %s\n", string);

  if (!string || plugin_exists(string)) {
    lcmaps_log_debug(1, "  init_name_args: Either the plugin exists or string == 0.\n");
    return;
  }

  lcmaps_log_debug(1, "  init_name_args: plugin does not exists.\n");

  if (!top_plugin) {
    top_plugin = (plugin_t*)malloc(sizeof(plugin_t));
    *plugin = top_plugin;
  }
  else {
    (*plugin)->next = (plugin_t*)malloc(sizeof(plugin_t));
    *plugin = (*plugin)->next;
  }

  (*plugin)->name = (*plugin)->args = 0;
  (*plugin)->next = 0;

  space = find_first_space(string);

  lcmaps_log_debug(1, "  init_name_args: space found a pos: %d  strlen = %d.\n", space, strlen(string));

  (*plugin)->name = (char *)malloc(space+1);
  strncpy((*plugin)->name, string, space);
  *((*plugin)->name+space) = '\0';
  
  remainder = strlen(string)-space-1;
  if (remainder > 0) {
    (*plugin)->args   = (char *)malloc(remainder+1);
    strncpy((*plugin)->args, string+space+1, remainder);
    *((*plugin)->args+remainder) = '\0';
  } else
    (*plugin)->args = 0;

  (*plugin)->lineno = rule->lineno;
  (*plugin)->next   = 0;

  lcmaps_log_debug(1, "  init_name_args: plugin->name = %s\n", (*plugin)->name);
  lcmaps_log_debug(1, "  init_name_args: plugin->args = %s\n", (*plugin)->args);
}


int find_first_space(const char* string)
{
  int space, max_length;
  space = 0;
  max_length = strlen(string);

  for (; *string++ != ' ' && space < max_length; ++space);

  return space;
}


const char *pdl_path(void)
{
  return path;
};


int yyerror(const char* s)
{
  //  lcmaps_log_debug(1, "%s\n", token_name());

  warning(PDL_ERROR, s);

  return 0;
}


void set_path(record_t* path)
{
  _set_path(path);

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


void _set_path(const record_t* _path)
{
  //  lcmaps_log_debug(1, "set_path: '%s'.\n", _path);

  if (!default_path) {
    warning(PDL_ERROR, "path already defined in: %d; ignoring this instance.", path_lineno);
    return;
  }

  default_path = FALSE;
  path_lineno  = _path->lineno;
  path         = strdup(_path->string);
}



void free_path(void)
{
  if (!default_path && path) {
    free((char*)path);
    default_path = TRUE;
    path = 0;
  }
}



record_t* concat_strings(record_t* s1, record_t* s2)
{
  record_t* r = _concat_strings(s1, s2, 0);

  free(s1->string);
  free(s2->string);
  free(s1);
  free(s2);

  return r;
}


record_t* _concat_strings(const record_t* s1, const record_t* s2,
                          const char* extra)
{
  int len       = strlen(s1->string);
  int len_extra = extra ? strlen(extra) : 0;

  record_t* record = (record_t *)malloc(sizeof(record_t));

  if (!(record->string = (char *)malloc(len + len_extra + strlen(s2->string)+1))) {
    warning(PDL_ERROR, "out of memory");
    return 0;
  }

  strcpy(record->string, s1->string);
  if (extra)
    strcpy(record->string+len, extra);
  strcpy(record->string+len+len_extra, s2->string);

  //lcmaps_log_debug(1, "concat_strings: '%s' + '%s' = '%s'.\n", s1, s2, s3);

  return record;
}


record_t* concat_strings_with_space(record_t* s1, record_t* s2)
{
  record_t* r;

  /*  Check if there is a string to add.  */
  if (strlen(s2->string)!=0) {
    /*
     *  When the first and second string end with ", do not an extra
     *  space. This is the result of an sequence of escaped ".
     */
    if ((s1->string[strlen(s1->string)-1]=='"') &&
        (s2->string[strlen(s2->string)-1]=='"'))
      r = _concat_strings(s1, s2, 0);
    else
      r = _concat_strings(s1, s2, " ");

    free(s1->string);
    free(s2->string);
    free(s1);
    free(s2);
  } else {
    /*
     *  Since there is nothing to concatenate, we simply copy the
     *  first string (s1) to the result.
     */
    r = (record_t*)malloc(sizeof(r));
    memcpy(r, s1, sizeof(r));
  }

  return r;
}


const char* pdl_next_plugin(plugin_status_t status)
{
  const static policy_t* current_policy = 0;
  const static rule_t*   current_rule   = 0;
  char* string      = 0;
  const char* state = 0;

  switch (status) {
  case EVALUATION_START:
    /*  Make sure that there is a policy list.  */
    if (!(current_policy = get_policies()))
      return 0;
    if (!(current_rule = current_policy->rule))
      return 0;

    state = current_rule->state;
    break;

  case EVALUATION_SUCCESS:
    if (current_rule)
      state = current_rule->true_branch;

    if (current_policy && state)
      current_rule = find_state(current_policy->rule, state);
    else
      current_rule = 0;
    break;

  case EVALUATION_FAILURE:
    /*
     *  Find the next rule for evalaution. The plugins specified by
     *  that rule will not be returned by this iterating of the
     *  function. Instead the static variables are setup, such that on
     *  the next iteration the next plugin is returned. Only after the
     *  evaluation of the plugin found during this iteration can a
     *  decision be made which plugin to return.
     *
     *  When the last rule has been evaluated, there is the
     *  possibility that there is another policy in the configration.
     *  Instead of stopping at the end of a rule chain, setup the
     *  variables for the next policy rule.
     *
     */
    if (current_rule)
      state = current_rule->false_branch;

    /* 
     *  Check if either there is a current_rule or a state. If so, we
     *  can continue. If there is no current rule, there might be a
     *  next policy. This needs to be evaluated next. If there is no
     *  state, this is because the false branch does not exist and
     *  hence we need to evaluate possible next policies.
     *
     */
    if (!(current_rule && state)) {
      if (current_policy && (current_policy = current_policy->next)) {
        if ((current_rule = current_policy->rule))
          state = current_rule->state;
      }
    } else {
       /*  We have a valid next state. Let's find  the next rule.  */
      if (current_policy)
        current_rule = find_state(current_policy->rule, state);
    }

    break;
  }

  /*
   *  Create the full plugin name, i.e. including the path. The rules
   *  do not specify the path, this must be added so that a single
   *  string can be returned. State holde the current plugin name.
   *
   */
  if (state) {
    const char* tmp;
    int state_length, path_length;

    tmp = state;
    state_length = path_length = 0;

    while (*tmp!=' ' && *tmp++!='\0') {
      ++state_length;
    }
    path_length = strlen(pdl_path());

    /*  Allocate memory and initialize the string.  */
    string = (char*)malloc(state_length + path_length + 2);
    strcpy(string, pdl_path());

    /*  Make sure the path ends in '/'.  */
    if (string[path_length-1] != '/')
      string[path_length++] = '/';
    strncpy(string + path_length, state, state_length);
    string[path_length + state_length] = '\0';
  }

  return string;
}


void free_resources(void)
{
  if (script_name) {
    free((char*)script_name);
    script_name = 0;
  }

  free_path();

  free_variables();
  free_policies();

  /*
   *  YACC takes its input from the stdin by default. When the input
   *  is taken from a file, the yyin variable will have a different
   *  value from stdin and stderr. If so, it is necessary to close it.
   */
  if (yyin!=stdin && yyin!=stderr) {
    fclose(yyin);
    yyin=stdin;
  }

#ifdef HAVE_FLEX
  delete_lex_buffer();
#endif
}


void warning(pdl_error_t error, const char* s, ...)
{
  static char* level = 0;
  char buf[2048];
  int res;

  va_list args;

  if (error == PDL_ERROR)
    parse_error = TRUE;

  if (!level)
    level = level_str[PDL_UNKNOWN];

  if (error != PDL_SAME)
    level = level_str[error];

  /*
   *  Prepend a standard text before the message. This makes reading
   *  the errors/warnings a little easier.
   */
  res = sprintf(buf, "%s:%d: [%s] ", script_name, lineno, level);

  /*  Print (format) the actual message.  */
  va_start(args, s);
  res += vsnprintf(buf+res, sizeof(buf)-res-2, s, args);
  va_end(args);

  /*
   *  The string needs to end in a new line and of course strings are
   *  termintated by the end of string character. Make sure it happens
   *  and respect the buffer size!
   */
  buf[res<sizeof(buf)-1 ? res++ : sizeof(buf)-2] = '\n';
  buf[res<sizeof(buf)   ? res   : sizeof(buf)-1] = '\0';

  lcmaps_log(0, buf);
}

---