pdl_policy.c

Go to the documentation of this file.

/*                                                                                                            
 * Copyright (c) Members of the EGEE Collaboration. 2004.
 * See http://eu-egee.org/partners/ for details on the copyright holders.
 * For license conditions see the license file or
 * http://eu-egee.org/license.html
 */

/*
 *   Copyright (c) 2003 EU DataGrid        http://www.eu-datagrid.org/
 *
 *   $Id: pdl_policy.c,v 1.21 2005/05/27 16:22:20 msteenba 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_policy.h"

static BOOL policies_reduced = FALSE;       

static policy_t *top_policy=0, *last_policy=0;

static int num_of_policies_to_evaluate = 0;
static char** policies_to_evaluate = NULL;

BOOL _add_policy(const record_t* name, const rule_t* rules);


void allow_rules(BOOL allow)
{
  allow_new_rules(allow);
}


void add_policy(record_t* policy, rule_t* rules)
{
  /*
   *  Do not switch the order of the and operator, because the
   *  _add_policy needs to be done always.
   */
  if (!_add_policy(policy, rules)) {
    free_rules(rules);     rules          = NULL;
    free(policy->string);  policy->string = NULL;
    free(policy);          policy         = NULL;

    set_yylval(0);
  }

  free(policy);
  policy = NULL;

  start_new_rules();
};


BOOL _add_policy(const record_t* name, const rule_t* rules)
{
  policy_t *policy;

  if ((policy = find_policy(name->string))) {
    warning(PDL_ERROR, "policy '%s' already defined at line %d.", name->string, policy->lineno);
    allow_rules(FALSE);
    return FALSE;
  }

  if ((policy = (policy_t *)malloc(sizeof(policy_t)))) {
    policy->name   = name->string;
    policy->rule   = (rule_t*)rules;
    policy->lineno = name->lineno;
    policy->next   = 0;
    policy->prev   = last_policy;

    if (top_policy)
      last_policy->next = policy;
    else
      top_policy = policy;

    last_policy = policy;
  } else {
    warning(PDL_ERROR, "Out of memory; cannot add policy '%s'.\n", name);
    return FALSE;
  }

  return TRUE;
}


void remove_policy(record_t* policy)
{
  free(policy->string);  policy->string = NULL;
  free(policy);          policy         = NULL;
}


policy_t* find_policy(const char* name)
{
  policy_t* policy=top_policy;

  while (policy && strcmp(name, policy->name)!=0) {
    policy = policy->next;
  }

  return policy;  
}


BOOL check_policies_for_recursion(void)
{
  BOOL recursion = FALSE;
  policy_t* policy = get_policies();

  while (policy) {
    lcmaps_log_debug(1, "Checking policy '%s' for recursions.\n", policy->name);

    if (check_rule_for_recursion(policy->rule)) {
      recursion = TRUE;
      lcmaps_log_debug(1, "Recursions were found.\n");
    }
    else
      lcmaps_log_debug(1, "No recursions were found.\n");

    policy = policy->next;
  }

  return recursion;
}


void reduce_policies(void)
{
  policy_t* policy = get_policies();

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

    while (rule) {
      reduce_rule(rule);
      rule = rule->next;
    }

    policy = policy->next;
  }

  policies_reduced = TRUE;
}



policy_t* get_policies(void)
{
  return top_policy;
}


void show_policies(void)
{
  policy_t* policy = top_policy;

  while (policy) {
    lcmaps_log_debug(1, "policy: %s\n", policy->name);
    show_rules(policy->rule);

    policy = policy->next;
  }
}


void cleanup_policies(void)
{
  policy_t* policy = top_policy;

  while (policy) {
    if (!policy->rule) {
      if (policy->prev) {
        policy->prev->next = policy->next;
      }
      else
      {
        /* move the top_policy to the new head of the list */
        top_policy = policy->next;
      }
      if (policy->next) {
        policy->next->prev = policy->prev;
      }
      policy_t* tmp = policy;
      policy = policy->next;
      free (tmp);
    } else {
      policy = policy->next;
    }
  }
}


void free_policies(void)
{
  policy_t* next_pol, *policy = top_policy;

  while (policy) {
    next_pol = policy->next;
    free((char *)policy->name);  policy->name = NULL;
    free_rules(policy->rule);    policy->rule = NULL;
    free(policy);
    policy = next_pol;
  }

  top_policy = 0;
  //  When there is no policy defined, it does not make sense to have a
  //  top rule either.
  set_top_rule(0);
}


BOOL allowed_policy_rule(const char* label)
{
  BOOL allowed = TRUE;
  int i=0;

  if (num_of_policies_to_evaluate > 0)
  {
    allowed = FALSE;
    while (i<num_of_policies_to_evaluate) {
      if (strcmp(label, policies_to_evaluate[i]) == 0) {
        allowed = TRUE;
        break;
      }
      i++;
    }
  }

  return allowed;
}


void SetSetOfRules(int argc, char* argv[])
{
  num_of_policies_to_evaluate = argc;
  policies_to_evaluate = argv;
}

BOOL policies_have_been_reduced(void)
{
  return policies_reduced;
}

---