1

#include "module.h"

     2

#include "log.h"

     3

     4

#include <stdlib.h>

     5

#include <dlfcn.h>

     6

#include <string.h>

     7

#include <assert.h>

     8

     9

err_t modules_create (struct modules **modules_ptr, struct nexus *nexus)

    10

{

    11

    struct modules *modules;

    12

    13

    // alloc

    14

    if ((modules = calloc(1, sizeof(*modules))) == NULL)

    15

        return ERR_CALLOC;

    16

    17

    // init

    18

    TAILQ_INIT(&modules->list);

    19

    20

    // store

    21

    modules->nexus = nexus;

    22

    23

    // ok

    24

    *modules_ptr = modules;

    25

    26

    return SUCCESS;

    27

}

    28

    29

/**

    30

 * Load the symbol named "<module>_<suffix>".

    31

 */ 

    32

static err_t module_symbol (struct module *module, void **sym, const char *suffix)

    33

{

    34

    char sym_name[MODULE_SYMBOL_MAX];

    35

    36

    // validate the length of the suffix

    37

    assert(strlen(module->info.name) <= MODULE_NAME_MAX);

    38

    assert(strlen(suffix) <= MODULE_SUFFIX_MAX);

    39

    40

    // format

    41

    sprintf(sym_name, "%s_%s", module->info.name, suffix);

    42

    43

    // load

    44

    if ((*sym = dlsym(module->handle, sym_name)) == NULL)

    45

       return ERR_MODULE_SYM;

    46

    47

    // ok

    48

    return SUCCESS;

    49

}

    50

    51

err_t module_load (struct modules *modules, struct module **module_ptr, const struct module_info *info, struct error_info *err)

    52

{

    53

    struct module *module;

    54

    55

    // validate the module name

    56

    if (strlen(info->name) > MODULE_NAME_MAX)

    57

        return SET_ERROR(err, ERR_MODULE_NAME);

    58

    59

    // alloc

    60

    if ((module = calloc(1, sizeof(*module))) == NULL)

    61

        return SET_ERROR(err, ERR_CALLOC);

    62

    63

    // store

    64

    module->info = *info;

    65

    module->modules = modules;

    66

    67

    // clear dlerrors

    68

    (void) dlerror();

    69

    70

    // load it

    71

    if ((module->handle = dlopen(info->path, RTLD_NOW)) == NULL)

    72

        JUMP_SET_ERROR_STR(err, ERR_MODULE_OPEN, dlerror());

    73

    74

    // load the funcs symbol

    75

    if ((ERROR_CODE(err) = module_symbol(module, (void **) &module->funcs, "funcs")))

    76

        JUMP_SET_ERROR_STR(err, ERROR_CODE(err), dlerror());

    77

    78

    // call the init func

    79

    if ((module->funcs->init(modules->nexus, &module->ctx, err)))

    80

        goto error;

    81

    82

    // add to modules list

    83

    TAILQ_INSERT_TAIL(&modules->list, module, modules_list);

    84

    85

    // ok

    86

    if (module_ptr)

    87

        *module_ptr = module;

    88

    89

    return SUCCESS;

    90

    91

error:

    92

    // XXX: cleanup

    93

    free(module);

    94

    95

    return ERROR_CODE(err);    

    96

}

    97

    98

struct module* module_get (struct modules *modules, const char *name)

    99

{

   100

    struct module *module = NULL;

   101

   102

    // look for it...

   103

    TAILQ_FOREACH(module, &modules->list, modules_list) {

   104

        if (strcasecmp(module->info.name, name) == 0)

   105

            // found it

   106

            return module;

   107

    }

   108

   109

    // no such module

   110

    return NULL;

   111

}

   112

   113

err_t module_conf (struct module *module, const char *name, char *value, struct error_info *err)

   114

{

   115

    // call the conf func

   116

    return module->funcs->conf(module->ctx, name, value, err);

   117

}

   118

   119

err_t module_unload (struct module *module)

   120

{

   121

    err_t err;

   122

   123

    // invoke the unload func

   124

    if ((err = module->funcs->unload(module->ctx)))

   125

        return err;

   126

   127

    // ok

   128

    return SUCCESS;

   129

}

   130

   131

void module_destroy (struct module *module)

   132

{

   133

    // remove from modules list

   134

    TAILQ_REMOVE(&module->modules->list, module, modules_list);

   135

   136

    // unload the dl handle

   137

    if (dlclose(module->handle))

   138

        log_error("dlclose(%s): %s", module->info.name, dlerror());

   139

   140

    // free the module info

   141

    free(module);

   142

}

   143

   144

err_t modules_unload (struct modules *modules)

   145

{

   146

    struct module *module;

   147

    err_t err;

   148

   149

    // unload each module in turn

   150

    TAILQ_FOREACH(module, &modules->list, modules_list) {

   151

        if ((err = module_unload(module)))

   152

            log_warn("module_unload(%s) failed: %s", module->info.name, error_name(err));

   153

    }

   154

   155

    // ok

   156

    return SUCCESS;

   157

}

   158