/Users/maurits/Documents/studie/afstuderen/biosphere/daemon/module.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: feb 14, 2007
 * 
 * Function:
 * Module subsystem which loads and unloads pluggable modules.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */
 
#include "module.h"
#include "mutex.h"
#include "options.h"
#include "service.h"
#include "settings.h"
#include <biosphere_module.h>
#include <list.h>
#include <io.h>
#include <str.h>
#include <xml.h>

#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <apr_dso.h>
#include <apr_time.h>
#include <apr_strings.h>
#include <apr_file_io.h>

extern apr_pool_t *global_mp;

static bs_list *modules;


static bs_status set_definitions(module_info *modinfo, apr_pool_t *mp)
{
        bs_status rv;
        char *xmlbuf, *moddir, *wsdlpath;
        bs_uint64 len;
        unsigned type;
        void *object;
        
        /* Construct the filepath (thread-safe): */
        lock_option_mux();
    if (global_modules_dir) moddir = global_modules_dir;
    else moddir = BIOSPHERED_MODULES_DIR;
    wsdlpath = apr_pstrcat(mp, moddir, modinfo->def->services_definition, NULL);
    unlock_option_mux();
    
    /* Read the WSDL file: */
    rv = read_file_into_buf(wsdlpath, &xmlbuf, &len, mp);
    if (rv != BS_OK) return rv;
    
    /* Parse it: */
    rv = xlate_from_xml(xmlbuf, len, &object, &type, mp);
    if (rv != BS_OK || type != SERVICE_DEF_FROM_XML) return rv;
    modinfo->services = (bs_definition *) object;
    return BS_OK; 
}


bs_status load_module(const char *name)
{
        apr_status_t rv;
        bs_status rv2;
        apr_dso_handle_t *modh;
        module_info     *modinfo;
        char *fullpath;
        
        /* Scan the list to see if this module is not already loaded: */
        if (module_is_loaded(name)) {
                fprintf(stderr, "Module already loaded: %s\n", name);
                return BS_ERROR;        
        }
        
        /* Try to construct the filepath of the module: */
        printf("Loading module: %s\n", name);
        lock_pool_mux();
        fullpath = apr_pstrdup(global_mp, name);
        unlock_pool_mux();
        if (fullpath && fullpath[0] != '/') { /* Add path if necessary: */
                char *moddir = BIOSPHERED_MODULES_DIR;
                lock_option_mux();
                if (global_modules_dir) moddir = global_modules_dir;
                unlock_option_mux();
                lock_pool_mux();
                fullpath = apr_pstrcat(global_mp, moddir, name, NULL);
                unlock_pool_mux();
        }
        
        /* Perform the actual loading of the module: */
        lock_pool_mux();
        if ((rv = apr_dso_load(&modh, fullpath, global_mp)) != APR_SUCCESS) {
                char err[256];
        apr_strerror(rv, err, sizeof(err));
        fprintf(stderr, "Failure to load module '%s': %s\n", name, err);
        unlock_pool_mux();
        return BS_ERROR;
    }
    
    /* Create a module_info struct and fill it up: */
    modinfo = (module_info *) apr_palloc(global_mp, sizeof(module_info));
    modinfo->name = apr_pstrdup(global_mp, name);
    modinfo->modh = modh;
    modinfo->time_loaded = apr_time_now();
    rv = apr_dso_sym((apr_dso_handle_sym_t*) &modinfo->def, modh,
                "bsmod_symtable");
    if (rv != APR_SUCCESS) {
        char err[256];
        apr_strerror(rv, err, sizeof(err));
        fprintf(stderr, "Failure to load module symtable: %s\n", err);
        unlock_pool_mux();
        return BS_ERROR;
    }
    rv2 = set_definitions(modinfo, global_mp);
    if (rv2 != BS_OK) {
        fprintf(stderr, "Failure to parse WSDL file of module: %s\n", name);
        unlock_pool_mux();
        return BS_ERROR;
    }
    unlock_pool_mux();
    
    /* Install the system-wide service handler,
     * call the modules initialization routine and add service: */
    modinfo->def->syshandler = handle_service_request;
    rv2 = modinfo->def->init();
    if (rv2 != BS_OK) return rv2;
    printf("Successfully loaded module: %s\n", modinfo->def->name);
    rv2 = add_service(modinfo->services, modinfo->def->handler);
    if (rv2 != BS_OK) {
        fprintf(stderr, "Failure to add module services: %s\n", name);
        return BS_ERROR;
    }
    
    /* Finally add it to the modules list: */
    lock_module_mux();
    list_append(modules, modinfo);
    unlock_module_mux();
        return BS_OK;
}


bs_status unload_module(const char *name)
{
        unsigned i;
        printf("Unloading module %s...", name);
        
        /* Search the modules list for the named module: */
        lock_module_mux();
        for (i = 0; i < list_size(modules); i++) {
                module_info *mi = list_index(modules, i);
                if (streq(mi->name, name)) {
                        bs_status rv;
                        
                        mi->def->cleanup();
                        apr_dso_unload(mi->modh);
                        list_remove(modules, i);
                        unlock_module_mux();
                        
                        rv = remove_service(mi->services->name);
                        
                        printf("OK\n");
                        return BS_OK;
                }
        }
        
        /* Module was apparently not found: */
        unlock_module_mux();
        printf("ERROR\n");
        fprintf(stderr, "Module not found while unloading: %s\n", name);
        return BS_ERROR;
}


bs_status unload_all_modules(void)
{
        lock_module_mux();
        while (list_size(modules) > 0) {
                bs_status rv;
                module_info *mi;
                
                mi = list_index(modules, 0);
                mi->def->cleanup();
                apr_dso_unload(mi->modh);
                list_remove(modules, 0);
                
                rv = remove_service(mi->services->name);
                if (rv != BS_OK) {
                        fprintf(stderr, "error while remove services for module %s", mi->name);
                        unlock_module_mux();
                        return rv;      
                }
        }
        unlock_module_mux();
        return BS_OK;   
}


bs_status init_module(apr_pool_t *mp)
{
        unsigned i;
        
        modules = new_list(mp); /* Don't worry about threads yet... */
        for (i = 0; global_module_names_list && i < list_size(global_module_names_list); i++) {
                char *tmp = list_index(global_module_names_list, i);
                if (load_module(tmp) != BS_OK) return BS_ERROR;
        }
        return BS_OK;
}


bs_module *get_module_info(const char *name)
{
        unsigned i;
        
        lock_module_mux();
        for (i = 0; i < list_size(modules); i++) {
                module_info *mi = list_index(modules, i);
                if (streq(mi->name, name)) {
                        unlock_module_mux();
                        return mi->def;
                }
        }
        
        /* Module could not be found... */
        unlock_module_mux();
        return NULL;    
}


bs_status get_module_descriptions(bs_list *names, 
                bs_list *fnames, bs_list *versions, bs_list *descriptions)
{
        unsigned i;
        assert(names && fnames && versions && descriptions);
        
        lock_module_mux();
        for (i = 0; i < list_size(modules); i++) {
                char *mname, *descr, *fname, *version;
                module_info *mi = list_index(modules, i);
                
                mname = apr_pstrdup(names->pool, mi->name);
                list_append(names, mname);
                
                version = apr_psprintf(fnames->pool, "%d.%d", mi->def->module_major,
                                mi->def->module_minor);
                list_append(versions, version);
                
                fname = apr_pstrdup(names->pool, mi->def->name);
                list_append(fnames, fname);
                
                descr = apr_pstrdup(descriptions->pool, mi->def->description);
                list_append(descriptions, descr);
        }
        unlock_module_mux();
        return BS_OK;
}

---