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) {
  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     pa_assert_se(pa_idxset_put(c->modules, m, &m->index) >= 0);
 109     pa_assert(m->index != PA_IDXSET_INVALID);
 110
 111     pa_log_info("Loaded \"%s\" (index: #%u; argument: \"%s\").", m->name, m->index, m->argument ? m->argument : "");
 112
 113     pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_NEW, m->index);
 114
 115     if ((mi = pa_modinfo_get_by_handle(m->dl, name))) {
 116
 117         if (mi->author && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_AUTHOR))
 118             pa_proplist_sets(m->proplist, PA_PROP_MODULE_AUTHOR, mi->author);
 119
 120         if (mi->description && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_DESCRIPTION))
 121             pa_proplist_sets(m->proplist, PA_PROP_MODULE_DESCRIPTION, mi->description);
 122
 123         if (mi->version && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_VERSION))
 124             pa_proplist_sets(m->proplist, PA_PROP_MODULE_VERSION, mi->version);
 125
 126         pa_modinfo_free(mi);
 127     }
 128
 129     return m;
 130
 131 fail:
 132
 133     if (m) {
 134         if (m->proplist)
 135             pa_proplist_free(m->proplist);
 136
 137         pa_xfree(m->argument);
 138         pa_xfree(m->name);
 139
 140         if (m->dl)
 141             lt_dlclose(m->dl);
 142
 143         pa_xfree(m);
 144     }
 145
 146     return NULL;
 147 }
 148
 149 static void pa_module_free(pa_module *m) {
 150     pa_assert(m);
 151     pa_assert(m->core);
 152
 153     pa_log_info("Unloading \"%s\" (index: #%u).", m->name, m->index);
 154
 155     if (m->done)
 156         m->done(m);
 157
 158     if (m->proplist)
 159         pa_proplist_free(m->proplist);
 160
 161     lt_dlclose(m->dl);
 162
 163     pa_log_info("Unloaded \"%s\" (index: #%u).", m->name, m->index);
 164
 165     pa_subscription_post(m->core, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_REMOVE, m->index);
 166
 167     pa_xfree(m->name);
 168     pa_xfree(m->argument);
 169     pa_xfree(m);
 170 }
 171
 172 void pa_module_unload(pa_core *c, pa_module *m, pa_bool_t force) {
 173     pa_assert(c);
 174     pa_assert(m);
 175
 176     if (m->core->disallow_module_loading && !force)
 177         return;
 178
 179     if (!(m = pa_idxset_remove_by_data(c->modules, m, NULL)))
 180         return;
 181
 182     pa_module_free(m);
 183 }
 184
 185 void pa_module_unload_by_index(pa_core *c, uint32_t idx, pa_bool_t force) {
 186     pa_module *m;
 187     pa_assert(c);
 188     pa_assert(idx != PA_IDXSET_INVALID);
 189
 190     if (c->disallow_module_loading && !force)
 191         return;
 192
 193     if (!(m = pa_idxset_remove_by_index(c->modules, idx)))
 194         return;
 195
 196     pa_module_free(m);
 197 }
 198
 199 void pa_module_unload_all(pa_core *c) {
 200     pa_module *m;
 201     pa_assert(c);
 202
 203     while ((m = pa_idxset_steal_first(c->modules, NULL)))
 204         pa_module_free(m);
 205
 206     if (c->module_defer_unload_event) {
 207         c->mainloop->defer_free(c->module_defer_unload_event);
 208         c->module_defer_unload_event = NULL;
 209     }
 210 }
 211
 212 static void defer_cb(pa_mainloop_api*api, pa_defer_event *e, void *userdata) {
 213     void *state = NULL;
 214     pa_core *c = PA_CORE(userdata);
 215     pa_module *m;
 216
 217     pa_core_assert_ref(c);
 218     api->defer_enable(e, 0);
 219
 220     while ((m = pa_idxset_iterate(c->modules, &state, NULL)))
 221         if (m->unload_requested)
 222             pa_module_unload(c, m, TRUE);
 223 }
 224
 225 void pa_module_unload_request(pa_module *m, pa_bool_t force) {
 226     pa_assert(m);
 227
 228     if (m->core->disallow_module_loading && !force)
 229         return;
 230
 231     m->unload_requested = TRUE;
 232
 233     if (!m->core->module_defer_unload_event)
 234         m->core->module_defer_unload_event = m->core->mainloop->defer_new(m->core->mainloop, defer_cb, m->core);
 235
 236     m->core->mainloop->defer_enable(m->core->module_defer_unload_event, 1);
 237 }
 238
 239 void pa_module_unload_request_by_index(pa_core *c, uint32_t idx, pa_bool_t force) {
 240     pa_module *m;
 241     pa_assert(c);
 242
 243     if (!(m = pa_idxset_get_by_index(c->modules, idx)))
 244         return;
 245
 246     pa_module_unload_request(m, force);
 247 }
 248
 249 int pa_module_get_n_used(pa_module*m) {
 250     pa_assert(m);
 251
 252     if (!m->get_n_used)
 253         return -1;
 254
 255     return m->get_n_used(m);
 256 }