LGPL
[vlc.git] / src / modules / modules.c
1 /*****************************************************************************
2  * modules.c : Builtin and plugin modules management functions
3  *****************************************************************************
4  * Copyright (C) 2001-2011 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Sam Hocevar <sam@zoy.org>
8  *          Ethan C. Baldridge <BaldridgeE@cadmus.com>
9  *          Hans-Peter Jansen <hpj@urpla.net>
10  *          Gildas Bazin <gbazin@videolan.org>
11  *          RĂ©mi Denis-Courmont
12  *
13  * This program is free software; you can redistribute it and/or modify it
14  * under the terms of the GNU Lesser General Public License as published by
15  * the Free Software Foundation; either version 2.1 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21  * GNU Lesser General Public License for more details.
22  *
23  * You should have received a copy of the GNU Lesser General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <stdlib.h>
33 #include <string.h>
34 #ifdef ENABLE_NLS
35 # include <libintl.h>
36 #endif
37 #include <assert.h>
38
39 #include <vlc_common.h>
40 #include <vlc_modules.h>
41 #include "libvlc.h"
42 #include "config/configuration.h"
43 #include "vlc_arrays.h"
44 #include "modules/modules.h"
45
46 /**
47  * Checks whether a module implements a capability.
48  *
49  * \param m the module
50  * \param cap the capability to check
51  * \return TRUE if the module have the capability
52  */
53 bool module_provides( const module_t *m, const char *cap )
54 {
55     if (unlikely(m->psz_capability == NULL))
56         return false;
57     return !strcmp( m->psz_capability, cap );
58 }
59
60 /**
61  * Get the internal name of a module
62  *
63  * \param m the module
64  * \return the module name
65  */
66 const char *module_get_object( const module_t *m )
67 {
68     if (unlikely(m->i_shortcuts == 0))
69         return "unnamed";
70     return m->pp_shortcuts[0];
71 }
72
73 /**
74  * Get the human-friendly name of a module.
75  *
76  * \param m the module
77  * \param long_name TRUE to have the long name of the module
78  * \return the short or long name of the module
79  */
80 const char *module_get_name( const module_t *m, bool long_name )
81 {
82     if( long_name && ( m->psz_longname != NULL) )
83         return m->psz_longname;
84
85     if (m->psz_shortname != NULL)
86         return m->psz_shortname;
87     return module_get_object (m);
88 }
89
90 /**
91  * Get the help for a module
92  *
93  * \param m the module
94  * \return the help
95  */
96 const char *module_get_help( const module_t *m )
97 {
98     return m->psz_help;
99 }
100
101 /**
102  * Get the capability for a module
103  *
104  * \param m the module
105  * return the capability
106  */
107 const char *module_get_capability( const module_t *m )
108 {
109     return m->psz_capability;
110 }
111
112 /**
113  * Get the score for a module
114  *
115  * \param m the module
116  * return the score for the capability
117  */
118 int module_get_score( const module_t *m )
119 {
120     return m->i_score;
121 }
122
123 /**
124  * Translate a string using the module's text domain
125  *
126  * \param m the module
127  * \param str the American English ASCII string to localize
128  * \return the gettext-translated string
129  */
130 const char *module_gettext (const module_t *m, const char *str)
131 {
132     if (m->parent != NULL)
133         m = m->parent;
134     if (unlikely(str == NULL || *str == '\0'))
135         return "";
136 #ifdef ENABLE_NLS
137     const char *domain = m->domain;
138     return dgettext ((domain != NULL) ? domain : PACKAGE_NAME, str);
139 #else
140     (void)m;
141     return str;
142 #endif
143 }
144
145 #undef module_start
146 int module_start (vlc_object_t *obj, const module_t *m)
147 {
148    int (*activate) (vlc_object_t *) = m->pf_activate;
149
150    return (activate != NULL) ? activate (obj) : VLC_SUCCESS;
151 }
152
153 #undef module_stop
154 void module_stop (vlc_object_t *obj, const module_t *m)
155 {
156    void (*deactivate) (vlc_object_t *) = m->pf_deactivate;
157
158     if (deactivate != NULL)
159         deactivate (obj);
160 }
161
162 typedef struct module_list_t
163 {
164     module_t *p_module;
165     int16_t  i_score;
166     bool     b_force;
167 } module_list_t;
168
169 static int modulecmp (const void *a, const void *b)
170 {
171     const module_list_t *la = a, *lb = b;
172     /* Note that qsort() uses _ascending_ order,
173      * so the smallest module is the one with the biggest score. */
174     return lb->i_score - la->i_score;
175 }
176
177 #undef vlc_module_load
178 /**
179  * Finds and instantiates the best module of a certain type.
180  * All candidates modules having the specified capability and name will be
181  * sorted in decreasing order of priority. Then the probe callback will be
182  * invoked for each module, until it succeeds (returns 0), or all candidate
183  * module failed to initialize.
184  *
185  * The probe callback first parameter is the address of the module entry point.
186  * Further parameters are passed as an argument list; it corresponds to the
187  * variable arguments passed to this function. This scheme is meant to
188  * support arbitrary prototypes for the module entry point.
189  *
190  * \param p_this VLC object
191  * \param psz_capability capability, i.e. class of module
192  * \param psz_name name name of the module asked, if any
193  * \param b_strict if true, do not fallback to plugin with a different name
194  *                 but the same capability
195  * \param probe module probe callback
196  * \return the module or NULL in case of a failure
197  */
198 module_t *vlc_module_load(vlc_object_t *p_this, const char *psz_capability,
199                           const char *psz_name, bool b_strict,
200                           vlc_activate_t probe, ...)
201 {
202     stats_TimerStart( p_this, "module_need()", STATS_TIMER_MODULE_NEED );
203
204     module_list_t *p_list;
205     module_t *p_module;
206     int i_shortcuts = 0;
207     char *psz_shortcuts = NULL, *psz_var = NULL, *psz_alias = NULL;
208     bool b_force_backup = p_this->b_force;
209
210     /* Deal with variables */
211     if( psz_name && psz_name[0] == '$' )
212     {
213         psz_name = psz_var = var_CreateGetString( p_this, psz_name + 1 );
214     }
215
216     /* Count how many different shortcuts were asked for */
217     if( psz_name && *psz_name )
218     {
219         char *psz_parser, *psz_last_shortcut;
220
221         /* If the user wants none, give him none. */
222         if( !strcmp( psz_name, "none" ) )
223         {
224             free( psz_var );
225             stats_TimerStop( p_this, STATS_TIMER_MODULE_NEED );
226             stats_TimerDump( p_this, STATS_TIMER_MODULE_NEED );
227             stats_TimerClean( p_this, STATS_TIMER_MODULE_NEED );
228             return NULL;
229         }
230
231         i_shortcuts++;
232         psz_parser = psz_shortcuts = psz_last_shortcut = strdup( psz_name );
233
234         while( ( psz_parser = strchr( psz_parser, ',' ) ) )
235         {
236              *psz_parser = '\0';
237              i_shortcuts++;
238              psz_last_shortcut = ++psz_parser;
239         }
240
241         /* Check if the user wants to override the "strict" mode */
242         if( psz_last_shortcut )
243         {
244             if( !strcmp(psz_last_shortcut, "none") )
245             {
246                 b_strict = true;
247                 i_shortcuts--;
248             }
249             else if( !strcmp(psz_last_shortcut, "any") )
250             {
251                 b_strict = false;
252                 i_shortcuts--;
253             }
254         }
255     }
256
257     /* Sort the modules and test them */
258     size_t count;
259     module_t **p_all = module_list_get (&count);
260     p_list = malloc( count * sizeof( module_list_t ) );
261
262     /* Parse the module list for capabilities and probe each of them */
263     count = 0;
264     for (size_t i = 0; (p_module = p_all[i]) != NULL; i++)
265     {
266         int i_shortcut_bonus = 0;
267
268         /* Test that this module can do what we need */
269         if( !module_provides( p_module, psz_capability ) )
270             continue;
271
272         /* If we required a shortcut, check this plugin provides it. */
273         if( i_shortcuts > 0 )
274         {
275             const char *name = psz_shortcuts;
276
277             for( unsigned i_short = i_shortcuts; i_short > 0; i_short-- )
278             {
279                 for( unsigned i = 0; i < p_module->i_shortcuts; i++ )
280                 {
281                     char *c;
282                     if( ( c = strchr( name, '@' ) )
283                         ? !strncasecmp( name, p_module->pp_shortcuts[i],
284                                         c-name )
285                         : !strcasecmp( name, p_module->pp_shortcuts[i] ) )
286                     {
287                         /* Found it */
288                         if( c && c[1] )
289                             psz_alias = c+1;
290                         i_shortcut_bonus = i_short * 10000;
291                         goto found_shortcut;
292                     }
293                 }
294
295                 /* Go to the next shortcut... This is so lame! */
296                 name += strlen( name ) + 1;
297             }
298
299             /* If we are in "strict" mode and we couldn't
300              * find the module in the list of provided shortcuts,
301              * then kick the bastard out of here!!! */
302             if( b_strict )
303                 continue;
304         }
305
306         /* Trash <= 0 scored plugins (they can only be selected by shortcut) */
307         if( p_module->i_score <= 0 )
308             continue;
309
310 found_shortcut:
311         /* Store this new module */
312         p_list[count].p_module = p_module;
313         p_list[count].i_score = p_module->i_score + i_shortcut_bonus;
314         p_list[count].b_force = i_shortcut_bonus && b_strict;
315         count++;
316     }
317
318     /* We can release the list, interesting modules are held */
319     module_list_free (p_all);
320
321     /* Sort candidates by descending score */
322     qsort (p_list, count, sizeof (p_list[0]), modulecmp);
323     msg_Dbg( p_this, "looking for %s module: %zu candidate%s", psz_capability,
324              count, count == 1 ? "" : "s" );
325
326     /* Parse the linked list and use the first successful module */
327     va_list args;
328
329     va_start(args, probe);
330     p_module = NULL;
331
332     for (size_t i = 0; (i < count) && (p_module == NULL); i++)
333     {
334         module_t *p_cand = p_list[i].p_module;
335
336         if (module_Map (p_this, p_cand))
337             continue;
338         p_this->b_force = p_list[i].b_force;
339
340         int ret;
341
342         if (likely(p_cand->pf_activate != NULL))
343         {
344             va_list ap;
345
346             va_copy(ap, args);
347             ret = probe(p_cand->pf_activate, ap);
348             va_end(ap);
349         }
350         else
351             ret = VLC_SUCCESS;
352
353         switch (ret)
354         {
355         case VLC_SUCCESS:
356             /* good module! */
357             p_module = p_cand;
358             break;
359
360         case VLC_ETIMEOUT:
361             /* good module, but aborted */
362             break;
363
364         default: /* bad module */
365             continue;
366         }
367     }
368
369     va_end (args);
370     free( p_list );
371     p_this->b_force = b_force_backup;
372
373     if( p_module != NULL )
374     {
375         msg_Dbg( p_this, "using %s module \"%s\"",
376                  psz_capability, module_get_object(p_module) );
377         vlc_object_set_name( p_this, psz_alias ? psz_alias
378                                                : module_get_object(p_module) );
379     }
380     else if( count == 0 )
381         msg_Dbg( p_this, "no %s module matched \"%s\"",
382                  psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
383     else
384         msg_Dbg( p_this, "no %s module matching \"%s\" could be loaded",
385                   psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
386
387     free( psz_shortcuts );
388     free( psz_var );
389
390     stats_TimerStop( p_this, STATS_TIMER_MODULE_NEED );
391     stats_TimerDump( p_this, STATS_TIMER_MODULE_NEED );
392     stats_TimerClean( p_this, STATS_TIMER_MODULE_NEED );
393
394     /* Don't forget that the module is still locked */
395     return p_module;
396 }
397
398
399 /**
400  * Deinstantiates a module.
401  * \param module the module pointer as returned by vlc_module_load()
402  * \param deinit deactivation callback
403  */
404 void vlc_module_unload(module_t *module, vlc_deactivate_t deinit, ...)
405 {
406     if (module->pf_deactivate != NULL)
407     {
408         va_list ap;
409
410         va_start(ap, deinit);
411         deinit(module->pf_deactivate, ap);
412         va_end(ap);
413     }
414 }
415
416
417 static int generic_start(void *func, va_list ap)
418 {
419     vlc_object_t *obj = va_arg(ap, vlc_object_t *);
420     int (*activate)(vlc_object_t *) = func;
421
422     return activate(obj);
423 }
424
425 static void generic_stop(void *func, va_list ap)
426 {
427     vlc_object_t *obj = va_arg(ap, vlc_object_t *);
428     void (*deactivate)(vlc_object_t *) = func;
429
430     deactivate(obj);
431 }
432
433 #undef module_need
434 module_t *module_need(vlc_object_t *obj, const char *cap, const char *name,
435                       bool strict)
436 {
437     return vlc_module_load(obj, cap, name, strict, generic_start, obj);
438 }
439
440 #undef module_unneed
441 void module_unneed(vlc_object_t *obj, module_t *module)
442 {
443     msg_Dbg(obj, "removing module \"%s\"", module_get_object(module));
444     vlc_module_unload(module, generic_stop, obj);
445 }
446
447 /**
448  * Get a pointer to a module_t given it's name.
449  *
450  * \param name the name of the module
451  * \return a pointer to the module or NULL in case of a failure
452  */
453 module_t *module_find (const char *name)
454 {
455     module_t **list, *module;
456
457     assert (name != NULL);
458     list = module_list_get (NULL);
459     if (!list)
460         return NULL;
461
462     for (size_t i = 0; (module = list[i]) != NULL; i++)
463     {
464         if (unlikely(module->i_shortcuts == 0))
465             continue;
466         if (!strcmp (module->pp_shortcuts[0], name))
467             break;
468     }
469     module_list_free (list);
470     return module;
471 }
472
473 /**
474  * Tell if a module exists and release it in thic case
475  *
476  * \param psz_name th name of the module
477  * \return TRUE if the module exists
478  */
479 bool module_exists (const char * psz_name)
480 {
481     return module_find (psz_name) != NULL;
482 }
483
484 /**
485  * Get a pointer to a module_t that matches a shortcut.
486  * This is a temporary hack for SD. Do not re-use (generally multiple modules
487  * can have the same shortcut, so this is *broken* - use module_need()!).
488  *
489  * \param psz_shortcut shortcut of the module
490  * \param psz_cap capability of the module
491  * \return a pointer to the module or NULL in case of a failure
492  */
493 module_t *module_find_by_shortcut (const char *psz_shortcut)
494 {
495     module_t **list, *module;
496
497     list = module_list_get (NULL);
498     if (!list)
499         return NULL;
500
501     for (size_t i = 0; (module = list[i]) != NULL; i++)
502         for (size_t j = 0; j < module->i_shortcuts; j++)
503             if (!strcmp (module->pp_shortcuts[j], psz_shortcut))
504                 goto out;
505 out:
506     module_list_free (list);
507     return module;
508 }
509
510 /**
511  * Get the configuration of a module
512  *
513  * \param module the module
514  * \param psize the size of the configuration returned
515  * \return the configuration as an array
516  */
517 module_config_t *module_config_get( const module_t *module, unsigned *restrict psize )
518 {
519     unsigned i,j;
520     unsigned size = module->confsize;
521     module_config_t *config = malloc( size * sizeof( *config ) );
522
523     assert( psize != NULL );
524     *psize = 0;
525
526     if( !config )
527         return NULL;
528
529     for( i = 0, j = 0; i < size; i++ )
530     {
531         const module_config_t *item = module->p_config + i;
532         if( item->b_internal /* internal option */
533          || item->b_removed /* removed option */ )
534             continue;
535
536         memcpy( config + j, item, sizeof( *config ) );
537         j++;
538     }
539     *psize = j;
540
541     return config;
542 }
543
544 /**
545  * Release the configuration
546  *
547  * \param the configuration
548  * \return nothing
549  */
550 void module_config_free( module_config_t *config )
551 {
552     free( config );
553 }