---

pdl_policy.c

Go to the documentation of this file.

/*
 *   Copyright (c) 2003 EU DataGrid        http://www.eu-datagrid.org/
 *
 *   $Id: pdl_policy.c,v 1.13 2003/08/06 08:15:36 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 "lcmaps_log.h"
#include "pdl_policy.h"

static BOOL policies_reduced = FALSE;       

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

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


policy_t* current_policy(void)
{
  return last_policy;
}


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);
    free(policy->string);
    free(policy);

    set_yylval(0);
  }

  free(policy);

  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);
  free(policy);
}


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 free_policies(void)
{
  policy_t* next_pol, *policy = top_policy;

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

  top_policy = 0;
}


BOOL policies_have_been_reduced(void)
{
  return policies_reduced;
}

---