/*****************************************************************************
* 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,
* CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE).
*****************************************************************************/
void config_PutPsz( vlc_object_t *p_this,
const char *psz_name, const char *psz_value )
{
module_config_t *p_config;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Warn( p_this, "option %s does not exist", psz_name );
return;
}
if (!IsConfigStringType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a string", psz_name );
return;
}
char *str, *oldstr;
if ((psz_value != NULL) && *psz_value)
str = strdup (psz_value);
else
str = NULL;
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 (oldstr);
}
static int CacheSaveConfig (FILE *file, const module_config_t *cfg)
{
SAVE_IMMEDIATE (cfg->flags);
SAVE_STRING (cfg->psz_type);
SAVE_STRING (cfg->psz_name);
SAVE_STRING (cfg->psz_text);
SAVE_STRING (cfg->psz_longtext);
SAVE_IMMEDIATE (cfg->list_count);
if (IsConfigStringType (cfg->i_type))
{
SAVE_STRING (cfg->orig.psz);
if (cfg->list_count == 0)
SAVE_IMMEDIATE (cfg->list.psz_cb); /* XXX: see CacheLoadConfig() */
for (unsigned i = 0; i < cfg->list_count; i++)
SAVE_STRING (cfg->list.psz[i]);
}
else
{
SAVE_IMMEDIATE (cfg->orig);
SAVE_IMMEDIATE (cfg->min);
SAVE_IMMEDIATE (cfg->max);
if (cfg->list_count == 0)
SAVE_IMMEDIATE (cfg->list.i_cb); /* XXX: see CacheLoadConfig() */
for (unsigned i = 0; i < cfg->list_count; i++)
SAVE_IMMEDIATE (cfg->list.i[i]);
}
for (unsigned i = 0; i < cfg->list_count; i++)
SAVE_STRING (cfg->list_text[i]);
return 0;
error:
return -1;
}
/*****************************************************************************
* 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,
* 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 )
{
module_config_t *p_config;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Err( p_this, "option %s does not exist", psz_name );
return NULL;
}
if (!IsConfigStringType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a string", psz_name );
return NULL;
}
/* return a copy of the string */
vlc_rwlock_rdlock (&config_lock);
char *psz_value = strdupnull (p_config->value.psz);
vlc_rwlock_unlock (&config_lock);
return psz_value;
}
/*****************************************************************************
* config_ResetAll: reset the configuration data for all the modules.
*****************************************************************************/
void config_ResetAll( vlc_object_t *p_this )
{
VLC_UNUSED(p_this);
module_t *p_module;
module_t **list = module_list_get (NULL);
vlc_rwlock_wrlock (&config_lock);
for (size_t j = 0; (p_module = list[j]) != NULL; j++)
{
if( p_module->b_submodule ) continue;
for (size_t i = 0; i < p_module->confsize; i++ )
{
module_config_t *p_config = p_module->p_config + i;
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);
module_list_free (list);
}
static int CacheLoadConfig (module_config_t *cfg, FILE *file)
{
LOAD_IMMEDIATE (cfg->flags);
LOAD_STRING (cfg->psz_type);
LOAD_STRING (cfg->psz_name);
LOAD_STRING (cfg->psz_text);
LOAD_STRING (cfg->psz_longtext);
LOAD_IMMEDIATE (cfg->list_count);
if (IsConfigStringType (cfg->i_type))
{
LOAD_STRING (cfg->orig.psz);
if (cfg->orig.psz != NULL)
cfg->value.psz = strdup (cfg->orig.psz);
else
cfg->value.psz = NULL;
if (cfg->list_count)
cfg->list.psz = xmalloc (cfg->list_count * sizeof (char *));
else /* TODO: fix config_GetPszChoices() instead of this hack: */
LOAD_IMMEDIATE(cfg->list.psz_cb);
for (unsigned i = 0; i < cfg->list_count; i++)
{
LOAD_STRING (cfg->list.psz[i]);
if (cfg->list.psz[i] == NULL /* NULL -> empty string */
&& (cfg->list.psz[i] = calloc (1, 1)) == NULL)
goto error;
}
}
else
{
LOAD_IMMEDIATE (cfg->orig);
LOAD_IMMEDIATE (cfg->min);
LOAD_IMMEDIATE (cfg->max);
cfg->value = cfg->orig;
if (cfg->list_count)
cfg->list.i = xmalloc (cfg->list_count * sizeof (int));
else /* TODO: fix config_GetPszChoices() instead of this hack: */
LOAD_IMMEDIATE(cfg->list.i_cb);
for (unsigned i = 0; i < cfg->list_count; i++)
LOAD_IMMEDIATE (cfg->list.i[i]);
}
cfg->list_text = xmalloc (cfg->list_count * sizeof (char *));
for (unsigned i = 0; i < cfg->list_count; i++)
{
LOAD_STRING (cfg->list_text[i]);
if (cfg->list_text[i] == NULL /* NULL -> empty string */
&& (cfg->list_text[i] = calloc (1, 1)) == NULL)
goto error;
}
return 0;
error:
return -1; /* FIXME: leaks */
}
static int CacheSaveConfig (FILE *file, const module_t *p_module)
{
uint32_t i_lines = p_module->confsize;
SAVE_IMMEDIATE( p_module->i_config_items );
SAVE_IMMEDIATE( p_module->i_bool_items );
SAVE_IMMEDIATE( i_lines );
for (size_t i = 0; i < i_lines ; i++)
{
SAVE_IMMEDIATE( p_module->p_config[i] );
SAVE_STRING( p_module->p_config[i].psz_type );
SAVE_STRING( p_module->p_config[i].psz_name );
SAVE_STRING( p_module->p_config[i].psz_text );
SAVE_STRING( p_module->p_config[i].psz_longtext );
SAVE_STRING( p_module->p_config[i].psz_oldname );
if (IsConfigStringType (p_module->p_config[i].i_type))
SAVE_STRING( p_module->p_config[i].orig.psz );
if( p_module->p_config[i].i_list )
{
if( p_module->p_config[i].ppsz_list )
{
for (int j = 0; j < p_module->p_config[i].i_list; j++)
SAVE_STRING( p_module->p_config[i].ppsz_list[j] );
}
if( p_module->p_config[i].ppsz_list_text )
{
for (int j = 0; j < p_module->p_config[i].i_list; j++)
SAVE_STRING( p_module->p_config[i].ppsz_list_text[j] );
}
if( p_module->p_config[i].pi_list )
{
for (int j = 0; j < p_module->p_config[i].i_list; j++)
SAVE_IMMEDIATE( p_module->p_config[i].pi_list[j] );
}
}
for (int j = 0; j < p_module->p_config[i].i_action; j++)
SAVE_STRING( p_module->p_config[i].ppsz_action_text[j] );
}
return 0;
error:
return -1;
}
/*****************************************************************************
* 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,
* CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE).
*****************************************************************************/
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;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Warn( p_this, "option %s does not exist", psz_name );
return;
}
if (!IsConfigStringType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a string", psz_name );
return;
}
vlc_rwlock_wrlock (&config_lock);
/* backup old value */
oldval.psz_string = (char *)p_config->value.psz;
if ((psz_value != NULL) && *psz_value)
p_config->value.psz = strdup (psz_value);
else
p_config->value.psz = NULL;
p_config->b_dirty = true;
vlc_rwlock_unlock (&config_lock);
if( p_config->pf_callback )
{
vlc_value_t val;
val.psz_string = (char *)psz_value;
p_config->pf_callback( p_this, psz_name, oldval, val,
p_config->p_callback_data );
}
/* free old string */
free( oldval.psz_string );
}
/*****************************************************************************
* 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 )
{
int i;
for (size_t j = 0; j < p_module->confsize; j++)
{
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);
}
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++ )
{
free( p_item->ppsz_action_text[i] );
}
free( p_item->ppf_action );
free( p_item->ppsz_action_text );
}
}
free (p_module->p_config);
p_module->p_config = NULL;
}
/*****************************************************************************
* config_SaveConfigFile: Save a module's config options.
*****************************************************************************
* This will save the specified module's config options to the config file.
* If psz_module_name is NULL then we save all the modules config options.
* It's no use to save the config options that kept their default values, so
* we'll try to be a bit clever here.
*
* When we save we mustn't delete the config options of the modules that
* haven't been loaded. So we cannot just create a new config file with the
* config structures we've got in memory.
* I don't really know how to deal with this nicely, so I will use a completly
* dumb method ;-)
* I will load the config file in memory, but skipping all the sections of the
* modules we want to save. Then I will create a brand new file, dump the file
* loaded in memory and then append the sections of the modules we want to
* save.
* Really stupid no ?
*****************************************************************************/
static int SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name,
bool b_autosave )
{
module_t *p_parser;
char *permanent = NULL, *temporary = NULL;
if( config_PrepareDir( p_this ) )
{
msg_Err( p_this, "no configuration directory" );
return -1;
}
/* List all available modules */
module_t **list = module_list_get (NULL);
char *bigbuf = NULL;
size_t bigsize = 0;
FILE *file = config_OpenConfigFile (p_this);
if (file != NULL)
{
struct stat st;
/* Some users make vlcrc read-only to prevent changes.
* The atomic replacement scheme breaks this "feature",
* so we check for read-only by hand. */
if (fstat (fileno (file), &st)
|| !(st.st_mode & S_IWUSR))
{
msg_Err (p_this, "configuration file is read-only");
goto error;
}
bigsize = (st.st_size < LONG_MAX) ? st.st_size : 0;
bigbuf = malloc (bigsize + 1);
if (bigbuf == NULL)
goto error;
/* backup file into memory, we only need to backup the sections we
* won't save later on */
char *p_index = bigbuf;
char *line = NULL;
size_t bufsize;
ssize_t linelen;
bool backup = false;
while ((linelen = getline (&line, &bufsize, file)) != -1)
{
char *p_index2;
if ((line[0] == '[') && (p_index2 = strchr(line,']')))
{
/* we found a new section, check if we need to do a backup */
backup = true;
for (int i = 0; (p_parser = list[i]) != NULL; i++)
{
if (!strncmp (line + 1, p_parser->psz_object_name,
strlen (p_parser->psz_object_name))
&& ((psz_module_name == NULL)
|| !strcmp (psz_module_name, p_parser->psz_object_name)))
{
backup = false; /* no, we will rewrite it! */
break;
}
}
}
/* save line if requested and line is valid (doesn't begin with a
* space, tab, or eol) */
if (backup && !memchr ("\n\t ", line[0], 3))
{
memcpy (p_index, line, linelen);
p_index += linelen;
}
}
fclose (file);
file = NULL;
free (line);
*p_index = '\0';
bigsize = p_index - bigbuf;
}
/*
* Save module config in file
*/
permanent = config_GetConfigFile (p_this);
if (!permanent)
{
module_list_free (list);
goto error;
}
if (asprintf (&temporary, "%s.%u", permanent, getpid ()) == -1)
{
temporary = NULL;
module_list_free (list);
goto error;
}
/* Configuration lock must be taken before vlcrc serializer below. */
vlc_rwlock_rdlock (&config_lock);
/* The temporary configuration file is per-PID. Therefore SaveConfigFile()
* should be serialized against itself within a given process. */
static vlc_mutex_t lock = VLC_STATIC_MUTEX;
vlc_mutex_lock (&lock);
int fd = vlc_open (temporary, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR);
if (fd == -1)
{
vlc_rwlock_unlock (&config_lock);
vlc_mutex_unlock (&lock);
module_list_free (list);
goto error;
}
file = fdopen (fd, "wt");
if (file == NULL)
{
msg_Err (p_this, "cannot create configuration file: %m");
vlc_rwlock_unlock (&config_lock);
close (fd);
vlc_mutex_unlock (&lock);
module_list_free (list);
goto error;
}
fprintf( file,
"\xEF\xBB\xBF###\n"
"### "PACKAGE_NAME" "PACKAGE_VERSION"\n"
"###\n"
"\n"
"###\n"
"### lines beginning with a '#' character are comments\n"
"###\n"
"\n" );
/* Ensure consistent number formatting... */
locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
locale_t baseloc = uselocale (loc);
/* We would take the config lock here. But this would cause a lock
* inversion with the serializer above and config_AutoSaveConfigFile().
vlc_rwlock_rdlock (&config_lock);*/
/* Look for the selected module, if NULL then save everything */
for (int i = 0; (p_parser = list[i]) != NULL; i++)
{
module_config_t *p_item, *p_end;
if( psz_module_name && strcmp( psz_module_name,
p_parser->psz_object_name ) )
continue;
if( !p_parser->i_config_items )
continue;
if( psz_module_name )
msg_Dbg( p_this, "saving config for module \"%s\"",
p_parser->psz_object_name );
fprintf( file, "[%s]", p_parser->psz_object_name );
if( p_parser->psz_longname )
fprintf( file, " # %s\n\n", p_parser->psz_longname );
else
fprintf( file, "\n\n" );
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 hint */
|| p_item->b_removed /* ignore deprecated option */
|| p_item->b_unsaveable) /* ignore volatile option */
continue;
/* Do not save the new value in the configuration file
* if doing an autosave, and the item is not an "autosaved" one. */
bool b_retain = b_autosave && !p_item->b_autosave;
if (IsConfigIntegerType (p_item->i_type))
{
int64_t val = b_retain ? p_item->saved.i : p_item->value.i;
config_Write (file, p_item->psz_text,
(p_item->i_type == CONFIG_ITEM_BOOL)
? N_("boolean") : N_("integer"),
val == p_item->orig.i,
p_item->psz_name, "%"PRId64, val);
p_item->saved.i = val;
}
else
if (IsConfigFloatType (p_item->i_type))
{
float val = b_retain ? p_item->saved.f : p_item->value.f;
config_Write (file, p_item->psz_text, N_("float"),
val == p_item->orig.f,
p_item->psz_name, "%f", val);
p_item->saved.f = val;
}
else
{
const char *psz_value = b_retain ? p_item->saved.psz
: p_item->value.psz;
bool modified;
assert (IsConfigStringType (p_item->i_type));
if (b_retain && (psz_value == NULL)) /* FIXME: hack */
psz_value = p_item->orig.psz;
modified =
(psz_value != NULL)
? ((p_item->orig.psz != NULL)
? (strcmp (psz_value, p_item->orig.psz) != 0)
: true)
: (p_item->orig.psz != NULL);
config_Write (file, p_item->psz_text, N_("string"),
!modified, p_item->psz_name, "%s",
psz_value ? psz_value : "");
if ( !b_retain )
{
free ((char *)p_item->saved.psz);
if( (psz_value && p_item->orig.psz &&
strcmp( psz_value, p_item->orig.psz )) ||
!psz_value || !p_item->orig.psz)
p_item->saved.psz = strdupnull (psz_value);
else
p_item->saved.psz = NULL;
}
}
if (!b_retain)
p_item->b_dirty = false;
}
}
vlc_rwlock_unlock (&config_lock);
module_list_free (list);
if (loc != (locale_t)0)
{
uselocale (baseloc);
freelocale (loc);
}
/*
* Restore old settings from the config in file
*/
if (bigsize)
fwrite (bigbuf, 1, bigsize, file);
/*
* Flush to disk and replace atomically
*/
fflush (file); /* Flush from run-time */
if (ferror (file))
{
vlc_unlink (temporary);
vlc_mutex_unlock (&lock);
msg_Err (p_this, "cannot write configuration file");
clearerr (file);
goto error;
}
#ifndef WIN32
#ifdef __APPLE__
fsync (fd); /* Flush from OS */
#else
fdatasync (fd); /* Flush from OS */
#endif
/* Atomically replace the file... */
if (vlc_rename (temporary, permanent))
vlc_unlink (temporary);
/* (...then synchronize the directory, err, TODO...) */
/* ...and finally close the file */
vlc_mutex_unlock (&lock);
#endif
fclose (file);
#ifdef WIN32
/* Windows cannot remove open files nor overwrite existing ones */
vlc_unlink (permanent);
if (vlc_rename (temporary, permanent))
vlc_unlink (temporary);
vlc_mutex_unlock (&lock);
#endif
free (temporary);
free (permanent);
free (bigbuf);
return 0;
error:
if( file )
fclose( file );
free (temporary);
free (permanent);
free (bigbuf);
return -1;
}
int vlc_plugin_set (module_t *module, module_config_t *item, int propid, ...)
{
va_list ap;
int ret = 0;
va_start (ap, propid);
switch (propid)
{
case VLC_SUBMODULE_CREATE:
{
module_t **pp = va_arg (ap, module_t **);
*pp = vlc_submodule_create (module);
if (*pp == NULL)
ret = -1;
break;
}
case VLC_CONFIG_CREATE:
{
int type = va_arg (ap, int);
module_config_t **pp = va_arg (ap, module_config_t **);
*pp = vlc_config_create (module, type);
if (*pp == NULL)
ret = -1;
break;
}
case VLC_MODULE_SHORTCUT:
{
unsigned i_shortcuts = va_arg (ap, unsigned);
unsigned index = module->i_shortcuts;
/* The cache loader accept only a small number of shortcuts */
assert(i_shortcuts + index <= MODULE_SHORTCUT_MAX);
const char *const *tab = va_arg (ap, const char *const *);
char **pp = realloc (module->pp_shortcuts,
sizeof (pp[0]) * (index + i_shortcuts));
if (unlikely(pp == NULL))
{
ret = -1;
break;
}
module->pp_shortcuts = pp;
module->i_shortcuts = index + i_shortcuts;
memcpy (pp + index, tab, sizeof (pp[0]) * i_shortcuts);
break;
}
case VLC_MODULE_CAPABILITY:
module->psz_capability = va_arg (ap, char *);
break;
case VLC_MODULE_SCORE:
module->i_score = va_arg (ap, int);
break;
case VLC_MODULE_CB_OPEN:
module->pf_activate = va_arg (ap, void *);
break;
case VLC_MODULE_CB_CLOSE:
module->pf_deactivate = va_arg (ap, void *);
break;
case VLC_MODULE_NO_UNLOAD:
module->b_unloadable = false;
break;
case VLC_MODULE_NAME:
{
const char *value = va_arg (ap, const char *);
free( module->psz_object_name );
module->psz_object_name = strdup( value );
module->pp_shortcuts = malloc( sizeof( char ** ) );
module->pp_shortcuts[0] = (char*)value; /* dooh! */
module->i_shortcuts = 1;
if (module->psz_longname == default_name)
module->psz_longname = (char*)value; /* dooh! */
break;
}
case VLC_MODULE_SHORTNAME:
module->psz_shortname = va_arg (ap, char *);
break;
case VLC_MODULE_DESCRIPTION:
module->psz_longname = va_arg (ap, char *);
break;
case VLC_MODULE_HELP:
module->psz_help = va_arg (ap, char *);
break;
case VLC_MODULE_TEXTDOMAIN:
module->domain = va_arg (ap, char *);
break;
case VLC_CONFIG_NAME:
{
const char *name = va_arg (ap, const char *);
assert (name != NULL);
item->psz_name = strdup (name);
break;
}
case VLC_CONFIG_VALUE:
{
if (IsConfigIntegerType (item->i_type))
{
item->orig.i =
item->value.i = va_arg (ap, int64_t);
}
else
if (IsConfigFloatType (item->i_type))
{
item->orig.f =
item->value.f = va_arg (ap, double);
}
else
if (IsConfigStringType (item->i_type))
{
const char *value = va_arg (ap, const char *);
item->value.psz = value ? strdup (value) : NULL;
item->orig.psz = value ? strdup (value) : NULL;
}
break;
}
static int CacheLoadConfig( module_t *p_module, FILE *file )
{
uint32_t i_lines;
uint16_t i_size;
/* Calculate the structure length */
LOAD_IMMEDIATE( p_module->i_config_items );
LOAD_IMMEDIATE( p_module->i_bool_items );
LOAD_IMMEDIATE( i_lines );
/* Allocate memory */
if (i_lines)
{
p_module->p_config =
(module_config_t *)calloc( i_lines, sizeof(module_config_t) );
if( p_module->p_config == NULL )
{
p_module->confsize = 0;
return VLC_ENOMEM;
}
}
p_module->confsize = i_lines;
/* Do the duplication job */
for (size_t i = 0; i < i_lines; i++ )
{
LOAD_IMMEDIATE( p_module->p_config[i] );
LOAD_STRING( p_module->p_config[i].psz_type );
LOAD_STRING( p_module->p_config[i].psz_name );
LOAD_STRING( p_module->p_config[i].psz_text );
LOAD_STRING( p_module->p_config[i].psz_longtext );
if (IsConfigStringType (p_module->p_config[i].i_type))
{
LOAD_STRING (p_module->p_config[i].orig.psz);
p_module->p_config[i].value.psz =
(p_module->p_config[i].orig.psz != NULL)
? strdup (p_module->p_config[i].orig.psz) : NULL;
}
else
memcpy (&p_module->p_config[i].value, &p_module->p_config[i].orig,
sizeof (p_module->p_config[i].value));
p_module->p_config[i].b_dirty = false;
if( p_module->p_config[i].i_list )
{
if( p_module->p_config[i].ppsz_list )
{
int j;
p_module->p_config[i].ppsz_list =
xmalloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
if( p_module->p_config[i].ppsz_list )
{
for( j = 0; j < p_module->p_config[i].i_list; j++ )
LOAD_STRING( p_module->p_config[i].ppsz_list[j] );
p_module->p_config[i].ppsz_list[j] = NULL;
}
}
if( p_module->p_config[i].ppsz_list_text )
{
int j;
p_module->p_config[i].ppsz_list_text =
xmalloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
if( p_module->p_config[i].ppsz_list_text )
{
for( j = 0; j < p_module->p_config[i].i_list; j++ )
LOAD_STRING( p_module->p_config[i].ppsz_list_text[j] );
p_module->p_config[i].ppsz_list_text[j] = NULL;
}
}
if( p_module->p_config[i].pi_list )
{
p_module->p_config[i].pi_list =
xmalloc( (p_module->p_config[i].i_list + 1) * sizeof(int) );
if( p_module->p_config[i].pi_list )
{
for (int j = 0; j < p_module->p_config[i].i_list; j++)
LOAD_IMMEDIATE( p_module->p_config[i].pi_list[j] );
}
}
}
if( p_module->p_config[i].i_action )
{
p_module->p_config[i].ppf_action =
xmalloc( p_module->p_config[i].i_action * sizeof(void *) );
p_module->p_config[i].ppsz_action_text =
xmalloc( p_module->p_config[i].i_action * sizeof(char *) );
for (int j = 0; j < p_module->p_config[i].i_action; j++)
{
p_module->p_config[i].ppf_action[j] = NULL;
LOAD_STRING( p_module->p_config[i].ppsz_action_text[j] );
}
}
}
return VLC_SUCCESS;
error:
return VLC_EGENERIC;
}
/**
* Saves the in-memory configuration into a file.
* @return 0 on success, -1 on error.
*/
int config_SaveConfigFile (vlc_object_t *p_this)
{
if( config_PrepareDir( p_this ) )
{
msg_Err( p_this, "no configuration directory" );
return -1;
}
/*
* Save module config in file
*/
char *temporary;
char *permanent = config_GetConfigFile (p_this);
if (permanent == NULL)
return -1;
if (asprintf (&temporary, "%s.%u", permanent, getpid ()) == -1)
{
free (permanent);
return -1;
}
else
{
struct stat st;
/* Some users make vlcrc read-only to prevent changes.
* The atomic replacement scheme breaks this "feature",
* so we check for read-only by hand. */
if (stat (permanent, &st) == 0 && !(st.st_mode & S_IWUSR))
{
msg_Err (p_this, "configuration file is read-only");
goto error;
}
}
/* Configuration lock must be taken before vlcrc serializer below. */
vlc_rwlock_rdlock (&config_lock);
/* The temporary configuration file is per-PID. Therefore this function
* should be serialized against itself within a given process. */
static vlc_mutex_t lock = VLC_STATIC_MUTEX;
vlc_mutex_lock (&lock);
int fd = vlc_open (temporary, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR);
if (fd == -1)
{
vlc_rwlock_unlock (&config_lock);
vlc_mutex_unlock (&lock);
goto error;
}
FILE *file = fdopen (fd, "wt");
if (file == NULL)
{
msg_Err (p_this, "cannot create configuration file: %s",
vlc_strerror_c(errno));
vlc_rwlock_unlock (&config_lock);
close (fd);
vlc_mutex_unlock (&lock);
goto error;
}
fprintf( file,
"\xEF\xBB\xBF###\n"
"### "PACKAGE_NAME" "PACKAGE_VERSION"\n"
"###\n"
"\n"
"###\n"
"### lines beginning with a '#' character are comments\n"
"###\n"
"\n" );
/* Ensure consistent number formatting... */
locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
locale_t baseloc = uselocale (loc);
/* We would take the config lock here. But this would cause a lock
* inversion with the serializer above and config_AutoSaveConfigFile().
vlc_rwlock_rdlock (&config_lock);*/
/* Look for the selected module, if NULL then save everything */
size_t count;
module_t **list = module_list_get (&count);
for (size_t i = 0; i < count; i++)
{
module_t *p_parser = list[i];
module_config_t *p_item, *p_end;
if( !p_parser->i_config_items )
continue;
fprintf( file, "[%s]", module_get_object (p_parser) );
if( p_parser->psz_longname )
fprintf( file, " # %s\n\n", p_parser->psz_longname );
else
fprintf( file, "\n\n" );
for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
p_item < p_end;
p_item++ )
{
if (!CONFIG_ITEM(p_item->i_type) /* ignore hint */
|| p_item->b_removed /* ignore deprecated option */
|| p_item->b_unsaveable) /* ignore volatile option */
continue;
if (IsConfigIntegerType (p_item->i_type))
{
int64_t val = p_item->value.i;
config_Write (file, p_item->psz_text,
(CONFIG_CLASS(p_item->i_type) == CONFIG_ITEM_BOOL)
? N_("boolean") : N_("integer"),
val == p_item->orig.i,
p_item->psz_name, "%"PRId64, val);
}
else
if (IsConfigFloatType (p_item->i_type))
{
float val = p_item->value.f;
config_Write (file, p_item->psz_text, N_("float"),
val == p_item->orig.f,
p_item->psz_name, "%f", val);
}
else
{
const char *psz_value = p_item->value.psz;
bool modified;
assert (IsConfigStringType (p_item->i_type));
modified = !!strcmp (psz_value ? psz_value : "",
p_item->orig.psz ? p_item->orig.psz : "");
config_Write (file, p_item->psz_text, N_("string"),
!modified, p_item->psz_name, "%s",
psz_value ? psz_value : "");
}
}
}
vlc_rwlock_unlock (&config_lock);
module_list_free (list);
if (loc != (locale_t)0)
{
uselocale (baseloc);
freelocale (loc);
}
/*
* Flush to disk and replace atomically
*/
fflush (file); /* Flush from run-time */
if (ferror (file))
{
vlc_unlink (temporary);
vlc_mutex_unlock (&lock);
msg_Err (p_this, "cannot write configuration file");
fclose (file);
goto error;
}
#if defined(__APPLE__) || defined(__ANDROID__)
fsync (fd); /* Flush from OS */
#else
fdatasync (fd); /* Flush from OS */
#endif
#if defined (_WIN32) || defined (__OS2__)
/* Windows cannot (re)move open files nor overwrite existing ones */
fclose (file);
vlc_unlink (permanent);
#endif
/* Atomically replace the file... */
if (vlc_rename (temporary, permanent))
vlc_unlink (temporary);
/* (...then synchronize the directory, err, TODO...) */
/* ...and finally close the file */
vlc_mutex_unlock (&lock);
#if !defined (_WIN32) && !defined (__OS2__)
fclose (file);
#endif
free (temporary);
free (permanent);
return 0;
error:
free (temporary);
free (permanent);
return -1;
}
/*****************************************************************************
* config_SaveConfigFile: Save a module's config options.
*****************************************************************************
* This will save the specified module's config options to the config file.
* If psz_module_name is NULL then we save all the modules config options.
* It's no use to save the config options that kept their default values, so
* we'll try to be a bit clever here.
*
* When we save we mustn't delete the config options of the modules that
* haven't been loaded. So we cannot just create a new config file with the
* config structures we've got in memory.
* I don't really know how to deal with this nicely, so I will use a completly
* dumb method ;-)
* I will load the config file in memory, but skipping all the sections of the
* modules we want to save. Then I will create a brand new file, dump the file
* loaded in memory and then append the sections of the modules we want to
* save.
* Really stupid no ?
*****************************************************************************/
static int SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name,
bool b_autosave )
{
module_t *p_parser;
FILE *file = NULL;
char *permanent = NULL, *temporary = NULL;
char p_line[1024], *p_index2;
unsigned long i_sizebuf = 0;
char *p_bigbuffer = NULL, *p_index;
bool b_backup;
int i_index;
if( config_PrepareDir( p_this ) )
{
msg_Err( p_this, "no configuration directory" );
goto error;
}
file = config_OpenConfigFile( p_this );
if( file != NULL )
{
struct stat st;
/* Some users make vlcrc read-only to prevent changes.
* The atomic replacement scheme breaks this "feature",
* so we check for read-only by hand. */
if (fstat (fileno (file), &st)
|| !(st.st_mode & S_IWUSR))
{
msg_Err (p_this, "configuration file is read-only");
goto error;
}
i_sizebuf = ( st.st_size < LONG_MAX ) ? st.st_size : 0;
}
p_bigbuffer = p_index = malloc( i_sizebuf+1 );
if( !p_bigbuffer )
goto error;
p_bigbuffer[0] = 0;
/* List all available modules */
module_t **list = module_list_get (NULL);
/* backup file into memory, we only need to backup the sections we won't
* save later on */
b_backup = false;
while( file && fgets( p_line, 1024, file ) )
{
if( (p_line[0] == '[') && (p_index2 = strchr(p_line,']')))
{
/* we found a section, check if we need to do a backup */
for( i_index = 0; (p_parser = list[i_index]) != NULL; i_index++ )
{
if( ((p_index2 - &p_line[1])
== (int)strlen(p_parser->psz_object_name) )
&& !memcmp( &p_line[1], p_parser->psz_object_name,
strlen(p_parser->psz_object_name) ) )
{
if( !psz_module_name )
break;
else if( !strcmp( psz_module_name,
p_parser->psz_object_name ) )
break;
}
}
if( list[i_index] == NULL )
{
/* we don't have this section in our list so we need to back
* it up */
*p_index2 = 0;
#if 0
msg_Dbg( p_this, "backing up config for unknown module \"%s\"",
&p_line[1] );
#endif
*p_index2 = ']';
b_backup = true;
}
else
{
b_backup = false;
}
}
/* save line if requested and line is valid (doesn't begin with a
* space, tab, or eol) */
if( b_backup && (p_line[0] != '\n') && (p_line[0] != ' ')
&& (p_line[0] != '\t') )
{
strcpy( p_index, p_line );
p_index += strlen( p_line );
}
}
if( file )
fclose( file );
file = NULL;
/*
* Save module config in file
*/
permanent = config_GetConfigFile (p_this);
if (!permanent)
{
module_list_free (list);
goto error;
}
if (asprintf (&temporary, "%s.%u", permanent, getpid ()) == -1)
{
temporary = NULL;
module_list_free (list);
goto error;
}
/* The temporary configuration file is per-PID. Therefore SaveConfigFile()
* should be serialized against itself within a given process. */
static vlc_mutex_t lock = VLC_STATIC_MUTEX;
vlc_mutex_lock (&lock);
int fd = utf8_open (temporary, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR);
if (fd == -1)
{
vlc_mutex_unlock (&lock);
module_list_free (list);
goto error;
}
file = fdopen (fd, "wt");
if (file == NULL)
{
close (fd);
vlc_mutex_unlock (&lock);
module_list_free (list);
goto error;
}
fprintf( file, "\xEF\xBB\xBF###\n### " COPYRIGHT_MESSAGE "\n###\n\n"
"###\n### lines beginning with a '#' character are comments\n###\n\n" );
/* Ensure consistent number formatting... */
locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
locale_t baseloc = uselocale (loc);
/* Look for the selected module, if NULL then save everything */
for( i_index = 0; (p_parser = list[i_index]) != NULL; i_index++ )
{
module_config_t *p_item, *p_end;
if( psz_module_name && strcmp( psz_module_name,
p_parser->psz_object_name ) )
continue;
if( !p_parser->i_config_items )
continue;
if( psz_module_name )
msg_Dbg( p_this, "saving config for module \"%s\"",
p_parser->psz_object_name );
fprintf( file, "[%s]", p_parser->psz_object_name );
if( p_parser->psz_longname )
fprintf( file, " # %s\n\n", p_parser->psz_longname );
else
fprintf( file, "\n\n" );
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 hint */
|| p_item->b_removed /* ignore deprecated option */
|| p_item->b_unsaveable) /* ignore volatile option */
continue;
vlc_mutex_lock (p_item->p_lock);
/* Do not save the new value in the configuration file
* if doing an autosave, and the item is not an "autosaved" one. */
bool b_retain = b_autosave && !p_item->b_autosave;
if (IsConfigIntegerType (p_item->i_type))
{
int val = b_retain ? p_item->saved.i : p_item->value.i;
if (p_item->i_type == CONFIG_ITEM_KEY)
{
char *psz_key = ConfigKeyToString (val);
config_Write (file, p_item->psz_text, N_("key"),
val == p_item->orig.i,
p_item->psz_name, "%s",
psz_key ? psz_key : "");
free (psz_key);
}
else
config_Write (file, p_item->psz_text,
(p_item->i_type == CONFIG_ITEM_BOOL)
? N_("boolean") : N_("integer"),
val == p_item->orig.i,
p_item->psz_name, "%d", val);
p_item->saved.i = val;
}
else
if (IsConfigFloatType (p_item->i_type))
{
float val = b_retain ? p_item->saved.f : p_item->value.f;
config_Write (file, p_item->psz_text, N_("float"),
val == p_item->orig.f,
p_item->psz_name, "%f", val);
p_item->saved.f = val;
}
else
{
const char *psz_value = b_retain ? p_item->saved.psz
: p_item->value.psz;
bool modified;
assert (IsConfigStringType (p_item->i_type));
if (b_retain && (psz_value == NULL)) /* FIXME: hack */
psz_value = p_item->orig.psz;
modified =
(psz_value != NULL)
? ((p_item->orig.psz != NULL)
? (strcmp (psz_value, p_item->orig.psz) != 0)
: true)
: (p_item->orig.psz != NULL);
config_Write (file, p_item->psz_text, N_("string"),
!modified, p_item->psz_name, "%s",
psz_value ? psz_value : "");
if ( !b_retain )
{
free ((char *)p_item->saved.psz);
if( (psz_value && p_item->orig.psz &&
strcmp( psz_value, p_item->orig.psz )) ||
!psz_value || !p_item->orig.psz)
p_item->saved.psz = strdupnull (psz_value);
else
p_item->saved.psz = NULL;
}
}
if (!b_retain)
p_item->b_dirty = false;
vlc_mutex_unlock (p_item->p_lock);
}
}
module_list_free (list);
if (loc != (locale_t)0)
{
uselocale (baseloc);
freelocale (loc);
}
/*
* Restore old settings from the config in file
*/
fputs( p_bigbuffer, file );
free( p_bigbuffer );
/*
* Flush to disk and replace atomically
*/
fflush (file); /* Flush from run-time */
#ifndef WIN32
fdatasync (fd); /* Flush from OS */
/* Atomically replace the file... */
if (utf8_rename (temporary, permanent))
utf8_unlink (temporary);
/* (...then synchronize the directory, err, TODO...) */
/* ...and finally close the file */
vlc_mutex_unlock (&lock);
#endif
fclose (file);
#ifdef WIN32
/* Windows cannot remove open files nor overwrite existing ones */
utf8_unlink (permanent);
if (utf8_rename (temporary, permanent))
utf8_unlink (temporary);
vlc_mutex_unlock (&lock);
#endif
free (temporary);
free (permanent);
return 0;
error:
if( file )
fclose( file );
free (temporary);
free (permanent);
free( p_bigbuffer );
return -1;
}
/**
* Callback for the plugin descriptor functions.
*/
static int vlc_plugin_setter (void *plugin, void *tgt, int propid, ...)
{
module_t **pprimary = plugin;
module_t *module = tgt;
module_config_t *item = tgt;
va_list ap;
int ret = 0;
va_start (ap, propid);
switch (propid)
{
case VLC_MODULE_CREATE:
{
module = *pprimary;
module_t *submodule = vlc_module_create (module);
if (unlikely(submodule == NULL))
{
ret = -1;
break;
}
*(va_arg (ap, module_t **)) = submodule;
if (*pprimary == NULL)
{
*pprimary = submodule;
break;
}
/* Inheritance. Ugly!! */
submodule->pp_shortcuts = xmalloc (sizeof ( *submodule->pp_shortcuts ));
submodule->pp_shortcuts[0] = strdup_null (module->pp_shortcuts[0]);
submodule->i_shortcuts = 1; /* object name */
submodule->psz_shortname = strdup_null (module->psz_shortname);
submodule->psz_longname = strdup_null (module->psz_longname);
submodule->psz_capability = strdup_null (module->psz_capability);
break;
}
case VLC_CONFIG_CREATE:
{
int type = va_arg (ap, int);
module_config_t **pp = va_arg (ap, module_config_t **);
item = vlc_config_create (*pprimary, type);
if (unlikely(item == NULL))
{
ret = -1;
break;
}
*pp = item;
break;
}
case VLC_MODULE_SHORTCUT:
{
unsigned i_shortcuts = va_arg (ap, unsigned);
unsigned index = module->i_shortcuts;
/* The cache loader accept only a small number of shortcuts */
assert(i_shortcuts + index <= MODULE_SHORTCUT_MAX);
const char *const *tab = va_arg (ap, const char *const *);
char **pp = realloc (module->pp_shortcuts,
sizeof (pp[0]) * (index + i_shortcuts));
if (unlikely(pp == NULL))
{
ret = -1;
break;
}
module->pp_shortcuts = pp;
module->i_shortcuts = index + i_shortcuts;
pp += index;
for (unsigned i = 0; i < i_shortcuts; i++)
pp[i] = strdup (tab[i]);
break;
}
case VLC_MODULE_CAPABILITY:
free (module->psz_capability);
module->psz_capability = strdup (va_arg (ap, char *));
break;
case VLC_MODULE_SCORE:
module->i_score = va_arg (ap, int);
break;
case VLC_MODULE_CB_OPEN:
module->pf_activate = va_arg (ap, void *);
break;
case VLC_MODULE_CB_CLOSE:
module->pf_deactivate = va_arg (ap, void *);
break;
case VLC_MODULE_NO_UNLOAD:
assert (module->parent == NULL);
module->b_unloadable = false;
break;
case VLC_MODULE_NAME:
{
const char *value = va_arg (ap, const char *);
assert (module->i_shortcuts == 0);
module->pp_shortcuts = malloc( sizeof( *module->pp_shortcuts ) );
module->pp_shortcuts[0] = strdup (value);
module->i_shortcuts = 1;
assert (module->psz_longname == NULL);
module->psz_longname = strdup (value);
break;
}
case VLC_MODULE_SHORTNAME:
assert (module->psz_shortname == NULL || module->parent != NULL);
free (module->psz_shortname);
module->psz_shortname = strdup (va_arg (ap, char *));
break;
case VLC_MODULE_DESCRIPTION:
// TODO: do not set this in VLC_MODULE_NAME
free (module->psz_longname);
module->psz_longname = strdup (va_arg (ap, char *));
break;
case VLC_MODULE_HELP:
assert (module->parent == NULL);
assert (module->psz_help == NULL);
module->psz_help = strdup (va_arg (ap, char *));
break;
case VLC_MODULE_TEXTDOMAIN:
assert (module->parent == NULL);
assert (module->domain == NULL);
module->domain = strdup (va_arg (ap, char *));
break;
case VLC_CONFIG_NAME:
{
const char *name = va_arg (ap, const char *);
assert (name != NULL);
item->psz_name = strdup (name);
break;
}
case VLC_CONFIG_VALUE:
{
if (IsConfigIntegerType (item->i_type)
|| !CONFIG_ITEM(item->i_type))
{
item->orig.i =
item->value.i = va_arg (ap, int64_t);
}
else
if (IsConfigFloatType (item->i_type))
{
item->orig.f =
item->value.f = va_arg (ap, double);
}
else
if (IsConfigStringType (item->i_type))
{
const char *value = va_arg (ap, const char *);
item->value.psz = value ? strdup (value) : NULL;
item->orig.psz = value ? strdup (value) : NULL;
}
break;
}
