X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fconfig%2Fcore.c;h=9882c525cc24fcbd4303b4c850b7d18bc5b17226;hb=ec3df8f49c7d48389c79226db6acf00a511e7e0e;hp=c1ae9be6bcb249e961fb73e76f80f17d9ee1c7fa;hpb=4fe6d5bc0d11f92648ce6465174d67adea8b38d5;p=vlc diff --git a/src/config/core.c b/src/config/core.c index c1ae9be6bc..9882c525cc 100644 --- a/src/config/core.c +++ b/src/config/core.c @@ -1,103 +1,59 @@ /***************************************************************************** * core.c management of the modules configuration ***************************************************************************** - * Copyright (C) 2001-2007 the VideoLAN team + * Copyright (C) 2001-2007 VLC authors and VideoLAN * $Id$ * * Authors: Gildas Bazin * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ #ifdef HAVE_CONFIG_H # include "config.h" #endif -#include -#include "../libvlc.h" -#include "vlc_keys.h" -#include "vlc_charset.h" +#include +#include +#include +#include + #include "vlc_configuration.h" -#include /* errno */ +#include #include -#include - -#ifdef HAVE_UNISTD_H -# include /* getuid() */ -#endif - -#if defined(HAVE_GETPWUID) -# include /* getpwuid() */ -#endif - -#if defined( HAVE_SYS_STAT_H ) -# include -#endif -#if defined( HAVE_SYS_TYPES_H ) -# include -#endif -#if defined( WIN32 ) -# if !defined( UNDER_CE ) -# include -# endif -#include -#endif #include "configuration.h" #include "modules/modules.h" +vlc_rwlock_t config_lock = VLC_STATIC_RWLOCK; +bool config_dirty = false; + static inline char *strdupnull (const char *src) { return src ? strdup (src) : NULL; } -/* Item types that use a string value (i.e. serialized in the module cache) */ -int IsConfigStringType (int type) -{ - static const unsigned char config_types[] = - { - CONFIG_ITEM_STRING, CONFIG_ITEM_FILE, CONFIG_ITEM_MODULE, - CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_MODULE_CAT, CONFIG_ITEM_PASSWORD, - CONFIG_ITEM_MODULE_LIST, CONFIG_ITEM_MODULE_LIST_CAT - }; - - /* NOTE: this needs to be changed if we ever get more than 255 types */ - return memchr (config_types, type, sizeof (config_types)) != NULL; -} - - -int IsConfigIntegerType (int type) -{ - static const unsigned char config_types[] = - { - CONFIG_ITEM_INTEGER, CONFIG_ITEM_KEY, CONFIG_ITEM_BOOL, - CONFIG_CATEGORY, CONFIG_SUBCATEGORY - }; - - return memchr (config_types, type, sizeof (config_types)) != NULL; -} - - +#undef config_GetType /***************************************************************************** * config_GetType: get the type of a variable (bool, int, float, string) ***************************************************************************** * This function is used to get the type of a variable from its name. * Beware, this is quite slow. *****************************************************************************/ -int __config_GetType( vlc_object_t *p_this, const char *psz_name ) +int config_GetType( vlc_object_t *p_this, const char *psz_name ) { module_config_t *p_config; int i_type; @@ -110,44 +66,24 @@ int __config_GetType( vlc_object_t *p_this, const char *psz_name ) return 0; } - switch( p_config->i_type ) + switch( CONFIG_CLASS(p_config->i_type) ) { - case CONFIG_ITEM_BOOL: - i_type = VLC_VAR_BOOL; + case CONFIG_ITEM_FLOAT: + i_type = VLC_VAR_FLOAT; break; case CONFIG_ITEM_INTEGER: - case CONFIG_ITEM_KEY: i_type = VLC_VAR_INTEGER; break; - case CONFIG_ITEM_FLOAT: - i_type = VLC_VAR_FLOAT; - break; - - case CONFIG_ITEM_MODULE: - case CONFIG_ITEM_MODULE_CAT: - case CONFIG_ITEM_MODULE_LIST: - case CONFIG_ITEM_MODULE_LIST_CAT: - i_type = VLC_VAR_MODULE; + case CONFIG_ITEM_BOOL: + i_type = VLC_VAR_BOOL; break; case CONFIG_ITEM_STRING: i_type = VLC_VAR_STRING; break; - case CONFIG_ITEM_PASSWORD: - i_type = VLC_VAR_STRING; - break; - - case CONFIG_ITEM_FILE: - i_type = VLC_VAR_FILE; - break; - - case CONFIG_ITEM_DIRECTORY: - i_type = VLC_VAR_DIRECTORY; - break; - default: i_type = 0; break; @@ -156,6 +92,13 @@ int __config_GetType( vlc_object_t *p_this, const char *psz_name ) return i_type; } +bool config_IsSafe( const char *name ) +{ + module_config_t *p_config = config_FindConfig( NULL, name ); + return p_config != NULL && p_config->b_safe; +} + +#undef config_GetInt /***************************************************************************** * config_GetInt: get the value of an int variable ***************************************************************************** @@ -163,7 +106,7 @@ int __config_GetType( vlc_object_t *p_this, const char *psz_name ) * represented by an integer (CONFIG_ITEM_INTEGER and * CONFIG_ITEM_BOOL). *****************************************************************************/ -int __config_GetInt( vlc_object_t *p_this, const char *psz_name ) +int64_t config_GetInt( vlc_object_t *p_this, const char *psz_name ) { module_config_t *p_config; @@ -182,16 +125,22 @@ int __config_GetInt( vlc_object_t *p_this, const char *psz_name ) return -1; } - return p_config->value.i; + int64_t val; + + vlc_rwlock_rdlock (&config_lock); + val = p_config->value.i; + vlc_rwlock_unlock (&config_lock); + return val; } +#undef config_GetFloat /***************************************************************************** * config_GetFloat: get the value of a float variable ***************************************************************************** * This function is used to get the value of variables which are internally * represented by a float (CONFIG_ITEM_FLOAT). *****************************************************************************/ -float __config_GetFloat( vlc_object_t *p_this, const char *psz_name ) +float config_GetFloat( vlc_object_t *p_this, const char *psz_name ) { module_config_t *p_config; @@ -210,21 +159,27 @@ float __config_GetFloat( vlc_object_t *p_this, const char *psz_name ) return -1; } - return p_config->value.f; + float val; + + vlc_rwlock_rdlock (&config_lock); + val = p_config->value.f; + vlc_rwlock_unlock (&config_lock); + return val; } +#undef config_GetPsz /***************************************************************************** * config_GetPsz: get the string value of a string variable ***************************************************************************** * This function is used to get the value of variables which are internally - * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE, + * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_*FILE, * CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE). * * Important note: remember to free() the returned char* because it's a * duplicate of the actual value. It isn't safe to return a pointer to the * actual value as it can be modified at any time. *****************************************************************************/ -char * __config_GetPsz( vlc_object_t *p_this, const char *psz_name ) +char * config_GetPsz( vlc_object_t *p_this, const char *psz_name ) { module_config_t *p_config; @@ -244,25 +199,25 @@ char * __config_GetPsz( vlc_object_t *p_this, const char *psz_name ) } /* return a copy of the string */ - vlc_mutex_lock( p_config->p_lock ); + vlc_rwlock_rdlock (&config_lock); char *psz_value = strdupnull (p_config->value.psz); - vlc_mutex_unlock( p_config->p_lock ); + vlc_rwlock_unlock (&config_lock); return psz_value; } +#undef config_PutPsz /***************************************************************************** * config_PutPsz: set the string value of a string variable ***************************************************************************** * This function is used to set the value of variables which are internally - * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE, + * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_*FILE, * CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE). *****************************************************************************/ -void __config_PutPsz( vlc_object_t *p_this, +void config_PutPsz( vlc_object_t *p_this, const char *psz_name, const char *psz_value ) { module_config_t *p_config; - vlc_value_t oldval, val; p_config = config_FindConfig( p_this, psz_name ); @@ -280,32 +235,22 @@ void __config_PutPsz( vlc_object_t *p_this, return; } - vlc_mutex_lock( p_config->p_lock ); - - /* backup old value */ - oldval.psz_string = (char *)p_config->value.psz; - + char *str, *oldstr; if ((psz_value != NULL) && *psz_value) - p_config->value.psz = strdup (psz_value); + str = strdup (psz_value); else - p_config->value.psz = NULL; - - p_config->b_dirty = true; + str = NULL; - val.psz_string = (char *)p_config->value.psz; - - vlc_mutex_unlock( p_config->p_lock ); - - if( p_config->pf_callback ) - { - p_config->pf_callback( p_this, psz_name, oldval, val, - p_config->p_callback_data ); - } + vlc_rwlock_wrlock (&config_lock); + oldstr = (char *)p_config->value.psz; + p_config->value.psz = str; + config_dirty = true; + vlc_rwlock_unlock (&config_lock); - /* free old string */ - free( oldval.psz_string ); + free (oldstr); } +#undef config_PutInt /***************************************************************************** * config_PutInt: set the integer value of an int variable ***************************************************************************** @@ -313,10 +258,10 @@ void __config_PutPsz( vlc_object_t *p_this, * represented by an integer (CONFIG_ITEM_INTEGER and * CONFIG_ITEM_BOOL). *****************************************************************************/ -void __config_PutInt( vlc_object_t *p_this, const char *psz_name, int i_value ) +void config_PutInt( vlc_object_t *p_this, const char *psz_name, + int64_t i_value ) { module_config_t *p_config; - vlc_value_t oldval, val; p_config = config_FindConfig( p_this, psz_name ); @@ -333,49 +278,28 @@ void __config_PutInt( vlc_object_t *p_this, const char *psz_name, int i_value ) return; } - /* backup old value */ - oldval.i_int = p_config->value.i; - - /* if i_min == i_max == 0, then do not use them */ - if ((p_config->min.i == 0) && (p_config->max.i == 0)) - { - p_config->value.i = i_value; - } - else if (i_value < p_config->min.i) - { - p_config->value.i = p_config->min.i; - } - else if (i_value > p_config->max.i) - { - p_config->value.i = p_config->max.i; - } - else - { - p_config->value.i = i_value; - } - - p_config->b_dirty = true; - - val.i_int = p_config->value.i; + if (i_value < p_config->min.i) + i_value = p_config->min.i; + if (i_value > p_config->max.i) + i_value = p_config->max.i; - if( p_config->pf_callback ) - { - p_config->pf_callback( p_this, psz_name, oldval, val, - p_config->p_callback_data ); - } + vlc_rwlock_wrlock (&config_lock); + p_config->value.i = i_value; + config_dirty = true; + vlc_rwlock_unlock (&config_lock); } +#undef config_PutFloat /***************************************************************************** * config_PutFloat: set the value of a float variable ***************************************************************************** * This function is used to set the value of variables which are internally * represented by a float (CONFIG_ITEM_FLOAT). *****************************************************************************/ -void __config_PutFloat( vlc_object_t *p_this, - const char *psz_name, float f_value ) +void config_PutFloat( vlc_object_t *p_this, + const char *psz_name, float f_value ) { module_config_t *p_config; - vlc_value_t oldval, val; p_config = config_FindConfig( p_this, psz_name ); @@ -392,398 +316,325 @@ void __config_PutFloat( vlc_object_t *p_this, return; } - /* backup old value */ - oldval.f_float = p_config->value.f; - /* if f_min == f_max == 0, then do not use them */ if ((p_config->min.f == 0) && (p_config->max.f == 0)) - { - p_config->value.f = f_value; - } + ; else if (f_value < p_config->min.f) - { - p_config->value.f = p_config->min.f; - } + f_value = p_config->min.f; else if (f_value > p_config->max.f) + f_value = p_config->max.f; + + vlc_rwlock_wrlock (&config_lock); + p_config->value.f = f_value; + config_dirty = true; + vlc_rwlock_unlock (&config_lock); +} + +/** + * Determines a list of suggested values for an integer configuration item. + * \param values pointer to a table of integer values [OUT] + * \param texts pointer to a table of descriptions strings [OUT] + * \return number of choices, or -1 on error + * \note the caller is responsible for calling free() on all descriptions and + * on both tables. In case of error, both pointers are set to NULL. + */ +ssize_t config_GetIntChoices (vlc_object_t *obj, const char *name, + int64_t **restrict values, char ***restrict texts) +{ + *values = NULL; + *texts = NULL; + + module_config_t *cfg = config_FindConfig (obj, name); + if (cfg == NULL) { - p_config->value.f = p_config->max.f; + msg_Warn (obj, "option %s does not exist", name); + errno = ENOENT; + return -1; } - else + + size_t count = cfg->list_count; + if (count == 0) { - p_config->value.f = f_value; + if (cfg->list.i_cb == NULL) + return 0; + return cfg->list.i_cb(obj, name, values, texts); } - p_config->b_dirty = true; - - val.f_float = p_config->value.f; + int64_t *vals = xmalloc (sizeof (*vals) * count); + char **txts = xmalloc (sizeof (*txts) * count); - if( p_config->pf_callback ) + for (size_t i = 0; i < count; i++) { - p_config->pf_callback( p_this, psz_name, oldval, val, - p_config->p_callback_data ); + vals[i] = cfg->list.i[i]; + /* FIXME: use module_gettext() instead */ + txts[i] = strdup ((cfg->list_text[i] != NULL) + ? vlc_gettext (cfg->list_text[i]) : ""); + if (unlikely(txts[i] == NULL)) + abort (); } + + *values = vals; + *texts = txts; + return count; } -/***************************************************************************** - * config_FindConfig: find the config structure associated with an option. - ***************************************************************************** - * FIXME: This function really needs to be optimized. - * FIXME: And now even more. - *****************************************************************************/ -module_config_t *config_FindConfig( vlc_object_t *p_this, const char *psz_name ) + +static ssize_t config_ListModules (const char *cap, char ***restrict values, + char ***restrict texts) { - vlc_list_t *p_list; - int i_index; + module_t **list; + ssize_t n = module_list_cap (&list, cap); + if (n <= 0) + { + *values = *texts = NULL; + return n; + } - if( !psz_name ) return NULL; + char **vals = xmalloc ((n + 2) * sizeof (*vals)); + char **txts = xmalloc ((n + 2) * sizeof (*txts)); - p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); + vals[0] = xstrdup ("any"); + txts[0] = xstrdup (_("Automatic")); - for( i_index = 0; i_index < p_list->i_count; i_index++ ) + for (ssize_t i = 0; i < n; i++) { - module_config_t *p_item, *p_end; - module_t *p_parser = (module_t *)p_list->p_values[i_index].p_object; - - if( !p_parser->i_config_items ) - continue; - - for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize; - p_item < p_end; - p_item++ ) - { - if( p_item->i_type & CONFIG_HINT ) - /* ignore hints */ - continue; - if( !strcmp( psz_name, p_item->psz_name ) - || ( p_item->psz_oldname - && !strcmp( psz_name, p_item->psz_oldname ) ) ) - { - vlc_list_release( p_list ); - return p_item; - } - } + vals[i + 1] = xstrdup (module_get_object (list[i])); + txts[i + 1] = xstrdup (module_gettext (list[i], + module_get_name (list[i], true))); } - vlc_list_release( p_list ); + vals[n + 1] = xstrdup ("none"); + txts[n + 1] = xstrdup (_("Disable")); - return NULL; + *values = vals; + *texts = txts; + return n + 2; } -/***************************************************************************** - * config_Free: frees a duplicated module's configuration data. - ***************************************************************************** - * This function frees all the data duplicated by config_Duplicate. - *****************************************************************************/ -void config_Free( module_t *p_module ) +/** + * Determines a list of suggested values for a string configuration item. + * \param values pointer to a table of value strings [OUT] + * \param texts pointer to a table of descriptions strings [OUT] + * \return number of choices, or -1 on error + * \note the caller is responsible for calling free() on all values, on all + * descriptions and on both tables. + * In case of error, both pointers are set to NULL. + */ +ssize_t config_GetPszChoices (vlc_object_t *obj, const char *name, + char ***restrict values, char ***restrict texts) { - int i; + *values = *texts = NULL; - for (size_t j = 0; j < p_module->confsize; j++) + module_config_t *cfg = config_FindConfig (obj, name); + if (cfg == NULL) { - module_config_t *p_item = p_module->p_config + j; - - free( p_item->psz_type ); - free( p_item->psz_name ); - free( p_item->psz_text ); - free( p_item->psz_longtext ); - free( p_item->psz_oldname ); - - if (IsConfigStringType (p_item->i_type)) - { - free (p_item->value.psz); - free (p_item->orig.psz); - free (p_item->saved.psz); - } + errno = ENOENT; + return -1; + } - if( p_item->ppsz_list ) - for( i = 0; i < p_item->i_list; i++ ) - free( p_item->ppsz_list[i] ); - if( p_item->ppsz_list_text ) - for( i = 0; i < p_item->i_list; i++ ) - free( p_item->ppsz_list_text[i] ); - free( p_item->ppsz_list ); - free( p_item->ppsz_list_text ); - free( p_item->pi_list ); - - if( p_item->i_action ) - { - for( i = 0; i < p_item->i_action; i++ ) + switch (cfg->i_type) + { + case CONFIG_ITEM_MODULE: + return config_ListModules (cfg->psz_type, values, texts); + default: + if (!IsConfigStringType (cfg->i_type)) { - free( p_item->ppsz_action_text[i] ); + errno = EINVAL; + return -1; } - free( p_item->ppf_action ); - free( p_item->ppsz_action_text ); - } + break; } - free (p_module->p_config); - p_module->p_config = NULL; -} + size_t count = cfg->list_count; + if (count == 0) + { + if (cfg->list.psz_cb == NULL) + return 0; + return cfg->list.psz_cb(obj, name, values, texts); + } -/***************************************************************************** - * config_SetCallbacks: sets callback functions in the duplicate p_config. - ***************************************************************************** - * Unfortunatly we cannot work directly with the module's config data as - * this module might be unloaded from memory at any time (remember HideModule). - * This is why we need to duplicate callbacks each time we reload the module. - *****************************************************************************/ -void config_SetCallbacks( module_config_t *p_new, module_config_t *p_orig, - size_t n ) -{ - for (size_t i = 0; i < n; i++) + char **vals = xmalloc (sizeof (*vals) * count); + char **txts = xmalloc (sizeof (*txts) * count); + + for (size_t i = 0; i < count; i++) { - p_new->pf_callback = p_orig->pf_callback; - p_new++; - p_orig++; + vals[i] = xstrdup ((cfg->list.psz[i] != NULL) ? cfg->list.psz[i] : ""); + /* FIXME: use module_gettext() instead */ + txts[i] = xstrdup ((cfg->list_text[i] != NULL) + ? vlc_gettext (cfg->list_text[i]) : ""); } + + *values = vals; + *texts = txts; + return count; } -/***************************************************************************** - * config_UnsetCallbacks: unsets callback functions in the duplicate p_config. - ***************************************************************************** - * We simply undo what we did in config_SetCallbacks. - *****************************************************************************/ -void config_UnsetCallbacks( module_config_t *p_new, size_t n ) +static int confcmp (const void *a, const void *b) { - for (size_t i = 0; i < n; i++) - { - p_new->pf_callback = NULL; - p_new++; - } + const module_config_t *const *ca = a, *const *cb = b; + + return strcmp ((*ca)->psz_name, (*cb)->psz_name); } -/***************************************************************************** - * config_ResetAll: reset the configuration data for all the modules. - *****************************************************************************/ -void __config_ResetAll( vlc_object_t *p_this ) +static int confnamecmp (const void *key, const void *elem) +{ + const module_config_t *const *conf = elem; + + return strcmp (key, (*conf)->psz_name); +} + +static struct { - libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc); - int i_index; - vlc_list_t *p_list; - module_t *p_module; + module_config_t **list; + size_t count; +} config = { NULL, 0 }; - /* Acquire config file lock */ - vlc_mutex_lock( &priv->config_lock ); +/** + * Index the configuration items by name for faster lookups. + */ +int config_SortConfig (void) +{ + size_t nmod, nconf = 0; + module_t **mlist = module_list_get (&nmod); - p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); + for (size_t i = 0; i < nmod; i++) + nconf += mlist[i]->confsize; - for( i_index = 0; i_index < p_list->i_count; i_index++ ) + module_config_t **clist = malloc (sizeof (*clist) * nconf); + if (unlikely(clist == NULL)) { - p_module = (module_t *)p_list->p_values[i_index].p_object ; - if( p_module->b_submodule ) continue; + module_list_free (mlist); + return VLC_ENOMEM; + } - for (size_t i = 0; i < p_module->confsize; i++ ) + nconf = 0; + for (size_t i = 0; i < nmod; i++) + { + module_t *parser = mlist[i]; + module_config_t *item, *end; + + for (item = parser->p_config, end = item + parser->confsize; + item < end; + item++) { - if (IsConfigIntegerType (p_module->p_config[i].i_type)) - p_module->p_config[i].value.i = p_module->p_config[i].orig.i; - else - if (IsConfigFloatType (p_module->p_config[i].i_type)) - p_module->p_config[i].value.f = p_module->p_config[i].orig.f; - else - if (IsConfigStringType (p_module->p_config[i].i_type)) - { - free ((char *)p_module->p_config[i].value.psz); - p_module->p_config[i].value.psz = - strdupnull (p_module->p_config[i].orig.psz); - } + if (!CONFIG_ITEM(item->i_type)) + continue; /* ignore hints */ + clist[nconf++] = item; } } + module_list_free (mlist); + + qsort (clist, nconf, sizeof (*clist), confcmp); - vlc_list_release( p_list ); - vlc_mutex_unlock( &priv->config_lock ); + config.list = clist; + config.count = nconf; + return VLC_SUCCESS; } -/** - * config_GetDataDir: find directory where shared data is installed - * - * @return a string (always succeeds). - */ -const char *config_GetDataDir( void ) +void config_UnsortConfig (void) { -#if defined (WIN32) || defined (UNDER_CE) - return vlc_global()->psz_vlcpath; -#elif defined(__APPLE__) || defined (SYS_BEOS) - static char path[PATH_MAX] = ""; + module_config_t **clist; - if( *path == '\0' ) - { - snprintf( path, sizeof( path ), "%s/share", - vlc_global()->psz_vlcpath ); - path[sizeof( path ) - 1] = '\0'; - } - return path; -#else - return DATA_PATH; -#endif + clist = config.list; + config.list = NULL; + config.count = 0; + + free (clist); } /***************************************************************************** - * config_GetHomeDir, config_GetUserDir: find the user's home directory. + * config_FindConfig: find the config structure associated with an option. ***************************************************************************** - * This function will try by different ways to find the user's home path. - * Note that this function is not reentrant, it should be called only once - * at the beginning of main where the result will be stored for later use. + * FIXME: remove p_this pointer parameter (or use it) *****************************************************************************/ -static char *GetDir( bool b_appdata ) +module_config_t *config_FindConfig (vlc_object_t *p_this, const char *name) { - const char *psz_localhome = NULL; + VLC_UNUSED(p_this); -#if defined(WIN32) && !defined(UNDER_CE) - typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD, - LPWSTR ); -#ifndef CSIDL_FLAG_CREATE -# define CSIDL_FLAG_CREATE 0x8000 -#endif -#ifndef CSIDL_APPDATA -# define CSIDL_APPDATA 0x1A -#endif -#ifndef CSIDL_PROFILE -# define CSIDL_PROFILE 0x28 -#endif -#ifndef SHGFP_TYPE_CURRENT -# define SHGFP_TYPE_CURRENT 0 -#endif + if (unlikely(name == NULL)) + return NULL; - HINSTANCE shfolder_dll; - SHGETFOLDERPATH SHGetFolderPath ; + module_config_t *const *p; + p = bsearch (name, config.list, config.count, sizeof (*p), confnamecmp); + return p ? *p : NULL; +} - /* load the shfolder dll to retrieve SHGetFolderPath */ - if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL ) +/** + * Destroys an array of configuration items. + * \param config start of array of items + * \param confsize number of items in the array + */ +void config_Free (module_config_t *config, size_t confsize) +{ + for (size_t j = 0; j < confsize; j++) { - SHGetFolderPath = (void *)GetProcAddress( shfolder_dll, - _T("SHGetFolderPathW") ); - if ( SHGetFolderPath != NULL ) - { - wchar_t whomedir[MAX_PATH]; - - /* get the "Application Data" folder for the current user */ - if( S_OK == SHGetFolderPath( NULL, - (b_appdata ? CSIDL_APPDATA : - CSIDL_PROFILE) | CSIDL_FLAG_CREATE, - NULL, SHGFP_TYPE_CURRENT, - whomedir ) ) - { - FreeLibrary( shfolder_dll ); - return FromWide( whomedir ); - } - } - FreeLibrary( shfolder_dll ); - } - -#elif defined(UNDER_CE) - -#ifndef CSIDL_APPDATA -# define CSIDL_APPDATA 0x1A -#endif + module_config_t *p_item = config + j; - wchar_t whomedir[MAX_PATH]; - - /* get the "Application Data" folder for the current user */ - if( SHGetSpecialFolderPath( NULL, whomedir, CSIDL_APPDATA, 1 ) ) - return FromWide( whomedir ); -#endif - - psz_localhome = getenv( "HOME" ); - if( psz_localhome == NULL ) - { -#if defined(HAVE_GETPWUID) - struct passwd *p_pw; - (void)b_appdata; + free( p_item->psz_type ); + free( p_item->psz_name ); + free( p_item->psz_text ); + free( p_item->psz_longtext ); - if( ( p_pw = getpwuid( getuid() ) ) != NULL ) - psz_localhome = p_pw->pw_dir; + if (IsConfigIntegerType (p_item->i_type)) + { + if (p_item->list_count) + free (p_item->list.i); + } else -#endif + if (IsConfigStringType (p_item->i_type)) { - psz_localhome = getenv( "TMP" ); - if( psz_localhome == NULL ) - psz_localhome = "/tmp"; + free (p_item->value.psz); + free (p_item->orig.psz); + if (p_item->list_count) + { + for (size_t i = 0; i < p_item->list_count; i++) + free (p_item->list.psz[i]); + free (p_item->list.psz); + } } - } - return FromLocaleDup( psz_localhome ); -} + for (size_t i = 0; i < p_item->list_count; i++) + free (p_item->list_text[i]); + free (p_item->list_text); + } -/** - * Get the user's home directory - */ -char *config_GetHomeDir( void ) -{ - return GetDir( false ); + free (config); } -/** - * Get the user's main data and config directory: - * - on windows that's the App Data directory; - * - on other OSes it's the same as the home directory. - */ -char *config_GetUserDir( void ); /* XXX why does gcc wants a declaration ? - * --funman */ -char *config_GetUserDir( void ) +#undef config_ResetAll +/***************************************************************************** + * config_ResetAll: reset the configuration data for all the modules. + *****************************************************************************/ +void config_ResetAll( vlc_object_t *p_this ) { - return GetDir( true ); -} + size_t count; + module_t **list = module_list_get (&count); -static char *config_GetFooDir (libvlc_int_t *p_libvlc, const char *xdg_name, - const char *xdg_default) -{ - char *psz_dir; -#if defined(WIN32) || defined(__APPLE__) || defined(SYS_BEOS) - char *psz_parent = config_GetUserDir(); - - if( asprintf( &psz_dir, "%s" DIR_SEP CONFIG_DIR, psz_parent ) == -1 ) - psz_dir = NULL; - - free (psz_parent); - (void)xdg_name; (void)xdg_default; -#else - char var[sizeof ("XDG__HOME") + strlen (xdg_name)], *psz_env; - - /* XDG Base Directory Specification - Version 0.6 */ - snprintf (var, sizeof (var), "XDG_%s_HOME", xdg_name); - psz_env = FromLocaleDup (getenv (var)); - if( psz_env ) + vlc_rwlock_wrlock (&config_lock); + for (size_t j = 0; j < count; j++) { - if( asprintf( &psz_dir, "%s/vlc", psz_env ) == -1 ) - psz_dir = NULL; - goto out; - } - - psz_env = FromLocaleDup (getenv ("HOME")); - /* not part of XDG spec but we want a sensible fallback */ - if( !psz_env ) - psz_env = config_GetHomeDir(); - if( asprintf( &psz_dir, "%s/%s/vlc", psz_env, xdg_default ) == -1 ) - psz_dir = NULL; - -out: - free (psz_env); -#endif - return psz_dir; -} + module_t *p_module = list[j]; -/** - * Get the user's VLC configuration directory - */ -char *config_GetConfigDir( libvlc_int_t *p_libvlc ) -{ - return config_GetFooDir (p_libvlc, "CONFIG", ".config"); -} + for (size_t i = 0; i < p_module->confsize; i++ ) + { + module_config_t *p_config = p_module->p_config + i; -/** - * Get the user's VLC data directory - * (used for stuff like the skins, custom lua modules, ...) - */ -char *config_GetUserDataDir( libvlc_int_t *p_libvlc ) -{ - return config_GetFooDir (p_libvlc, "DATA", ".local/share"); -} + if (IsConfigIntegerType (p_config->i_type)) + p_config->value.i = p_config->orig.i; + else + if (IsConfigFloatType (p_config->i_type)) + p_config->value.f = p_config->orig.f; + else + if (IsConfigStringType (p_config->i_type)) + { + free ((char *)p_config->value.psz); + p_config->value.psz = + strdupnull (p_config->orig.psz); + } + } + } + vlc_rwlock_unlock (&config_lock); -/** - * Get the user's VLC cache directory - * (used for stuff like the modules cache, the album art cache, ...) - */ -char *config_GetCacheDir( libvlc_int_t *p_libvlc ) -{ - return config_GetFooDir (p_libvlc, "CACHE", ".cache"); + module_list_free (list); + VLC_UNUSED(p_this); }