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     m->index = PA_IDXSET_INVALID;
  68
  69     if (!(m->dl = lt_dlopenext(name))) {
  70         /* We used to print the error that is returned by lt_dlerror(), but
  71          * lt_dlerror() is useless. It returns pretty much always "file not
  72          * found". That's because if there are any problems with loading the
  73          * module with normal loaders, libltdl falls back to the "preload"
  74          * loader, which never finds anything, and therefore says "file not
  75          * found". */
  76         pa_log("Failed to open module \"%s\".", name);
  77         goto fail;
  78     }
  79
  80     if ((load_once = (pa_bool_t (*)(void)) pa_load_sym(m->dl, name, PA_SYMBOL_LOAD_ONCE))) {
  81
  82         m->load_once = load_once();
  83
  84         if (m->load_once) {
  85             pa_module *i;
  86             uint32_t idx;
  87             /* OK, the module only wants to be loaded once, let's make sure it is */
  88
  89             PA_IDXSET_FOREACH(i, c->modules, idx) {
  90                 if (pa_streq(name, i->name)) {
  91                     pa_log("Module \"%s\" should be loaded once at most. Refusing to load.", name);
  92                     goto fail;
  93                 }
  94             }
  95         }
  96     }
  97
  98     if ((get_deprecated = (const char* (*) (void)) pa_load_sym(m->dl, name, PA_SYMBOL_GET_DEPRECATE))) {
  99         const char *t;
 100
 101         if ((t = get_deprecated()))
 102             pa_log_warn("%s is deprecated: %s", name, t);
 103     }
 104
 105     if (!(m->init = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_INIT))) {
 106         pa_log("Failed to load module \"%s\": symbol \""PA_SYMBOL_INIT"\" not found.", name);
 107         goto fail;
 108     }
 109
 110     m->done = (void (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_DONE);
 111     m->get_n_used = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_GET_N_USED);
 112     m->userdata = NULL;
 113     m->core = c;
 114     m->unload_requested = FALSE;
 115
 116     if (m->init(m) < 0) {
 117         pa_log_error("Failed to load module \"%s\" (argument: \"%s\"): initialization failed.", name, argument ? argument : "");
 118         goto fail;
 119     }
 120
 121     pa_assert_se(pa_idxset_put(c->modules, m, &m->index) >= 0);
 122     pa_assert(m->index != PA_IDXSET_INVALID);
 123
 124     pa_log_info("Loaded \"%s\" (index: #%u; argument: \"%s\").", m->name, m->index, m->argument ? m->argument : "");
 125
 126     pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_NEW, m->index);
 127
 128     if ((mi = pa_modinfo_get_by_handle(m->dl, name))) {
 129
 130         if (mi->author && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_AUTHOR))
 131             pa_proplist_sets(m->proplist, PA_PROP_MODULE_AUTHOR, mi->author);
 132
 133         if (mi->description && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_DESCRIPTION))
 134             pa_proplist_sets(m->proplist, PA_PROP_MODULE_DESCRIPTION, mi->description);
 135
 136         if (mi->version && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_VERSION))
 137             pa_proplist_sets(m->proplist, PA_PROP_MODULE_VERSION, mi->version);
 138
 139         pa_modinfo_free(mi);
 140     }
 141
 142     return m;
 143
 144 fail:
 145
 146     if (m) {
 147         if (m->proplist)
 148             pa_proplist_free(m->proplist);
 149
 150         pa_xfree(m->argument);
 151         pa_xfree(m->name);
 152
 153         if (m->dl)
 154             lt_dlclose(m->dl);
 155
 156         pa_xfree(m);
 157     }
 158
 159     return NULL;
 160 }
 161
 162 static void pa_module_free(pa_module *m) {
 163     pa_assert(m);
 164     pa_assert(m->core);
 165
 166     pa_log_info("Unloading \"%s\" (index: #%u).", m->name, m->index);
 167
 168     if (m->done)
 169         m->done(m);
 170
 171     if (m->proplist)
 172         pa_proplist_free(m->proplist);
 173
 174     lt_dlclose(m->dl);
 175
 176     pa_log_info("Unloaded \"%s\" (index: #%u).", m->name, m->index);
 177
 178     pa_subscription_post(m->core, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_REMOVE, m->index);
 179
 180     pa_xfree(m->name);
 181     pa_xfree(m->argument);
 182     pa_xfree(m);
 183 }
 184
 185 void pa_module_unload(pa_core *c, pa_module *m, pa_bool_t force) {
 186     pa_assert(c);
 187     pa_assert(m);
 188
 189     if (m->core->disallow_module_loading && !force)
 190         return;
 191
 192     if (!(m = pa_idxset_remove_by_data(c->modules, m, NULL)))
 193         return;
 194
 195     pa_module_free(m);
 196 }
 197
 198 void pa_module_unload_by_index(pa_core *c, uint32_t idx, pa_bool_t force) {
 199     pa_module *m;
 200     pa_assert(c);
 201     pa_assert(idx != PA_IDXSET_INVALID);
 202
 203     if (c->disallow_module_loading && !force)
 204         return;
 205
 206     if (!(m = pa_idxset_remove_by_index(c->modules, idx)))
 207         return;
 208
 209     pa_module_free(m);
 210 }
 211
 212 void pa_module_unload_all(pa_core *c) {
 213     pa_module *m;
 214     uint32_t *indices;
 215     uint32_t state;
 216     int i;
 217
 218     pa_assert(c);
 219     pa_assert(c->modules);
 220
 221     /* Unload modules in reverse order by default */
 222     indices = pa_xnew(uint32_t, pa_idxset_size(c->modules));
 223     i = 0;
 224     PA_IDXSET_FOREACH(m, c->modules, state)
 225         indices[i++] = state;
 226     pa_assert(i == (int) pa_idxset_size(c->modules));
 227     i--;
 228     for (; i >= 0; i--) {
 229         m = pa_idxset_remove_by_index(c->modules, indices[i]);
 230         if (m)
 231             pa_module_free(m);
 232     }
 233     pa_xfree(indices);
 234
 235     /* Just in case module unloading caused more modules to load */
 236     pa_idxset_remove_all(c->modules, (pa_free_cb_t) pa_module_free);
 237
 238     if (c->module_defer_unload_event) {
 239         c->mainloop->defer_free(c->module_defer_unload_event);
 240         c->module_defer_unload_event = NULL;
 241     }
 242 }
 243
 244 static void defer_cb(pa_mainloop_api*api, pa_defer_event *e, void *userdata) {
 245     void *state = NULL;
 246     pa_core *c = PA_CORE(userdata);
 247     pa_module *m;
 248
 249     pa_core_assert_ref(c);
 250     api->defer_enable(e, 0);
 251
 252     while ((m = pa_idxset_iterate(c->modules, &state, NULL)))
 253         if (m->unload_requested)
 254             pa_module_unload(c, m, TRUE);
 255 }
 256
 257 void pa_module_unload_request(pa_module *m, pa_bool_t force) {
 258     pa_assert(m);
 259
 260     if (m->core->disallow_module_loading && !force)
 261         return;
 262
 263     m->unload_requested = TRUE;
 264
 265     if (!m->core->module_defer_unload_event)
 266         m->core->module_defer_unload_event = m->core->mainloop->defer_new(m->core->mainloop, defer_cb, m->core);
 267
 268     m->core->mainloop->defer_enable(m->core->module_defer_unload_event, 1);
 269 }
 270
 271 void pa_module_unload_request_by_index(pa_core *c, uint32_t idx, pa_bool_t force) {
 272     pa_module *m;
 273     pa_assert(c);
 274
 275     if (!(m = pa_idxset_get_by_index(c->modules, idx)))
 276         return;
 277
 278     pa_module_unload_request(m, force);
 279 }
 280
 281 int pa_module_get_n_used(pa_module*m) {
 282     pa_assert(m);
 283
 284     if (!m->get_n_used)
 285         return -1;
 286
 287     return m->get_n_used(m);
 288 }
 289
 290 void pa_module_update_proplist(pa_module *m, pa_update_mode_t mode, pa_proplist *p) {
 291     pa_assert(m);
 292
 293     if (p)
 294         pa_proplist_update(m->proplist, mode, p);
 295
 296     pa_subscription_post(m->core, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_CHANGE, m->index);
 297 }