code.delx.au - pulseaudio/blob - src/pulsecore/module.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <limits.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <ctype.h>
  33
  34 #include <pulse/timeval.h>
  35 #include <pulse/xmalloc.h>
  36 #include <pulse/proplist.h>
  37
  38 #include <pulsecore/core-subscribe.h>
  39 #include <pulsecore/log.h>
  40 #include <pulsecore/core-util.h>
  41 #include <pulsecore/macro.h>
  42 #include <pulsecore/ltdl-helper.h>
  43 #include <pulsecore/modinfo.h>
  44
  45 #include "module.h"
  46
  47 #define PA_SYMBOL_INIT "pa__init"
  48 #define PA_SYMBOL_DONE "pa__done"
  49 #define PA_SYMBOL_LOAD_ONCE "pa__load_once"
  50 #define PA_SYMBOL_GET_N_USED "pa__get_n_used"
  51
  52 pa_module* pa_module_load(pa_core *c, const char *name, const char *argument) {
  53     pa_module *m = NULL;
  54     pa_bool_t (*load_once)(void);
  55     pa_modinfo *mi;
  56
  57     pa_assert(c);
  58     pa_assert(name);
  59
  60     if (c->disallow_module_loading)
  61         goto fail;
  62
  63     m = pa_xnew(pa_module, 1);
  64     m->name = pa_xstrdup(name);
  65     m->argument = pa_xstrdup(argument);
  66     m->load_once = FALSE;
  67     m->proplist = pa_proplist_new();
  68
  69     if (!(m->dl = lt_dlopenext(name))) {
  70         pa_log("Failed to open module \"%s\": %s", name, lt_dlerror());
  71         goto fail;
  72     }
  73
  74     if ((load_once = (pa_bool_t (*)(void)) pa_load_sym(m->dl, name, PA_SYMBOL_LOAD_ONCE))) {
  75
  76         m->load_once = load_once();
  77
  78         if (m->load_once && c->modules) {
  79             pa_module *i;
  80             uint32_t idx;
  81             /* OK, the module only wants to be loaded once, let's make sure it is */
  82
  83             for (i = pa_idxset_first(c->modules, &idx); i; i = pa_idxset_next(c->modules, &idx)) {
  84                 if (strcmp(name, i->name) == 0) {
  85                     pa_log("Module \"%s\" should be loaded once at most. Refusing to load.", name);
  86                     goto fail;
  87                 }
  88             }
  89         }
  90     }
  91
  92     if (!(m->init = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_INIT))) {
  93         pa_log("Failed to load module \"%s\": symbol \""PA_SYMBOL_INIT"\" not found.", name);
  94         goto fail;
  95     }
  96
  97     m->done = (void (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_DONE);
  98     m->get_n_used = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_GET_N_USED);
  99     m->userdata = NULL;
 100     m->core = c;
 101     m->unload_requested = FALSE;
 102
 103     if (m->init(m) < 0) {
 104         pa_log_error("Failed to load  module \"%s\" (argument: \"%s\"): initialization failed.", name, argument ? argument : "");
 105         goto fail;
 106     }
 107
 108     if (!c->modules)
 109         c->modules = pa_idxset_new(NULL, NULL);
 110
 111     pa_assert_se(pa_idxset_put(c->modules, m, &m->index) >= 0);
 112     pa_assert(m->index != PA_IDXSET_INVALID);
 113
 114     pa_log_info("Loaded \"%s\" (index: #%u; argument: \"%s\").", m->name, m->index, m->argument ? m->argument : "");
 115
 116     pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_NEW, m->index);
 117
 118     if ((mi = pa_modinfo_get_by_handle(m->dl, name))) {
 119
 120         if (mi->author && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_AUTHOR))
 121             pa_proplist_sets(m->proplist, PA_PROP_MODULE_AUTHOR, mi->author);
 122
 123         if (mi->description && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_DESCRIPTION))
 124             pa_proplist_sets(m->proplist, PA_PROP_MODULE_DESCRIPTION, mi->description);
 125
 126         if (mi->version && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_VERSION))
 127             pa_proplist_sets(m->proplist, PA_PROP_MODULE_VERSION, mi->version);
 128
 129         pa_modinfo_free(mi);
 130     }
 131
 132     return m;
 133
 134 fail:
 135
 136     if (m) {
 137         if (m->proplist)
 138             pa_proplist_free(m->proplist);
 139
 140         pa_xfree(m->argument);
 141         pa_xfree(m->name);
 142
 143         if (m->dl)
 144             lt_dlclose(m->dl);
 145
 146         pa_xfree(m);
 147     }
 148
 149     return NULL;
 150 }
 151
 152 static void pa_module_free(pa_module *m) {
 153     pa_assert(m);
 154     pa_assert(m->core);
 155
 156     pa_log_info("Unloading \"%s\" (index: #%u).", m->name, m->index);
 157
 158     if (m->done)
 159         m->done(m);
 160
 161     if (m->proplist)
 162         pa_proplist_free(m->proplist);
 163
 164     lt_dlclose(m->dl);
 165
 166     pa_log_info("Unloaded \"%s\" (index: #%u).", m->name, m->index);
 167
 168     pa_subscription_post(m->core, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_REMOVE, m->index);
 169
 170     pa_xfree(m->name);
 171     pa_xfree(m->argument);
 172     pa_xfree(m);
 173 }
 174
 175 void pa_module_unload(pa_core *c, pa_module *m, pa_bool_t force) {
 176     pa_assert(c);
 177     pa_assert(m);
 178
 179     if (m->core->disallow_module_loading && !force)
 180         return;
 181
 182     if (!(m = pa_idxset_remove_by_data(c->modules, m, NULL)))
 183         return;
 184
 185     pa_module_free(m);
 186 }
 187
 188 void pa_module_unload_by_index(pa_core *c, uint32_t idx, pa_bool_t force) {
 189     pa_module *m;
 190     pa_assert(c);
 191     pa_assert(idx != PA_IDXSET_INVALID);
 192
 193     if (c->disallow_module_loading && !force)
 194         return;
 195
 196     if (!(m = pa_idxset_remove_by_index(c->modules, idx)))
 197         return;
 198
 199     pa_module_free(m);
 200 }
 201
 202 void pa_module_unload_all(pa_core *c) {
 203     pa_assert(c);
 204
 205     if (c->modules) {
 206         pa_module *m;
 207
 208         while ((m = pa_idxset_steal_first(c->modules, NULL)))
 209             pa_module_free(m);
 210
 211         pa_idxset_free(c->modules, NULL, NULL);
 212         c->modules = NULL;
 213     }
 214
 215     if (c->module_defer_unload_event) {
 216         c->mainloop->defer_free(c->module_defer_unload_event);
 217         c->module_defer_unload_event = NULL;
 218     }
 219 }
 220
 221 static void defer_cb(pa_mainloop_api*api, pa_defer_event *e, void *userdata) {
 222     void *state = NULL;
 223     pa_core *c = PA_CORE(userdata);
 224     pa_module *m;
 225
 226     pa_core_assert_ref(c);
 227     api->defer_enable(e, 0);
 228
 229     if (!c->modules)
 230         return;
 231
 232     while ((m = pa_idxset_iterate(c->modules, &state, NULL)))
 233         if (m->unload_requested)
 234             pa_module_unload(c, m, TRUE);
 235 }
 236
 237 void pa_module_unload_request(pa_module *m, pa_bool_t force) {
 238     pa_assert(m);
 239
 240     if (m->core->disallow_module_loading && !force)
 241         return;
 242
 243     m->unload_requested = TRUE;
 244
 245     if (!m->core->module_defer_unload_event)
 246         m->core->module_defer_unload_event = m->core->mainloop->defer_new(m->core->mainloop, defer_cb, m->core);
 247
 248     m->core->mainloop->defer_enable(m->core->module_defer_unload_event, 1);
 249 }
 250
 251 void pa_module_unload_request_by_index(pa_core *c, uint32_t idx, pa_bool_t force) {
 252     pa_module *m;
 253     pa_assert(c);
 254
 255     if (!(m = pa_idxset_get_by_index(c->modules, idx)))
 256         return;
 257
 258     pa_module_unload_request(m, force);
 259 }
 260
 261 int pa_module_get_n_used(pa_module*m) {
 262     pa_assert(m);
 263
 264     if (!m->get_n_used)
 265         return -1;
 266
 267     return m->get_n_used(m);
 268 }