296cc37a005f22749b8ae28e8dd09b66dc609450
[vlc.git] / src / config / core.c
1 /*****************************************************************************
2  * core.c management of the modules configuration
3  *****************************************************************************
4  * Copyright (C) 2001-2007 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include <vlc_common.h>
29 #include <vlc_keys.h>
30 #include <vlc_modules.h>
31 #include <vlc_plugin.h>
32
33 #include "vlc_configuration.h"
34
35 #include <errno.h>
36 #include <assert.h>
37
38 #include "configuration.h"
39 #include "modules/modules.h"
40
41 vlc_rwlock_t config_lock = VLC_STATIC_RWLOCK;
42 bool config_dirty = false;
43
44 static inline char *strdupnull (const char *src)
45 {
46     return src ? strdup (src) : NULL;
47 }
48
49 /*****************************************************************************
50  * config_GetType: get the type of a variable (bool, int, float, string)
51  *****************************************************************************
52  * This function is used to get the type of a variable from its name.
53  *****************************************************************************/
54 int config_GetType(const char *psz_name)
55 {
56     module_config_t *p_config = config_FindConfig(psz_name);
57
58     /* sanity checks */
59     if( !p_config )
60     {
61         return 0;
62     }
63
64     switch( CONFIG_CLASS(p_config->i_type) )
65     {
66         case CONFIG_ITEM_FLOAT:
67             return VLC_VAR_FLOAT;
68         case CONFIG_ITEM_INTEGER:
69             return VLC_VAR_INTEGER;
70         case CONFIG_ITEM_BOOL:
71             return VLC_VAR_BOOL;
72         case CONFIG_ITEM_STRING:
73             return VLC_VAR_STRING;
74         default:
75             return 0;
76     }
77 }
78
79 bool config_IsSafe( const char *name )
80 {
81     module_config_t *p_config = config_FindConfig( name );
82     return p_config != NULL && p_config->b_safe;
83 }
84
85 #undef config_GetInt
86 /*****************************************************************************
87  * config_GetInt: get the value of an int variable
88  *****************************************************************************
89  * This function is used to get the value of variables which are internally
90  * represented by an integer (CONFIG_ITEM_INTEGER and
91  * CONFIG_ITEM_BOOL).
92  *****************************************************************************/
93 int64_t config_GetInt( vlc_object_t *p_this, const char *psz_name )
94 {
95     module_config_t *p_config = config_FindConfig( psz_name );
96
97     /* sanity checks */
98     if( !p_config )
99     {
100         msg_Err( p_this, "option %s does not exist", psz_name );
101         return -1;
102     }
103
104     if (!IsConfigIntegerType (p_config->i_type))
105     {
106         msg_Err( p_this, "option %s does not refer to an int", psz_name );
107         return -1;
108     }
109
110     int64_t val;
111
112     vlc_rwlock_rdlock (&config_lock);
113     val = p_config->value.i;
114     vlc_rwlock_unlock (&config_lock);
115     return val;
116 }
117
118 #undef config_GetFloat
119 /*****************************************************************************
120  * config_GetFloat: get the value of a float variable
121  *****************************************************************************
122  * This function is used to get the value of variables which are internally
123  * represented by a float (CONFIG_ITEM_FLOAT).
124  *****************************************************************************/
125 float config_GetFloat( vlc_object_t *p_this, const char *psz_name )
126 {
127     module_config_t *p_config;
128
129     p_config = config_FindConfig( psz_name );
130
131     /* sanity checks */
132     if( !p_config )
133     {
134         msg_Err( p_this, "option %s does not exist", psz_name );
135         return -1;
136     }
137
138     if (!IsConfigFloatType (p_config->i_type))
139     {
140         msg_Err( p_this, "option %s does not refer to a float", psz_name );
141         return -1;
142     }
143
144     float val;
145
146     vlc_rwlock_rdlock (&config_lock);
147     val = p_config->value.f;
148     vlc_rwlock_unlock (&config_lock);
149     return val;
150 }
151
152 #undef config_GetPsz
153 /*****************************************************************************
154  * config_GetPsz: get the string value of a string variable
155  *****************************************************************************
156  * This function is used to get the value of variables which are internally
157  * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_*FILE,
158  * CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE).
159  *
160  * Important note: remember to free() the returned char* because it's a
161  *   duplicate of the actual value. It isn't safe to return a pointer to the
162  *   actual value as it can be modified at any time.
163  *****************************************************************************/
164 char * config_GetPsz( vlc_object_t *p_this, const char *psz_name )
165 {
166     module_config_t *p_config;
167
168     p_config = config_FindConfig( psz_name );
169
170     /* sanity checks */
171     if( !p_config )
172     {
173         msg_Err( p_this, "option %s does not exist", psz_name );
174         return NULL;
175     }
176
177     if (!IsConfigStringType (p_config->i_type))
178     {
179         msg_Err( p_this, "option %s does not refer to a string", psz_name );
180         return NULL;
181     }
182
183     /* return a copy of the string */
184     vlc_rwlock_rdlock (&config_lock);
185     char *psz_value = strdupnull (p_config->value.psz);
186     vlc_rwlock_unlock (&config_lock);
187
188     return psz_value;
189 }
190
191 #undef config_PutPsz
192 /*****************************************************************************
193  * config_PutPsz: set the string value of a string variable
194  *****************************************************************************
195  * This function is used to set the value of variables which are internally
196  * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_*FILE,
197  * CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE).
198  *****************************************************************************/
199 void config_PutPsz( vlc_object_t *p_this,
200                       const char *psz_name, const char *psz_value )
201 {
202     module_config_t *p_config = config_FindConfig( psz_name );
203
204
205     /* sanity checks */
206     if( !p_config )
207     {
208         msg_Warn( p_this, "option %s does not exist", psz_name );
209         return;
210     }
211
212     if (!IsConfigStringType (p_config->i_type))
213     {
214         msg_Err( p_this, "option %s does not refer to a string", psz_name );
215         return;
216     }
217
218     char *str, *oldstr;
219     if ((psz_value != NULL) && *psz_value)
220         str = strdup (psz_value);
221     else
222         str = NULL;
223
224     vlc_rwlock_wrlock (&config_lock);
225     oldstr = (char *)p_config->value.psz;
226     p_config->value.psz = str;
227     config_dirty = true;
228     vlc_rwlock_unlock (&config_lock);
229
230     free (oldstr);
231 }
232
233 #undef config_PutInt
234 /*****************************************************************************
235  * config_PutInt: set the integer value of an int variable
236  *****************************************************************************
237  * This function is used to set the value of variables which are internally
238  * represented by an integer (CONFIG_ITEM_INTEGER and
239  * CONFIG_ITEM_BOOL).
240  *****************************************************************************/
241 void config_PutInt( vlc_object_t *p_this, const char *psz_name,
242                     int64_t i_value )
243 {
244     module_config_t *p_config = config_FindConfig( psz_name );
245
246     /* sanity checks */
247     if( !p_config )
248     {
249         msg_Warn( p_this, "option %s does not exist", psz_name );
250         return;
251     }
252
253     if (!IsConfigIntegerType (p_config->i_type))
254     {
255         msg_Err( p_this, "option %s does not refer to an int", psz_name );
256         return;
257     }
258
259     if (i_value < p_config->min.i)
260         i_value = p_config->min.i;
261     if (i_value > p_config->max.i)
262         i_value = p_config->max.i;
263
264     vlc_rwlock_wrlock (&config_lock);
265     p_config->value.i = i_value;
266     config_dirty = true;
267     vlc_rwlock_unlock (&config_lock);
268 }
269
270 #undef config_PutFloat
271 /*****************************************************************************
272  * config_PutFloat: set the value of a float variable
273  *****************************************************************************
274  * This function is used to set the value of variables which are internally
275  * represented by a float (CONFIG_ITEM_FLOAT).
276  *****************************************************************************/
277 void config_PutFloat( vlc_object_t *p_this,
278                       const char *psz_name, float f_value )
279 {
280     module_config_t *p_config = config_FindConfig( psz_name );
281
282     /* sanity checks */
283     if( !p_config )
284     {
285         msg_Warn( p_this, "option %s does not exist", psz_name );
286         return;
287     }
288
289     if (!IsConfigFloatType (p_config->i_type))
290     {
291         msg_Err( p_this, "option %s does not refer to a float", psz_name );
292         return;
293     }
294
295     /* if f_min == f_max == 0, then do not use them */
296     if ((p_config->min.f == 0) && (p_config->max.f == 0))
297         ;
298     else if (f_value < p_config->min.f)
299         f_value = p_config->min.f;
300     else if (f_value > p_config->max.f)
301         f_value = p_config->max.f;
302
303     vlc_rwlock_wrlock (&config_lock);
304     p_config->value.f = f_value;
305     config_dirty = true;
306     vlc_rwlock_unlock (&config_lock);
307 }
308
309 /**
310  * Determines a list of suggested values for an integer configuration item.
311  * \param values pointer to a table of integer values [OUT]
312  * \param texts pointer to a table of descriptions strings [OUT]
313  * \return number of choices, or -1 on error
314  * \note the caller is responsible for calling free() on all descriptions and
315  * on both tables. In case of error, both pointers are set to NULL.
316  */
317 ssize_t config_GetIntChoices (vlc_object_t *obj, const char *name,
318                              int64_t **restrict values, char ***restrict texts)
319 {
320     *values = NULL;
321     *texts = NULL;
322
323     module_config_t *cfg = config_FindConfig(name);
324     if (cfg == NULL)
325     {
326         msg_Warn (obj, "option %s does not exist", name);
327         errno = ENOENT;
328         return -1;
329     }
330
331     size_t count = cfg->list_count;
332     if (count == 0)
333     {
334         if (module_Map(obj, cfg->owner))
335         {
336             errno = EIO;
337             return -1;
338         }
339
340         if (cfg->list.i_cb == NULL)
341             return 0;
342         return cfg->list.i_cb(obj, name, values, texts);
343     }
344
345     int64_t *vals = malloc (sizeof (*vals) * count);
346     char **txts = malloc (sizeof (*txts) * count);
347     if (vals == NULL || txts == NULL)
348     {
349         errno = ENOMEM;
350         goto error;
351     }
352
353     for (size_t i = 0; i < count; i++)
354     {
355         vals[i] = cfg->list.i[i];
356         /* FIXME: use module_gettext() instead */
357         txts[i] = strdup ((cfg->list_text[i] != NULL)
358                                        ? vlc_gettext (cfg->list_text[i]) : "");
359         if (unlikely(txts[i] == NULL))
360         {
361             for (int j = i - 1; j >= 0; --j)
362                 free(txts[j]);
363             errno = ENOMEM;
364             goto error;
365         }
366     }
367
368     *values = vals;
369     *texts = txts;
370     return count;
371 error:
372
373     free(vals);
374     free(txts);
375     return -1;
376 }
377
378
379 static ssize_t config_ListModules (const char *cap, char ***restrict values,
380                                    char ***restrict texts)
381 {
382     module_t **list;
383     ssize_t n = module_list_cap (&list, cap);
384     if (n <= 0)
385     {
386         *values = *texts = NULL;
387         module_list_free (list);
388         return n;
389     }
390
391     char **vals = xmalloc ((n + 2) * sizeof (*vals));
392     char **txts = xmalloc ((n + 2) * sizeof (*txts));
393
394     vals[0] = xstrdup ("any");
395     txts[0] = xstrdup (_("Automatic"));
396
397     for (ssize_t i = 0; i < n; i++)
398     {
399         vals[i + 1] = xstrdup (module_get_object (list[i]));
400         txts[i + 1] = xstrdup (module_gettext (list[i],
401                                module_get_name (list[i], true)));
402     }
403
404     vals[n + 1] = xstrdup ("none");
405     txts[n + 1] = xstrdup (_("Disable"));
406
407     *values = vals;
408     *texts = txts;
409     module_list_free (list);
410     return n + 2;
411 }
412
413 /**
414  * Determines a list of suggested values for a string configuration item.
415  * \param values pointer to a table of value strings [OUT]
416  * \param texts pointer to a table of descriptions strings [OUT]
417  * \return number of choices, or -1 on error
418  * \note the caller is responsible for calling free() on all values, on all
419  * descriptions and on both tables.
420  * In case of error, both pointers are set to NULL.
421  */
422 ssize_t config_GetPszChoices (vlc_object_t *obj, const char *name,
423                               char ***restrict values, char ***restrict texts)
424 {
425     *values = *texts = NULL;
426
427     module_config_t *cfg = config_FindConfig(name);
428     if (cfg == NULL)
429     {
430         errno = ENOENT;
431         return -1;
432     }
433
434     switch (cfg->i_type)
435     {
436         case CONFIG_ITEM_MODULE:
437             return config_ListModules (cfg->psz_type, values, texts);
438         default:
439             if (!IsConfigStringType (cfg->i_type))
440             {
441                 errno = EINVAL;
442                 return -1;
443             }
444             break;
445     }
446
447     size_t count = cfg->list_count;
448     if (count == 0)
449     {
450         if (module_Map(obj, cfg->owner))
451         {
452             errno = EIO;
453             return -1;
454         }
455
456         if (cfg->list.psz_cb == NULL)
457             return 0;
458         return cfg->list.psz_cb(obj, name, values, texts);
459     }
460
461     char **vals = xmalloc (sizeof (*vals) * count);
462     char **txts = xmalloc (sizeof (*txts) * count);
463
464     for (size_t i = 0; i < count; i++)
465     {
466         vals[i] = xstrdup ((cfg->list.psz[i] != NULL) ? cfg->list.psz[i] : "");
467         /* FIXME: use module_gettext() instead */
468         txts[i] = xstrdup ((cfg->list_text[i] != NULL)
469                                        ? vlc_gettext (cfg->list_text[i]) : "");
470     }
471
472     *values = vals;
473     *texts = txts;
474     return count;
475 }
476
477 static int confcmp (const void *a, const void *b)
478 {
479     const module_config_t *const *ca = a, *const *cb = b;
480
481     return strcmp ((*ca)->psz_name, (*cb)->psz_name);
482 }
483
484 static int confnamecmp (const void *key, const void *elem)
485 {
486     const module_config_t *const *conf = elem;
487
488     return strcmp (key, (*conf)->psz_name);
489 }
490
491 static struct
492 {
493     module_config_t **list;
494     size_t count;
495 } config = { NULL, 0 };
496
497 /**
498  * Index the configuration items by name for faster lookups.
499  */
500 int config_SortConfig (void)
501 {
502     vlc_plugin_t *p;
503     size_t nconf = 0;
504
505     for (p = vlc_plugins; p != NULL; p = p->next)
506          nconf += p->conf.size;
507
508     module_config_t **clist = malloc (sizeof (*clist) * nconf);
509     if (unlikely(clist == NULL))
510         return VLC_ENOMEM;
511
512     nconf = 0;
513     for (p = vlc_plugins; p != NULL; p = p->next)
514     {
515         module_config_t *item, *end;
516
517         for (item = p->conf.items, end = item + p->conf.size;
518              item < end;
519              item++)
520         {
521             if (!CONFIG_ITEM(item->i_type))
522                 continue; /* ignore hints */
523             clist[nconf++] = item;
524         }
525     }
526
527     qsort (clist, nconf, sizeof (*clist), confcmp);
528
529     config.list = clist;
530     config.count = nconf;
531     return VLC_SUCCESS;
532 }
533
534 void config_UnsortConfig (void)
535 {
536     module_config_t **clist;
537
538     clist = config.list;
539     config.list = NULL;
540     config.count = 0;
541
542     free (clist);
543 }
544
545 /*****************************************************************************
546  * config_FindConfig: find the config structure associated with an option.
547  *****************************************************************************/
548 module_config_t *config_FindConfig(const char *name)
549 {
550     if (unlikely(name == NULL))
551         return NULL;
552
553     module_config_t *const *p;
554     p = bsearch (name, config.list, config.count, sizeof (*p), confnamecmp);
555     return p ? *p : NULL;
556 }
557
558 /**
559  * Destroys an array of configuration items.
560  * \param config start of array of items
561  * \param confsize number of items in the array
562  */
563 void config_Free (module_config_t *tab, size_t confsize)
564 {
565     for (size_t j = 0; j < confsize; j++)
566     {
567         module_config_t *p_item = &tab[j];
568
569         if (IsConfigStringType (p_item->i_type))
570         {
571             free (p_item->value.psz);
572             if (p_item->list_count)
573                 free (p_item->list.psz);
574         }
575
576         free (p_item->list_text);
577     }
578
579     free (tab);
580 }
581
582 #undef config_ResetAll
583 /*****************************************************************************
584  * config_ResetAll: reset the configuration data for all the modules.
585  *****************************************************************************/
586 void config_ResetAll( vlc_object_t *p_this )
587 {
588     vlc_rwlock_wrlock (&config_lock);
589     for (vlc_plugin_t *p = vlc_plugins; p != NULL; p = p->next)
590     {
591         for (size_t i = 0; i < p->conf.size; i++ )
592         {
593             module_config_t *p_config = p->conf.items + i;
594
595             if (IsConfigIntegerType (p_config->i_type))
596                 p_config->value.i = p_config->orig.i;
597             else
598             if (IsConfigFloatType (p_config->i_type))
599                 p_config->value.f = p_config->orig.f;
600             else
601             if (IsConfigStringType (p_config->i_type))
602             {
603                 free ((char *)p_config->value.psz);
604                 p_config->value.psz =
605                         strdupnull (p_config->orig.psz);
606             }
607         }
608     }
609     vlc_rwlock_unlock (&config_lock);
610
611     VLC_UNUSED(p_this);
612 }