lcmaps_pluginmanager.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) 2001 EU DataGrid.                                                                             
 * For license conditions see http://www.eu-datagrid.org/license.html                                          
 *
 * Copyright (c) 2001, 2002 by 
 *     Martijn Steenbakkers <martijn@nikhef.nl>,
 *     David Groep <davidg@nikhef.nl>,
 *     NIKHEF Amsterdam, the Netherlands
 */

/*****************************************************************************
                            Include header files
******************************************************************************/
#include "lcmaps_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if HAVE_MALLOC_H
#    include <malloc.h>
#endif

/* Programming interface to dynamic linking loader */
#if HAVE_DLFCN_H
#    include <dlfcn.h>
#endif

/* LCMAPS includes */
#include "lcmaps_types.h"
#include "lcmaps_log.h"
#include "lcmaps_arguments.h"
#include "lcmaps_defines.h"
#include "_lcmaps_utils.h"
#include "_lcmaps_db_read.h"
#include "_lcmaps_runvars.h"
#include "_lcmaps_cred_data.h"
/* interface to evaluationmanager */
#include "../evaluationmanager/evaluationmanager.h"

/******************************************************************************
                             Define constants
******************************************************************************/

#ifndef NUL
#define NUL '\0' 
#endif

/* LCMAPS authorization module definitions */
#define MAXPROCS    4 
#define USE_EVALUATIONMANAGER 1


/******************************************************************************
                               Type definitions
******************************************************************************/
enum lcmaps_proctype_e
{
    INITPROC,  
    RUNPROC,   
    TERMPROC,  
    INTROPROC, 
    ENDOFPROCS /*< this is the last enumeration value */
};

typedef int (*lcmaps_proc_t)();

typedef struct lcmaps_plugindl_s
{
    void *                      handle;                            
    lcmaps_proc_t               procs[MAXPROCS];                   
    char                        pluginname[LCMAPS_MAXPATHLEN+1];   
    char                        pluginargs[LCMAPS_MAXARGSTRING+1]; 
    int                         init_argc;                         
    char *                      init_argv[LCMAPS_MAXARGS];         
    int                         run_argc;                          
    lcmaps_argument_t *         run_argv;                          
    struct lcmaps_plugindl_s *  next;                              
}
lcmaps_plugindl_t;

/******************************************************************************
                          Module specific prototypes
******************************************************************************/
static lcmaps_plugindl_t * PluginInit(lcmaps_db_entry_t *, lcmaps_plugindl_t **);
static lcmaps_proc_t       get_procsymbol(void *, char *);
static int                 print_lcmaps_plugin(int, lcmaps_plugindl_t *);
static int                 parse_args_plugin(const char *, const char *, char **, int *);
static int                 clean_plugin_list(lcmaps_plugindl_t **);

/******************************************************************************
                       Define module specific variables
******************************************************************************/
static char *              lcmaps_db_file_default = NULL; 
static char *              lcmaps_dir             = NULL; 
static lcmaps_plugindl_t * plugin_list            = NULL; 
/******************************************************************************
Function:   startPluginManager
Description:
    Start PluginManager module:
    read from LCMAPS config file, the plugins to be loaded
    Start evaluation manager (get policy)

Parameters:
Returns:
    0: succes
    1: failure
******************************************************************************/
int startPluginManager(
)
{
#if USE_EVALUATIONMANAGER
    lcmaps_db_entry_t *   lcmaps_db_handle=NULL;
#else
    lcmaps_db_entry_t **  lcmaps_db_handle=NULL;
#endif
    lcmaps_db_entry_t *   ihandle=NULL;
    lcmaps_plugindl_t *   plugin_entry=NULL;
    lcmaps_plugindl_t *   plugin_entry_cmp=NULL;
    char *                lcmaps_db_file=NULL;
    int                   ientry;

    /* get LCMAPS (database) home directory and set lcmaps_db_file */
    lcmaps_dir = getenv("LCMAPS_DIR");
    lcmaps_dir = (lcmaps_dir ? lcmaps_dir : getenv("LCMAPS_ETC_DIR") );
    lcmaps_dir = (lcmaps_dir ? lcmaps_dir : LCMAPS_ETC_HOME );

    lcmaps_db_file_default = getenv("LCMAPS_DB_FILE");
    lcmaps_db_file_default = (lcmaps_db_file_default ? lcmaps_db_file_default : "lcmaps.db" );

    lcmaps_db_file=lcmaps_genfilename(lcmaps_dir, lcmaps_db_file_default, NULL);

#if USE_EVALUATIONMANAGER
    /* To be done:
     * Start evaluation manager (evaluates the  LCMAPS policy database)
     */
    lcmaps_log_debug(2,"lcmaps.mod-startPluginManager(): doing startEvaluationManager(%s)\n",
            lcmaps_db_file);
{
    int npol = 0;
    char * pol1 = NULL;
    if (startEvaluationManager(lcmaps_db_file, npol, &pol1 ) != 0)
    {
        lcmaps_log(0,"lcmaps.mod-startPluginManager(): startEvaluationManager(%s) failed\n",
                lcmaps_db_file);
        goto fail_startPluginManager;
    }
}
#endif

    /* 
     * retrieve PLUGIN MODULE info from evaluation manager and store
     * the info in a lcmaps_db structure
     */
    lcmaps_log_time(0,"lcmaps.mod-startPluginManager(): Reading LCMAPS database %s\n",
            lcmaps_db_file);
#if USE_EVALUATIONMANAGER
    if (getPluginNameAndArgs(&lcmaps_db_handle) != 0)
    {
        lcmaps_log(0,"lcmaps.mod-startPluginManager(): Error fetching list of plugins from evaluation manager\n");
        goto fail_startPluginManager;
    }
#else
    lcmaps_db_handle=lcmaps_db_read(lcmaps_db_file);
#endif

    if (lcmaps_db_handle == NULL)
    {
#if USE_EVALUATIONMANAGER
        lcmaps_log_debug(1,"lcmaps.mod-startPluginManager(): Evaluation manager found no plugins\n");
#else
        lcmaps_log_debug(1,"lcmaps.mod-startPluginManager(): no plugins found by lcmaps_db_read()\n");
#endif
        goto fail_startPluginManager;
    }

    /*
     * init the PLUGIN AUTHORIZATION MODULES (PluginInit)
     * - open plugins and check the symbols plugin_init and confirm_authorization
     * - run plugin_init
     */
    ientry=0;
#if USE_EVALUATIONMANAGER
    ihandle=lcmaps_db_handle;
#else
    ihandle=*lcmaps_db_handle;
#endif
    while (ihandle)
    {
        if (strlen(ihandle->pluginname) > 0)
        {
            int plugin_count=0;

            lcmaps_log_debug(1,"\n");
            lcmaps_log_debug(1,"lcmaps.mod-startPluginManager(): initializing plugin %s (db entry %d)\n",
                     ihandle->pluginname, ientry);
            if ((plugin_entry=PluginInit(ihandle,&plugin_list)) == NULL)
            {
                lcmaps_log(0,"lcmaps.mod-startPluginManager(): error initializing plugin: %s\n",ihandle->pluginname);
                goto fail_startPluginManager;
            }
            /* 
             * Check if plugin module is already registered as standard authorization module,
             * by comparing the complete path names of the plugin and modules
             */
            plugin_entry_cmp=plugin_list;
            while (plugin_entry_cmp)
            {
                if ( (strncmp(plugin_entry_cmp->pluginname,
                              plugin_entry->pluginname,
                              LCMAPS_MAXPATHLEN) == 0)
                   )
                    plugin_count++;
                if (plugin_count > 1)
                {
                    lcmaps_log(0,"lcmaps.mod-startPluginManager() error: plugin %s already registered as\n",
                             plugin_entry->pluginname);
                    goto fail_startPluginManager;
                }
                plugin_entry_cmp=plugin_entry_cmp->next;
            }
        }
        ientry++;
        ihandle=ihandle->next;
    }

    plugin_entry=plugin_list;
    while (plugin_entry)
    {
        print_lcmaps_plugin(2,plugin_entry);
        lcmaps_log_debug(2,"\n");
        plugin_entry=plugin_entry->next;
    }

    /* clean PLUGIN authorization module database structure */
#if USE_EVALUATIONMANAGER
    /*
     * Do not clean lcmaps_db_entry_t structure since it is managed by the evaluation manager
     * and will be taken care of in stopEvaluationManager
     */
//    if (lcmaps_db_clean_list(&lcmaps_db_handle))
//    {
//        lcmaps_log(0,"lcmaps.mod-startPluginManager() error: could not clean up plugin db structure\n");
//        goto fail_startPluginManager;
//    }
//    lcmaps_log_debug(5,"lcmaps.mod-startPluginManager(): cleaned lcmaps_db list: %p\n",lcmaps_db_handle);
#else
    if (lcmaps_db_clean())
    {
        lcmaps_log(0,"lcmaps.mod-startPluginManager() error: could not clean up plugin db structure\n");
        goto fail_startPluginManager;
    }
    lcmaps_log_debug(5,"lcmaps.mod-startPluginManager(): cleaned lcmaps_db list: %p\n",lcmaps_db_handle);
#endif

    /* success */
    if (lcmaps_db_file) free(lcmaps_db_file);
    return 0;

 fail_startPluginManager:
    /* failure */
#if USE_EVALUATIONMANAGER
    /*
     * Do not clean lcmaps_db_entry_t structure since it is managed by the evaluation manager
     * and will be taken care of in stopEvaluationManager
     */
/*    lcmaps_db_clean_list(&lcmaps_db_handle); */
#else
    lcmaps_db_clean();
#endif
    if (clean_plugin_list(&plugin_list)!=0)
    {
        lcmaps_log(0,"lcmaps.mod-startPluginManager() error: could not clean up plugin list\n");
    }
    if (lcmaps_db_file) free(lcmaps_db_file);

    return 1;
}


/******************************************************************************
Function:   PluginInit
Description:
    Initialize the plugin
    - Create entry in (plugin)list
    - Open plugins and check the symbols plugin_init and confirm_authorization
    - run plugin_init

Parameters:
    db_handle: handle to LCMAPS db (containing pluginname and pluginargs)
    list:      pointer to list to which (plugin) module has to be added
Returns:
    pointer to plugin structure
    NULL: could not initialize plugin
******************************************************************************/
static lcmaps_plugindl_t * PluginInit(
        lcmaps_db_entry_t * db_handle,
        lcmaps_plugindl_t ** list
)
{
    char *                 name;
    char *                 pname=NULL;
    char *                 args=NULL;
    void *                 plugin_handle;
    lcmaps_proc_t          plugin_procs[MAXPROCS];
    lcmaps_plugindl_t *    pplugin=NULL;
    int                    i;
    int                    retval;

    name = db_handle->pluginname;
    args = db_handle->pluginargs;

    /* Find plugin module */
    pname = lcmaps_findfile(name);
    if (pname == NULL)
    {
        lcmaps_log(0,
            "lcmaps.mod-PluginInit(): plugin %s not found (arguments: %s)\n",
            name, args
        );
        goto fail_PluginInit;
    }

    /* Try a dlopen() */
    plugin_handle=dlopen(pname,RTLD_NOW);
    if (!plugin_handle)
    {
        lcmaps_log(0,"lcmaps.mod-PluginInit(): dlopen error for %s:\n    %s\n",
            pname,dlerror()
        );
        goto fail_PluginInit;
    }

    /* Check symbols */
    for (i=0; i < MAXPROCS; ++i)
    {
        switch (i)
        {
            case INITPROC:
                plugin_procs[i]=get_procsymbol(plugin_handle,"plugin_initialize");
                if (plugin_procs[i] == NULL)
                {
                    lcmaps_log(0,"lcmaps.mod-PluginInit(): plugin %s not compliant\n",
                        name);
                    lcmaps_log(0,"lcmaps.mod-PluginInit(): missing function \"plugin_initialize()\"\n");
                    goto fail_PluginInit;
                }
                else
                {
                    lcmaps_log_debug(2,"lcmaps.mod-PluginInit(): found \"plugin_initialize()\"\n");
                }
                break;
            case RUNPROC:
                plugin_procs[i]=get_procsymbol(plugin_handle,"plugin_run");
                if (plugin_procs[i] == NULL)
                {
                    lcmaps_log(0,"lcmaps.mod-PluginInit(): plugin %s not compliant\n",
                        name);
                    lcmaps_log(0,"lcmaps.mod-PluginInit(): missing function \"plugin_run()\"\n");
                    goto fail_PluginInit;
                }
                else
                {
                    lcmaps_log_debug(2,"lcmaps.mod-PluginInit(): found \"plugin_run()\"\n");
                }
                break;
            case TERMPROC:
                plugin_procs[i]=get_procsymbol(plugin_handle,"plugin_terminate");
                if (plugin_procs[i] == NULL)
                {
                    lcmaps_log(0,"lcmaps.mod-PluginInit(): plugin %s not compliant\n",
                        name);
                    lcmaps_log(0,"lcmaps.mod-PluginInit(): missing function \"plugin_terminate()\"\n");
                    goto fail_PluginInit;
                }
                else
                {
                    lcmaps_log_debug(2,"lcmaps.mod-PluginInit(): found \"plugin_terminate()\"\n");
                }
                break;
            case INTROPROC:
                plugin_procs[i]=get_procsymbol(plugin_handle,"plugin_introspect");
                if (plugin_procs[i] == NULL)
                {
                    lcmaps_log(0,"lcmaps.mod-PluginInit(): plugin %s not compliant\n",
                        name);
                    lcmaps_log(0,"lcmaps.mod-PluginInit(): missing function \"plugin_introspect()\"\n");
                    goto fail_PluginInit;
                }
                else
                {
                    lcmaps_log_debug(2,"lcmaps.mod-PluginInit(): found \"plugin_introspect()\"\n");
                }
                break;
            default:
                /* do nothing */
                plugin_procs[i]=NULL;
                break;
        }
    }
    /* Make a new entry at end of plugin list */
    if (!*list)
    {
        lcmaps_log_debug(2,"lcmaps.mod-PluginInit(): creating first pluginlist entry\n");
        *list=pplugin=(lcmaps_plugindl_t *)malloc(sizeof(lcmaps_plugindl_t));
    }
    else
    {
        lcmaps_log_debug(2,"lcmaps.mod-PluginInit(): creating new pluginlist entry\n");
        pplugin=*list;
        while (pplugin->next) pplugin=pplugin->next;
        pplugin=pplugin->next=(lcmaps_plugindl_t *)malloc(sizeof(lcmaps_plugindl_t));
    }
    if (!pplugin)
    {
        lcmaps_log(0,"lcmaps.mod-PluginInit(): error creating new pluginlist entry\n");
        goto fail_PluginInit;
    }
    /* Set plugin list elements */
    pplugin->next=NULL;
    pplugin->handle=plugin_handle;
    pplugin->run_argc=0;
    pplugin->run_argv=NULL;
    for (i=0; i < MAXPROCS; ++i)
        pplugin->procs[i]=plugin_procs[i];
    if (pname != NULL)
    {
        strncpy(pplugin->pluginname,pname,LCMAPS_MAXPATHLEN);
        (pplugin->pluginname)[LCMAPS_MAXPATHLEN]=NUL;
    }
    else
        strncpy(pplugin->pluginname,"",LCMAPS_MAXPATHLEN);

    if (args != NULL)
    {
        strncpy(pplugin->pluginargs,args,LCMAPS_MAXARGSTRING);
        (pplugin->pluginargs)[LCMAPS_MAXARGSTRING]=NUL;
    }
    else
        strncpy(pplugin->pluginargs,"",LCMAPS_MAXARGSTRING);

    /* Parse options */
    if (parse_args_plugin(pname,args,pplugin->init_argv,&(pplugin->init_argc)) )
    {
        lcmaps_log(0,"lcmaps.mod-PluginInit(): Could not parse arguments for plugin module %s\n",
        pname);
        goto fail_PluginInit;
    }
    for (i=0; i < pplugin->init_argc; ++i)
        lcmaps_log_debug(4,"%s arg %d = %s\n",pname,i,(pplugin->init_argv)[i]);


    /* Run plugin_initialize() */
    retval=(*(pplugin->procs[INITPROC]))(pplugin->init_argc,pplugin->init_argv);
    if (retval != LCMAPS_MOD_SUCCESS )
    {
        lcmaps_log(0,"lcmaps.mod-PluginInit(): \"plugin_initialize()\" failed\n");
        goto fail_PluginInit;
    }
    else
    {
        lcmaps_log_debug(2,"lcmaps.mod-PluginInit(): \"plugin_initialize()\" succeeded\n");
    }

    /* Run plugin_introspect() */
    retval=(*(pplugin->procs[INTROPROC]))(&(pplugin->run_argc),&(pplugin->run_argv));
    if (retval != LCMAPS_MOD_SUCCESS )
    {
        lcmaps_log(0,"lcmaps.mod-PluginInit(): \"plugin_introspect()\" failed\n");
        goto fail_PluginInit;
    }
    else
    {
        lcmaps_log_debug(2,"lcmaps.mod-PluginInit(): \"plugin_introspect()\" succeeded\n");
    }

    /* free stuff */
    if (pname) { free(pname); pname=NULL; }

    return pplugin;

 fail_PluginInit:
    if (pname) { free(pname); pname=NULL; }
    return NULL;
}

/******************************************************************************
Function:   parse_args_plugin()
Description:
    Parse the argument string of the plugin and create xargv and xargc

Parameters:
    name: name of the plugin (goes into argv[0])
    argstring: string containing the arguments
    xargv: array of argument strings (has to be freed later)
    xargc: number of arguments
Returns:
    0 on succes
    1 on failure
******************************************************************************/
static int parse_args_plugin(
        const char * name,
        const char * argstring,
        char ** xargv,
        int * xargc
)
{
    int len=0;
    int i;
    int rc;

    /* set modulename */
    len=strlen(name);
    if ( (len > 0) && (len < LCMAPS_MAXPATHLEN) )
    {
        xargv[0]=(char *)malloc(len+1);
        if (xargv[0] != NULL)
            strncpy(xargv[0],name,len+1);
        else
            return 1;
    }

    *xargc=LCMAPS_MAXARGS-1;
    if ( ( rc = lcmaps_tokenize(argstring, &xargv[1], xargc, " \t\n") ) )
    {
        lcmaps_log(0,"lcmaps.mod-parse_args_plugin(): something wrong parsing arguments of %s, rc=%d\n",
                 name, rc);
        (*xargc)++;
        return 1;
    }
    (*xargc)++; /* increase by one for xargv[0] */
    lcmaps_log_debug(3,"lcmaps.mod-parse_args_plugin(): Found %d arguments:\n", *xargc);
    for (i=0; i < *xargc; i++)
        lcmaps_log_debug(3,"lcmaps.mod-parse_args_plugin(): %d --> %s\n", i, xargv[i]);

    return 0;
}

/******************************************************************************
Function:   get_procsymbol
Description:
    get procedure symbol from dlopen-ed library

Parameters:
    handle:  handle of dynamic library
    symname: name of procedure symbol
Returns:
    handle to procedure symbol
    NULL: Could not get symbol
******************************************************************************/
static lcmaps_proc_t get_procsymbol(
        void * handle,
        char * symname
)
{
    lcmaps_proc_t symhandle;
    char *error;

    symhandle=dlsym(handle,symname);
    if ((error = dlerror()) != NULL)
    {
        lcmaps_log(0,"lcmaps.mod-get_procsymbol(): dlsym error: %s",error);
        return NULL;
    }
    return symhandle;
}

/******************************************************************************
Function:   print_lcmaps_plugin
Description:
    print the lcmaps_plugindl_t structure

Parameters:
    debug_lvl: debugging level
    plugin:    plugin structure
Returns:
    1: succes
    0: failure
******************************************************************************/
static int print_lcmaps_plugin(
        int debug_lvl,
        lcmaps_plugindl_t * plugin
)
{
    int i=0;

    lcmaps_log_debug(debug_lvl,"\tplugin name                         : %s\n",plugin->pluginname);
    lcmaps_log_debug(debug_lvl,"\tplugin arguments                    : %s\n",plugin->pluginargs);
    lcmaps_log_debug(debug_lvl,"\tplugin address                      : x%x\n",plugin);
    lcmaps_log_debug(debug_lvl,"\tplugin size                         : %d\n",sizeof(lcmaps_plugindl_t));
    lcmaps_log_debug(debug_lvl,"\tplugin handle                       : x%x\n",plugin->handle);
    lcmaps_log_debug(debug_lvl,"\tplugin_initialize()                 : x%x\n",plugin->procs[INITPROC]);
    lcmaps_log_debug(debug_lvl,"\tplugin_run()                        : x%x\n",plugin->procs[RUNPROC]);
    lcmaps_log_debug(debug_lvl,"\tplugin_terminate()                  : x%x\n",plugin->procs[TERMPROC]);
    lcmaps_log_debug(debug_lvl,"\tplugin_introspect()                 : x%x\n",plugin->procs[INTROPROC]);
    lcmaps_log_debug(debug_lvl,"\tplugin init_argc                    : %d\n",plugin->init_argc);
    for (i=0; i < plugin->init_argc; i++)
        lcmaps_log_debug(debug_lvl,"\tplugin init_argv[%2d]                : %s\n",i,(plugin->init_argv)[i]);
    lcmaps_log_debug(debug_lvl,"\tplugin run_argc                     : %d\n",plugin->run_argc);
    for (i=0; i < plugin->run_argc; i++)
    {
        char * argType=NULL;

        argType=((plugin->run_argv)[i]).argType;
        lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d]                 : x%x\n",i,(plugin->run_argv)+i);
        lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d], argName        : %s\n",i,((plugin->run_argv)[i]).argName);
        lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d], argType        : %s\n",i,((plugin->run_argv)[i]).argType);
        lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d], argInOut       : %d\n",i,((plugin->run_argv)[i]).argInOut);
        lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d], value address  : x%x\n",i,((plugin->run_argv)[i]).value);
        if (strcmp("char *",argType) == 0)
        {
            char ** pstring;
            if ( ((plugin->run_argv)[i]).value != NULL)
            {
                pstring = (char **) (((plugin->run_argv)[i]).value);
                pstring = (char **) lcmaps_getArgValue(
                        ((plugin->run_argv)[i]).argName,
                        ((plugin->run_argv)[i]).argType,
                        plugin->run_argc,
                        plugin->run_argv
                );
                lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d], char * value   : %s\n",i,*pstring);
            }
            else
            {
                lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d], char * value   : none yet\n",i);
            }
        }
        if (strcmp("int",argType) == 0)
        {
            int * pint;
            if ( ((plugin->run_argv)[i]).value != NULL)
            {
                pint = (int *) (((plugin->run_argv)[i]).value);
                pint = (int *) lcmaps_getArgValue(
                        ((plugin->run_argv)[i]).argName,
                        ((plugin->run_argv)[i]).argType,
                        plugin->run_argc,
                        plugin->run_argv
                );
                lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d], int value      : %d\n",i,*pint);
            }
            else
            {
                lcmaps_log_debug(debug_lvl,"\tplugin run_argv[%2d], int value      : none yet\n",i);
            }
        }
    }
    lcmaps_log_debug(debug_lvl,"\tplugin next                         : x%x\n",plugin->next);
    if (plugin->next != NULL)
        lcmaps_log_debug(debug_lvl,"\tplugin_next                         : %s\n",(plugin->next)->pluginname);
    else
        lcmaps_log_debug(debug_lvl,"\tplugin_next                         : last plugin in list\n");

    return 1;
}

/******************************************************************************
Function:   clean_plugin_list
Description:
    clean (free) the list of plugins and call the plugin termination functions

Parameters:
    list:      pointer to list of plugins which has to be freeed.

Returns:
    1: succes
    0: failure
******************************************************************************/
static int clean_plugin_list(
        lcmaps_plugindl_t ** list
)
{
    int                           rc;
    lcmaps_plugindl_t *             plugin_entry=NULL;

    plugin_entry=*list;
    while (plugin_entry)
    {
        lcmaps_plugindl_t * plugin_next;
        int               i;

        rc = plugin_entry->procs[TERMPROC]();
        if (rc != LCMAPS_MOD_SUCCESS)
        {
            lcmaps_log(0,"lcmaps.mod-clean_plugin_list(): failed to terminate plugin module %s\n",
                    plugin_entry->pluginname);
        }
        lcmaps_log_debug(1, "lcmaps.mod-clean_plugin_list(): plugin module %s terminated\n",
                plugin_entry->pluginname);
        dlclose(plugin_entry->handle);

        plugin_next=plugin_entry->next;
        for (i=0; i < plugin_entry->init_argc; i++)
        {
            if ((plugin_entry->init_argv)[i] != NULL)
            {
                lcmaps_log_debug(3,"Freeing %d - %s\n",i,(plugin_entry->init_argv)[i]);
                free((plugin_entry->init_argv)[i]);
            }
        }
        free(plugin_entry);
        plugin_entry=plugin_next;
    }
    *list=plugin_entry=NULL;
    return 0;
}

/******************************************************************************
Function:   runPluginManager
Description:
    Run PluginManager:
    Contact Evaluation Manager with list of possible policies --> runs plugins

Parameters:
    request     : RSL request
    lcmaps_cred : user credential
    npols       : number of policies to be considered for evaluation
    policynames : the names of the policies to be considered for evaluation

Returns:
    0: user mapping succeeded
    1: user mapping failed
******************************************************************************/
int runPluginManager(
        lcmaps_request_t request,
        lcmaps_cred_id_t lcmaps_cred,
        int npols,
        char ** policynames
)
{
    lcmaps_plugindl_t * plugin_entry=NULL;

    /* To be done:
     * Take the run_argv array (of lcmaps_argument_t) and make a match on name and on type with the
     * lcmaps_variable[] list (created from request and lcmaps_cred)
     * make an array of void pointers to arguments --> fill in the lcmaps_plugindl_t structure
     */
    lcmaps_log_debug(2,"lcmaps.mod-runPluginManager(): extract RunVars\n");
    if (lcmaps_extractRunVars(request, lcmaps_cred) != 0)
    {
        lcmaps_log(0,"lcmaps.mod-runPluginManager(): error in creating list of run variables\n");
        return 1;
    }

    plugin_entry=plugin_list;
    while (plugin_entry)
    {
        void * pvalue=NULL;
        char * argName=NULL;
        char * argType=NULL;
        int iarg=0;

        for (iarg=0; iarg < plugin_entry->run_argc; iarg++)
        {
            argName=(plugin_entry->run_argv+iarg)->argName;
            argType=(plugin_entry->run_argv+iarg)->argType;
            lcmaps_log_debug(2,
                "lcmaps.mod-runPluginManager(): Getting value of \"%s\" of type \"%s\" for plugin \"%s\"\n",
                argName, argType, plugin_entry->pluginname);
            if ((pvalue=lcmaps_getRunVars(argName, argType)) == NULL)
            {
                lcmaps_log(0,
                    "lcmaps.mod-runPluginManager(): could not GET requested variable \"%s\" of type \"%s\" for plugin \"%s\"\n",
                    argName, argType, plugin_entry->pluginname);
                return 1;
            }
            lcmaps_log_debug(2,
                "lcmaps.mod-runPluginManager(): Setting value of \"%s\" of type \"%s\" for plugin \"%s\", address: 0x%x\n",
                argName, argType, plugin_entry->pluginname, pvalue);
            if (lcmaps_setArgValue(argName, argType, pvalue, plugin_entry->run_argc, &(plugin_entry->run_argv)) != 0)
            {
                lcmaps_log(0,
                    "lcmaps.mod-runPluginManager(): could not SET requested variable \"%s\" of type \"%s\" for plugin \"%s\"\n",
                    argName, argType, plugin_entry->pluginname);
                return 1;
            }
        }
        plugin_entry=plugin_entry->next;
    }

#if USE_EVALUATIONMANAGER
    if (npols > 0)
    {
        int ipol = 0;

        lcmaps_log_debug(1,"lcmaps.mod-runPluginManager(): Do runEvaluationManager with the following policies:\n");
        for (ipol = 0; ipol < npols; ipol ++)
            lcmaps_log_debug(1,"lcmaps.mod-runPluginManager():     %s\n", policynames[ipol]);
    }
    else
        lcmaps_log_debug(1,"lcmaps.mod-runPluginManager(): Do runEvaluationManager()\n");
    if (runEvaluationManager(npols, policynames) != 0)
    {
        lcmaps_log(0,"lcmaps.mod-runPluginManager(): Error running evaluation manager\n");
        return 1;
    }
    lcmaps_log_debug(1,"lcmaps.mod-runPluginManager(): runEvaluationManager() succeeded.\n");
#else
    /* The following will be taken over by the evaluation manager
     * It will call runPluginManager() directly and evaluate its return values
     */
    plugin_entry=plugin_list;
    while (plugin_entry)
    {
        print_lcmaps_plugin(2,plugin_entry);
        lcmaps_log_debug(2,"\n");
        lcmaps_log(0,"lcmaps.mod-runPluginManager(): running %s\n",plugin_entry->pluginname);
        if (runPlugin(plugin_entry->pluginname)) {
            lcmaps_log(0,"lcmaps.mod-runPluginManager(): plugin %s failed\n",plugin_entry->pluginname);
        }
        plugin_entry=plugin_entry->next;
    }
#endif
    return 0;
}

/******************************************************************************
Function:   resetCredentialData
Description:
    Reset the Credential data.
    Wrapper around cleanCredentialData() to be used
    by the Evaluation Manager, before a new policy is
    evaluated

Parameters:
    none
Returns:
    the return value of cleanCredentialData()
******************************************************************************/
int resetCredentialData()
{
    lcmaps_log_debug(1,"lcmaps.mod-resetCredentialData(): Called\n");
    return cleanCredentialData();
}

/******************************************************************************
Function:   runPlugin
Description:
    Run a plugin for the Evaluation Manager
    the result (succes or not will be passed to the Evaluation Manager)

Parameters:
    pluginname: the name of the plugin module
Returns:
    0: plugin run succeeded
    1: plugin run failed
******************************************************************************/
int runPlugin(
        const char * pluginname
)
{
    lcmaps_plugindl_t * plugin_entry=NULL;
    int rc=1;
    int foundplugin=0;

    /* To be done:
     * Search for the right plugin in lcmaps_plugindl_t structure
     * Run this plugin
     */

    plugin_entry=plugin_list;
    while (plugin_entry)
    {
        lcmaps_log_debug(3,"lcmaps.mod-runPlugin(): looking for plugin %s\n",pluginname);
        if (strcmp(plugin_entry->pluginname,pluginname) == 0) {
            lcmaps_log_time(0,"lcmaps.mod-runPlugin(): found plugin %s\n",plugin_entry->pluginname);
            foundplugin++;
            break;
        }
        plugin_entry=plugin_entry->next;
    }
    if (!foundplugin) {
        lcmaps_log(0,"lcmaps.mod-runPlugin(): could not find plugin %s\n",pluginname);
        return 1;
    }

    /* Actually run the plugin */
    lcmaps_log_time(0,"lcmaps.mod-runPlugin(): running plugin %s\n",plugin_entry->pluginname);
    rc = plugin_entry->procs[RUNPROC](plugin_entry->run_argc, plugin_entry->run_argv);

    return rc;
}

/******************************************************************************
Function:   stopPluginManager
Description:
    Terminate PluginManager module.

Parameters:
Returns:
    0: termination succeeded
    1: termination failed
******************************************************************************/
int stopPluginManager(
)
{
    lcmaps_log_debug(1,"lcmaps.mod-stopPluginManager(): cleaning credential data\n");
    printCredData(1);
    if (cleanCredentialData()!=0)
    {
        lcmaps_log(0,"lcmaps.mod-stopPluginManager() error: could not clean credential data list\n");
        return 1;
    }
    if (clean_plugin_list(&plugin_list)!=0)
    {
        lcmaps_log(0,"lcmaps.mod-stopPluginManager() error: could not clean up plugin list\n");
        return 1;
    }
#if USE_EVALUATIONMANAGER
    if (stopEvaluationManager() != 0)
    {
        lcmaps_log(0,"lcmaps.mod-stopPluginManager(): error in stopEvaluationManager()\n");
        return 1;
    }
#endif
    return 0;
}

---