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.1 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 <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <errno.h>
  31
  32 #include <pulse/xmalloc.h>
  33 #include <pulse/proplist.h>
  34
  35 #include <pulsecore/core-subscribe.h>
  36 #include <pulsecore/log.h>
  37 #include <pulsecore/core-util.h>
  38 #include <pulsecore/macro.h>
  39 #include <pulsecore/ltdl-helper.h>
  40 #include <pulsecore/modinfo.h>
  41
  42 #include "module.h"
  43
  44 #define PA_SYMBOL_INIT "pa__init"
  45 #define PA_SYMBOL_DONE "pa__done"
  46 #define PA_SYMBOL_LOAD_ONCE "pa__load_once"
  47 #define PA_SYMBOL_GET_N_USED "pa__get_n_used"
  48 #define PA_SYMBOL_GET_DEPRECATE "pa__get_deprecated"
  49
  50 pa_module* pa_module_load(pa_core *c, const char *name, const char *argument) {
  51     pa_module *m = NULL;
  52     pa_bool_t (*load_once)(void);
  53     const char* (*get_deprecated)(void);
  54     pa_modinfo *mi;
  55
  56     pa_assert(c);
  57     pa_assert(name);
  58
  59     if (c->disallow_module_loading)
  60         goto fail;
  61
  62     m = pa_xnew(pa_module, 1);
  63     m->name = pa_xstrdup(name);
  64     m->argument = pa_xstrdup(argument);
  65     m->load_once = FALSE;
  66     m->proplist = pa_proplist_new();
  67
  68     if (!(m->dl = lt_dlopenext(name))) {
  69         pa_log("Failed to open module \"%s\": %s", name, lt_dlerror());
  70         goto fail;
  71     }
  72
  73     if ((load_once = (pa_bool_t (*)(void)) pa_load_sym(m->dl, name, PA_SYMBOL_LOAD_ONCE))) {
  74
  75         m->load_once = load_once();
  76
  77         if (m->load_once) {
  78             pa_module *i;
  79             uint32_t idx;
  80             /* OK, the module only wants to be loaded once, let's make sure it is */
  81
  82             for (i = pa_idxset_first(c->modules, &idx); i; i = pa_idxset_next(c->modules, &idx)) {
  83                 if (strcmp(name, i->name) == 0) {
  84                     pa_log("Module \"%s\" should be loaded once at most. Refusing to load.", name);
  85                     goto fail;
  86                 }
  87             }
  88         }
  89     }
  90
  91     if ((get_deprecated = (const char* (*) (void)) pa_load_sym(m->dl, name, PA_SYMBOL_GET_DEPRECATE))) {
  92         const char *t;
  93
  94         if ((t = get_deprecated()))
  95             pa_log_warn("%s is deprecated: %s", name, t);
  96     }
  97
  98     if (!(m->init = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_INIT))) {
  99         pa_log("Failed to load module \"%s\": symbol \""PA_SYMBOL_INIT"\" not found.", name);
 100         goto fail;
 101     }
 102
 103     m->done = (void (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_DONE);
 104     m->get_n_used = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_GET_N_USED);
 105     m->userdata = NULL;
 106     m->core = c;
 107     m->unload_requested = FALSE;
 108
 109     if (m->init(m) < 0) {
 110         pa_log_error("Failed to load module \"%s\" (argument: \"%s\"): initialization failed.", name, argument ? argument : "");
 111         goto fail;
 112     }
 113
 114     pa_assert_se(pa_idxset_put(c->modules, m, &m->index) >= 0);
 115     pa_assert(m->index != PA_IDXSET_INVALID);
 116
 117     pa_log_info("Loaded \"%s\" (index: #%u; argument: \"%s\").", m->name, m->index, m->argument ? m->argument : "");
 118
 119     pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_NEW, m->index);
 120
 121     if ((mi = pa_modinfo_get_by_handle(m->dl, name))) {
 122
 123         if (mi->author && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_AUTHOR))
 124             pa_proplist_sets(m->proplist, PA_PROP_MODULE_AUTHOR, mi->author);
 125
 126         if (mi->description && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_DESCRIPTION))
 127             pa_proplist_sets(m->proplist, PA_PROP_MODULE_DESCRIPTION, mi->description);
 128
 129         if (mi->version && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_VERSION))
 130             pa_proplist_sets(m->proplist, PA_PROP_MODULE_VERSION, mi->version);
 131
 132         pa_modinfo_free(mi);
 133     }
 134
 135     return m;
 136
 137 fail:
 138
 139     if (m) {
 140         if (m->proplist)
 141             pa_proplist_free(m->proplist);
 142
 143         pa_xfree(m->argument);
 144         pa_xfree(m->name);
 145
 146         if (m->dl)
 147             lt_dlclose(m->dl);
 148
 149         pa_xfree(m);
 150     }
 151
 152     return NULL;
 153 }
 154
 155 static void pa_module_free(pa_module *m) {
 156     pa_assert(m);
 157     pa_assert(m->core);
 158
 159     pa_log_info("Unloading \"%s\" (index: #%u).", m->name, m->index);
 160
 161     if (m->done)
 162         m->done(m);
 163
 164     if (m->proplist)
 165         pa_proplist_free(m->proplist);
 166
 167     lt_dlclose(m->dl);
 168
 169     pa_log_info("Unloaded \"%s\" (index: #%u).", m->name, m->index);
 170
 171     pa_subscription_post(m->core, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_REMOVE, m->index);
 172
 173     pa_xfree(m->name);
 174     pa_xfree(m->argument);
 175     pa_xfree(m);
 176 }
 177
 178 void pa_module_unload(pa_core *c, pa_module *m, pa_bool_t force) {
 179     pa_assert(c);
 180     pa_assert(m);
 181
 182     if (m->core->disallow_module_loading && !force)
 183         return;
 184
 185     if (!(m = pa_idxset_remove_by_data(c->modules, m, NULL)))
 186         return;
 187
 188     pa_module_free(m);
 189 }
 190
 191 void pa_module_unload_by_index(pa_core *c, uint32_t idx, pa_bool_t force) {
 192     pa_module *m;
 193     pa_assert(c);
 194     pa_assert(idx != PA_IDXSET_INVALID);
 195
 196     if (c->disallow_module_loading && !force)
 197         return;
 198
 199     if (!(m = pa_idxset_remove_by_index(c->modules, idx)))
 200         return;
 201
 202     pa_module_free(m);
 203 }
 204
 205 void pa_module_unload_all(pa_core *c) {
 206     pa_module *m;
 207     pa_assert(c);
 208
 209     while ((m = pa_idxset_steal_first(c->modules, NULL)))
 210         pa_module_free(m);
 211
 212     if (c->module_defer_unload_event) {
 213         c->mainloop->defer_free(c->module_defer_unload_event);
 214         c->module_defer_unload_event = NULL;
 215     }
 216 }
 217
 218 static void defer_cb(pa_mainloop_api*api, pa_defer_event *e, void *userdata) {
 219     void *state = NULL;
 220     pa_core *c = PA_CORE(userdata);
 221     pa_module *m;
 222
 223     pa_core_assert_ref(c);
 224     api->defer_enable(e, 0);
 225
 226     while ((m = pa_idxset_iterate(c->modules, &state, NULL)))
 227         if (m->unload_requested)
 228             pa_module_unload(c, m, TRUE);
 229 }
 230
 231 void pa_module_unload_request(pa_module *m, pa_bool_t force) {
 232     pa_assert(m);
 233
 234     if (m->core->disallow_module_loading && !force)
 235         return;
 236
 237     m->unload_requested = TRUE;
 238
 239     if (!m->core->module_defer_unload_event)
 240         m->core->module_defer_unload_event = m->core->mainloop->defer_new(m->core->mainloop, defer_cb, m->core);
 241
 242     m->core->mainloop->defer_enable(m->core->module_defer_unload_event, 1);
 243 }
 244
 245 void pa_module_unload_request_by_index(pa_core *c, uint32_t idx, pa_bool_t force) {
 246     pa_module *m;
 247     pa_assert(c);
 248
 249     if (!(m = pa_idxset_get_by_index(c->modules, idx)))
 250         return;
 251
 252     pa_module_unload_request(m, force);
 253 }
 254
 255 int pa_module_get_n_used(pa_module*m) {
 256     pa_assert(m);
 257
 258     if (!m->get_n_used)
 259         return -1;
 260
 261     return m->get_n_used(m);
 262 }
 263
 264 void pa_module_update_proplist(pa_module *m, pa_update_mode_t mode, pa_proplist *p) {
 265     pa_assert(m);
 266
 267     if (p)
 268         pa_proplist_update(m->proplist, mode, p);
 269
 270     pa_subscription_post(m->core, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_CHANGE, m->index);
 271 }