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_actions.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 int config_GetType(const char *psz_name)
  50 {
  51     module_config_t *p_config = config_FindConfig(psz_name);
  52
  53     /* sanity checks */
  54     if( !p_config )
  55     {
  56         return 0;
  57     }
  58
  59     switch( CONFIG_CLASS(p_config->i_type) )
  60     {
  61         case CONFIG_ITEM_FLOAT:
  62             return VLC_VAR_FLOAT;
  63         case CONFIG_ITEM_INTEGER:
  64             return VLC_VAR_INTEGER;
  65         case CONFIG_ITEM_BOOL:
  66             return VLC_VAR_BOOL;
  67         case CONFIG_ITEM_STRING:
  68             return VLC_VAR_STRING;
  69         default:
  70             return 0;
  71     }
  72 }
  73
  74 bool config_IsSafe( const char *name )
  75 {
  76     module_config_t *p_config = config_FindConfig( name );
  77     return p_config != NULL && p_config->b_safe;
  78 }
  79
  80 int64_t config_GetInt(const char *psz_name)
  81 {
  82     module_config_t *p_config = config_FindConfig( psz_name );
  83
  84     /* sanity checks */
  85     assert(p_config != NULL);
  86     assert(IsConfigIntegerType(p_config->i_type));
  87
  88     int64_t val;
  89
  90     vlc_rwlock_rdlock (&config_lock);
  91     val = p_config->value.i;
  92     vlc_rwlock_unlock (&config_lock);
  93     return val;
  94 }
  95
  96 float config_GetFloat(const char *psz_name)
  97 {
  98     module_config_t *p_config;
  99
 100     p_config = config_FindConfig( psz_name );
 101
 102     /* sanity checks */
 103     assert(p_config != NULL);
 104     assert(IsConfigFloatType(p_config->i_type));
 105
 106     float val;
 107
 108     vlc_rwlock_rdlock (&config_lock);
 109     val = p_config->value.f;
 110     vlc_rwlock_unlock (&config_lock);
 111     return val;
 112 }
 113
 114 char *config_GetPsz(const char *psz_name)
 115 {
 116     module_config_t *p_config;
 117
 118     p_config = config_FindConfig( psz_name );
 119
 120     /* sanity checks */
 121     assert(p_config != NULL);
 122     assert(IsConfigStringType (p_config->i_type));
 123
 124     /* return a copy of the string */
 125     vlc_rwlock_rdlock (&config_lock);
 126     char *psz_value = strdupnull (p_config->value.psz);
 127     vlc_rwlock_unlock (&config_lock);
 128
 129     return psz_value;
 130 }
 131
 132 void config_PutPsz(const char *psz_name, const char *psz_value)
 133 {
 134     module_config_t *p_config = config_FindConfig( psz_name );
 135
 136
 137     /* sanity checks */
 138     assert(p_config != NULL);
 139     assert(IsConfigStringType(p_config->i_type));
 140
 141     char *str, *oldstr;
 142     if ((psz_value != NULL) && *psz_value)
 143         str = strdup (psz_value);
 144     else
 145         str = NULL;
 146
 147     vlc_rwlock_wrlock (&config_lock);
 148     oldstr = (char *)p_config->value.psz;
 149     p_config->value.psz = str;
 150     config_dirty = true;
 151     vlc_rwlock_unlock (&config_lock);
 152
 153     free (oldstr);
 154 }
 155
 156 void config_PutInt(const char *psz_name, int64_t i_value )
 157 {
 158     module_config_t *p_config = config_FindConfig( psz_name );
 159
 160     /* sanity checks */
 161     assert(p_config != NULL);
 162     assert(IsConfigIntegerType(p_config->i_type));
 163
 164     if (i_value < p_config->min.i)
 165         i_value = p_config->min.i;
 166     if (i_value > p_config->max.i)
 167         i_value = p_config->max.i;
 168
 169     vlc_rwlock_wrlock (&config_lock);
 170     p_config->value.i = i_value;
 171     config_dirty = true;
 172     vlc_rwlock_unlock (&config_lock);
 173 }
 174
 175 void config_PutFloat(const char *psz_name, float f_value)
 176 {
 177     module_config_t *p_config = config_FindConfig( psz_name );
 178
 179     /* sanity checks */
 180     assert(p_config != NULL);
 181     assert(IsConfigFloatType(p_config->i_type));
 182
 183     /* if f_min == f_max == 0, then do not use them */
 184     if ((p_config->min.f == 0.f) && (p_config->max.f == 0.f))
 185         ;
 186     else if (f_value < p_config->min.f)
 187         f_value = p_config->min.f;
 188     else if (f_value > p_config->max.f)
 189         f_value = p_config->max.f;
 190
 191     vlc_rwlock_wrlock (&config_lock);
 192     p_config->value.f = f_value;
 193     config_dirty = true;
 194     vlc_rwlock_unlock (&config_lock);
 195 }
 196
 197 ssize_t config_GetIntChoices(const char *name,
 198                              int64_t **restrict values, char ***restrict texts)
 199 {
 200     *values = NULL;
 201     *texts = NULL;
 202
 203     module_config_t *cfg = config_FindConfig(name);
 204     assert(cfg != NULL);
 205
 206     size_t count = cfg->list_count;
 207     if (count == 0)
 208     {
 209         if (module_Map(NULL, cfg->owner))
 210         {
 211             errno = EIO;
 212             return -1;
 213         }
 214
 215         if (cfg->list.i_cb == NULL)
 216             return 0;
 217         return cfg->list.i_cb(name, values, texts);
 218     }
 219
 220     int64_t *vals = vlc_alloc (count, sizeof (*vals));
 221     char **txts = vlc_alloc (count, sizeof (*txts));
 222     if (vals == NULL || txts == NULL)
 223     {
 224         errno = ENOMEM;
 225         goto error;
 226     }
 227
 228     for (size_t i = 0; i < count; i++)
 229     {
 230         vals[i] = cfg->list.i[i];
 231         /* FIXME: use module_gettext() instead */
 232         txts[i] = strdup ((cfg->list_text[i] != NULL)
 233                                        ? vlc_gettext (cfg->list_text[i]) : "");
 234         if (unlikely(txts[i] == NULL))
 235         {
 236             for (int j = i - 1; j >= 0; --j)
 237                 free(txts[j]);
 238             errno = ENOMEM;
 239             goto error;
 240         }
 241     }
 242
 243     *values = vals;
 244     *texts = txts;
 245     return count;
 246 error:
 247
 248     free(vals);
 249     free(txts);
 250     return -1;
 251 }
 252
 253
 254 static ssize_t config_ListModules (const char *cap, char ***restrict values,
 255                                    char ***restrict texts)
 256 {
 257     module_t **list;
 258     ssize_t n = module_list_cap (&list, cap);
 259     if (unlikely(n < 0))
 260     {
 261         *values = *texts = NULL;
 262         return n;
 263     }
 264
 265     char **vals = xmalloc ((n + 2) * sizeof (*vals));
 266     char **txts = xmalloc ((n + 2) * sizeof (*txts));
 267
 268     vals[0] = xstrdup ("any");
 269     txts[0] = xstrdup (_("Automatic"));
 270
 271     for (ssize_t i = 0; i < n; i++)
 272     {
 273         vals[i + 1] = xstrdup (module_get_object (list[i]));
 274         txts[i + 1] = xstrdup (module_gettext (list[i],
 275                                module_get_name (list[i], true)));
 276     }
 277
 278     vals[n + 1] = xstrdup ("none");
 279     txts[n + 1] = xstrdup (_("Disable"));
 280
 281     *values = vals;
 282     *texts = txts;
 283     module_list_free (list);
 284     return n + 2;
 285 }
 286
 287 ssize_t config_GetPszChoices(const char *name,
 288                              char ***restrict values, char ***restrict texts)
 289 {
 290     *values = *texts = NULL;
 291
 292     module_config_t *cfg = config_FindConfig(name);
 293     if (cfg == NULL)
 294     {
 295         errno = ENOENT;
 296         return -1;
 297     }
 298
 299     switch (cfg->i_type)
 300     {
 301         case CONFIG_ITEM_MODULE:
 302             return config_ListModules (cfg->psz_type, values, texts);
 303         default:
 304             if (!IsConfigStringType (cfg->i_type))
 305             {
 306                 errno = EINVAL;
 307                 return -1;
 308             }
 309             break;
 310     }
 311
 312     size_t count = cfg->list_count;
 313     if (count == 0)
 314     {
 315         if (module_Map(NULL, cfg->owner))
 316         {
 317             errno = EIO;
 318             return -1;
 319         }
 320
 321         if (cfg->list.psz_cb == NULL)
 322             return 0;
 323         return cfg->list.psz_cb(name, values, texts);
 324     }
 325
 326     char **vals = xmalloc (sizeof (*vals) * count);
 327     char **txts = xmalloc (sizeof (*txts) * count);
 328
 329     for (size_t i = 0; i < count; i++)
 330     {
 331         vals[i] = xstrdup ((cfg->list.psz[i] != NULL) ? cfg->list.psz[i] : "");
 332         /* FIXME: use module_gettext() instead */
 333         txts[i] = xstrdup ((cfg->list_text[i] != NULL)
 334                                        ? vlc_gettext (cfg->list_text[i]) : "");
 335     }
 336
 337     *values = vals;
 338     *texts = txts;
 339     return count;
 340 }
 341
 342 static int confcmp (const void *a, const void *b)
 343 {
 344     const module_config_t *const *ca = a, *const *cb = b;
 345
 346     return strcmp ((*ca)->psz_name, (*cb)->psz_name);
 347 }
 348
 349 static int confnamecmp (const void *key, const void *elem)
 350 {
 351     const module_config_t *const *conf = elem;
 352
 353     return strcmp (key, (*conf)->psz_name);
 354 }
 355
 356 static struct
 357 {
 358     module_config_t **list;
 359     size_t count;
 360 } config = { NULL, 0 };
 361
 362 /**
 363  * Index the configuration items by name for faster lookups.
 364  */
 365 int config_SortConfig (void)
 366 {
 367     vlc_plugin_t *p;
 368     size_t nconf = 0;
 369
 370     for (p = vlc_plugins; p != NULL; p = p->next)
 371          nconf += p->conf.size;
 372
 373     module_config_t **clist = vlc_alloc (nconf, sizeof (*clist));
 374     if (unlikely(clist == NULL))
 375         return VLC_ENOMEM;
 376
 377     nconf = 0;
 378     for (p = vlc_plugins; p != NULL; p = p->next)
 379     {
 380         module_config_t *item, *end;
 381
 382         for (item = p->conf.items, end = item + p->conf.size;
 383              item < end;
 384              item++)
 385         {
 386             if (!CONFIG_ITEM(item->i_type))
 387                 continue; /* ignore hints */
 388             clist[nconf++] = item;
 389         }
 390     }
 391
 392     qsort (clist, nconf, sizeof (*clist), confcmp);
 393
 394     config.list = clist;
 395     config.count = nconf;
 396     return VLC_SUCCESS;
 397 }
 398
 399 void config_UnsortConfig (void)
 400 {
 401     module_config_t **clist;
 402
 403     clist = config.list;
 404     config.list = NULL;
 405     config.count = 0;
 406
 407     free (clist);
 408 }
 409
 410 module_config_t *config_FindConfig(const char *name)
 411 {
 412     if (unlikely(name == NULL))
 413         return NULL;
 414
 415     module_config_t *const *p;
 416     p = bsearch (name, config.list, config.count, sizeof (*p), confnamecmp);
 417     return p ? *p : NULL;
 418 }
 419
 420 /**
 421  * Destroys an array of configuration items.
 422  * \param config start of array of items
 423  * \param confsize number of items in the array
 424  */
 425 void config_Free (module_config_t *tab, size_t confsize)
 426 {
 427     for (size_t j = 0; j < confsize; j++)
 428     {
 429         module_config_t *p_item = &tab[j];
 430
 431         if (IsConfigStringType (p_item->i_type))
 432         {
 433             free (p_item->value.psz);
 434             if (p_item->list_count)
 435                 free (p_item->list.psz);
 436         }
 437
 438         free (p_item->list_text);
 439     }
 440
 441     free (tab);
 442 }
 443
 444 void config_ResetAll(void)
 445 {
 446     vlc_rwlock_wrlock (&config_lock);
 447     for (vlc_plugin_t *p = vlc_plugins; p != NULL; p = p->next)
 448     {
 449         for (size_t i = 0; i < p->conf.size; i++ )
 450         {
 451             module_config_t *p_config = p->conf.items + i;
 452
 453             if (IsConfigIntegerType (p_config->i_type))
 454                 p_config->value.i = p_config->orig.i;
 455             else
 456             if (IsConfigFloatType (p_config->i_type))
 457                 p_config->value.f = p_config->orig.f;
 458             else
 459             if (IsConfigStringType (p_config->i_type))
 460             {
 461                 free ((char *)p_config->value.psz);
 462                 p_config->value.psz =
 463                         strdupnull (p_config->orig.psz);
 464             }
 465         }
 466     }
 467     vlc_rwlock_unlock (&config_lock);
 468 }