/*****************************************************************************
* config_PutInt: set the integer value of an int variable
*****************************************************************************
* This function is used to set the value of variables which are internally
* represented by an integer (CONFIG_ITEM_INTEGER and
* CONFIG_ITEM_BOOL).
*****************************************************************************/
void config_PutInt( vlc_object_t *p_this, const char *psz_name,
int64_t i_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 (!IsConfigIntegerType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to an int", psz_name );
return;
}
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;
vlc_rwlock_wrlock (&config_lock);
p_config->value.i = i_value;
config_dirty = true;
vlc_rwlock_unlock (&config_lock);
}
/**
* Initializes the messages logging subsystem and drain the early messages to
* the configured log.
*
* \return 0 on success, -1 on error.
*/
int vlc_LogInit(libvlc_int_t *vlc)
{
vlc_logger_t *logger = libvlc_priv(vlc)->logger;
if (unlikely(logger == NULL))
return -1;
vlc_log_cb cb;
void *sys, *early_sys = NULL;
/* TODO: module configuration item */
module_t *module = vlc_module_load(logger, "logger", NULL, false,
vlc_logger_load, logger, &cb, &sys);
if (module == NULL)
cb = vlc_vaLogDiscard;
vlc_rwlock_wrlock(&logger->lock);
if (logger->log == vlc_vaLogEarly)
early_sys = logger->sys;
logger->log = cb;
logger->sys = sys;
assert(logger->module == NULL); /* Only one call to vlc_LogInit()! */
logger->module = module;
vlc_rwlock_unlock(&logger->lock);
if (early_sys != NULL)
vlc_LogEarlyClose(logger, early_sys);
return 0;
}
/*****************************************************************************
* 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 )
{
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 (!IsConfigFloatType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a float", psz_name );
return;
}
/* if f_min == f_max == 0, then do not use them */
if ((p_config->min.f == 0) && (p_config->max.f == 0))
;
else if (f_value < 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);
}
int config_AutoSaveConfigFile( vlc_object_t *p_this )
{
int ret = VLC_SUCCESS;
bool save = false;
assert( p_this );
/* Check if there's anything to save */
module_t **list = module_list_get (NULL);
vlc_rwlock_rdlock (&config_lock);
for (size_t i_index = 0; list[i_index] && !save; i_index++)
{
module_t *p_parser = list[i_index];
module_config_t *p_item, *p_end;
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 && !save;
p_item++ )
{
save = p_item->b_autosave && p_item->b_dirty;
}
}
if (save)
/* Note: this will get the read lock recursively. Ok. */
ret = SaveConfigFile (p_this, NULL, true);
vlc_rwlock_unlock (&config_lock);
module_list_free (list);
return ret;
}
/**
* Sets the message logging callback.
* \param cb message callback, or NULL to reset
* \param data data pointer for the message callback
*/
void vlc_LogSet (libvlc_int_t *vlc, vlc_log_cb cb, void *opaque)
{
libvlc_priv_t *priv = libvlc_priv (vlc);
if (cb == NULL)
{
#if defined (HAVE_ISATTY) && !defined (_WIN32)
if (isatty (STDERR_FILENO) && var_InheritBool (vlc, "color"))
cb = PrintColorMsg;
else
#endif
cb = PrintMsg;
opaque = (void *)(intptr_t)priv->log.verbose;
}
vlc_rwlock_wrlock (&priv->log.lock);
priv->log.cb = cb;
priv->log.opaque = opaque;
vlc_rwlock_unlock (&priv->log.lock);
/* Announce who we are */
msg_Dbg (vlc, "VLC media player - %s", VERSION_MESSAGE);
msg_Dbg (vlc, "%s", COPYRIGHT_MESSAGE);
msg_Dbg (vlc, "revision %s", psz_vlc_changeset);
msg_Dbg (vlc, "configured with %s", CONFIGURE_LINE);
}
/**
* Sets the message logging callback.
* \param cb message callback, or NULL to clear
* \param data data pointer for the message callback
*/
void vlc_LogSet(libvlc_int_t *vlc, vlc_log_cb cb, void *opaque)
{
vlc_logger_t *logger = libvlc_priv(vlc)->logger;
if (unlikely(logger == NULL))
return;
module_t *module;
void *sys;
if (cb == NULL)
cb = vlc_vaLogDiscard;
vlc_rwlock_wrlock(&logger->lock);
sys = logger->sys;
module = logger->module;
logger->log = cb;
logger->sys = opaque;
logger->module = NULL;
vlc_rwlock_unlock(&logger->lock);
if (module != NULL)
vlc_module_unload(module, vlc_logger_unload, sys);
/* Announce who we are */
msg_Dbg (vlc, "VLC media player - %s", VERSION_MESSAGE);
msg_Dbg (vlc, "%s", COPYRIGHT_MESSAGE);
msg_Dbg (vlc, "revision %s", psz_vlc_changeset);
msg_Dbg (vlc, "configured with %s", CONFIGURE_LINE);
}
/*****************************************************************************
* 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_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);
}
/*****************************************************************************
* 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 )
{
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 -1;
}
if (!IsConfigFloatType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a float", psz_name );
return -1;
}
float val;
vlc_rwlock_rdlock (&config_lock);
val = p_config->value.f;
vlc_rwlock_unlock (&config_lock);
return val;
}
/*****************************************************************************
* 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);
}
/**
* Unsubscribe from the message queue.
* This function waits for the message callback to return if needed.
*/
void msg_Unsubscribe (msg_subscription_t *sub)
{
msg_bank_t *bank = libvlc_bank (sub->instance);
vlc_rwlock_wrlock (&bank->lock);
TAB_REMOVE (bank->i_sub, bank->pp_sub, sub);
vlc_rwlock_unlock (&bank->lock);
free (sub);
}
static vlc_interrupt_t *vlc_interrupt_get(void)
{
vlc_interrupt_t *ctx = NULL;
vlc_rwlock_rdlock(&vlc_interrupt_lock);
if (vlc_interrupt_refs > 0)
ctx = vlc_threadvar_get(vlc_interrupt_var);
vlc_rwlock_unlock(&vlc_interrupt_lock);
return ctx;
}
static void vlc_vaLogCallback(libvlc_int_t *vlc, int type,
const vlc_log_t *item, const char *format,
va_list ap)
{
vlc_logger_t *logger = libvlc_priv(vlc)->logger;
assert(logger != NULL);
vlc_rwlock_rdlock(&logger->lock);
logger->log(logger->sys, type, item, format, ap);
vlc_rwlock_unlock(&logger->lock);
}
/**
* Emit a log message. This function is the variable argument list equivalent
* to vlc_Log().
*/
void vlc_vaLog (vlc_object_t *obj, int type, const char *module,
const char *format, va_list args)
{
if (obj != NULL && obj->i_flags & OBJECT_FLAGS_QUIET)
return;
/* Get basename from the module filename */
char *p = strrchr(module, '/');
if (p != NULL)
module = p;
p = strchr(module, '.');
size_t modlen = (p != NULL) ? (p - module) : 1;
char modulebuf[modlen + 1];
if (p != NULL)
{
memcpy(modulebuf, module, modlen);
modulebuf[modlen] = '\0';
module = modulebuf;
}
/* Fill message information fields */
vlc_log_t msg;
msg.i_object_id = (uintptr_t)obj;
msg.psz_object_type = (obj != NULL) ? obj->psz_object_type : "generic";
msg.psz_module = module;
msg.psz_header = NULL;
for (vlc_object_t *o = obj; o != NULL; o = o->p_parent)
if (o->psz_header != NULL)
{
msg.psz_header = o->psz_header;
break;
}
/* Pass message to the callback */
libvlc_priv_t *priv = obj ? libvlc_priv (obj->p_libvlc) : NULL;
#ifdef _WIN32
va_list ap;
va_copy (ap, args);
Win32DebugOutputMsg (priv ? &priv->log.verbose : NULL, type, &msg, format, ap);
va_end (ap);
#endif
if (priv) {
vlc_rwlock_rdlock (&priv->log.lock);
priv->log.cb (priv->log.opaque, type, &msg, format, args);
vlc_rwlock_unlock (&priv->log.lock);
}
}
void msg_DisableObjectPrinting (vlc_object_t *obj, const char * psz_object)
{
msg_bank_t *bank = libvlc_bank (obj->p_libvlc);
vlc_rwlock_wrlock (&bank->lock);
if( !strcmp(psz_object, "all") )
bank->all_objects_enabled = false;
else
vlc_dictionary_insert (&bank->enabled_objects, psz_object,
(void *)kObjectPrintingDisabled);
vlc_rwlock_unlock (&bank->lock);
}
void msg_SubscriptionSetVerbosity( msg_subscription_t *sub, const int i_verbosity )
{
if( i_verbosity < 0 || i_verbosity > 2 ) return;
msg_bank_t *bank = libvlc_bank ( sub->instance );
vlc_rwlock_wrlock (&bank->lock);
sub->verbosity = i_verbosity;
vlc_rwlock_unlock (&bank->lock);
}
/**
* Deinitializes an interruption context.
* The context shall no longer be used by any thread.
*/
void vlc_interrupt_deinit(vlc_interrupt_t *ctx)
{
assert(ctx->callback == NULL);
assert(!ctx->attached);
vlc_mutex_destroy(&ctx->lock);
vlc_rwlock_wrlock(&vlc_interrupt_lock);
assert(vlc_interrupt_refs > 0);
if (--vlc_interrupt_refs == 0)
vlc_threadvar_delete(&vlc_interrupt_var);
vlc_rwlock_unlock(&vlc_interrupt_lock);
}
/**
* Unsubscribe from the message queue.
* This function waits for the message callback to return if needed.
*/
void vlc_Unsubscribe (msg_subscription_t *sub)
{
vlc_rwlock_wrlock (&msg_lock);
if (sub->next != NULL)
sub->next->prev = sub->prev;
if (sub->prev != NULL)
sub->prev->next = sub->next;
else
{
assert (msg_head == sub);
msg_head = sub->next;
}
vlc_rwlock_unlock (&msg_lock);
free (sub);
}
/*****************************************************************************
* 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 );
}
/**
* Subscribe to the message queue.
* Whenever a message is emitted, a callback will be called.
* Callback invocation are serialized within a subscription.
*
* @param cb callback function
* @param opaque data for the callback function
* @return a subscription pointer, or NULL in case of failure
*/
msg_subscription_t *vlc_Subscribe (msg_callback_t cb, void *opaque)
{
msg_subscription_t *sub = malloc (sizeof (*sub));
if (sub == NULL)
return NULL;
sub->prev = NULL;
sub->func = cb;
sub->opaque = opaque;
vlc_rwlock_wrlock (&msg_lock);
sub->next = msg_head;
msg_head = sub;
vlc_rwlock_unlock (&msg_lock);
return sub;
}
int config_AutoSaveConfigFile( vlc_object_t *p_this )
{
int ret = 0;
assert( p_this );
vlc_rwlock_rdlock (&config_lock);
if (config_dirty)
{
/* Note: this will get the read lock recursively. Ok. */
ret = config_SaveConfigFile (p_this);
config_dirty = (ret != 0);
}
vlc_rwlock_unlock (&config_lock);
return ret;
}
/*****************************************************************************
* config_PutInt: set the integer value of an int variable
*****************************************************************************
* This function is used to set the value of variables which are internally
* 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 )
{
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 (!IsConfigIntegerType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to an int", psz_name );
return;
}
/* if i_min == i_max == 0, then do not use them */
if ((p_config->min.i == 0) && (p_config->max.i == 0))
;
else if (i_value < p_config->min.i)
i_value = p_config->min.i;
else if (i_value > p_config->max.i)
i_value = p_config->max.i;
vlc_rwlock_wrlock (&config_lock);
/* backup old value */
oldval.i_int = p_config->value.i;
p_config->value.i = i_value;
p_config->b_dirty = true;
vlc_rwlock_unlock (&config_lock);
if( p_config->pf_callback )
{
vlc_value_t val;
val.i_int = i_value;
p_config->pf_callback( p_this, psz_name, oldval, val,
p_config->p_callback_data );
}
}
/**
* Subscribe to the message queue.
* Whenever a message is emitted, a callback will be called.
* Callback invocation are serialized within a subscription.
*
* @param instance LibVLC instance to get messages from
* @param cb callback function
* @param opaque data for the callback function
* @return a subscription pointer, or NULL in case of failure
*/
msg_subscription_t *msg_Subscribe (libvlc_int_t *instance, msg_callback_t cb,
msg_cb_data_t *opaque)
{
msg_subscription_t *sub = malloc (sizeof (*sub));
if (sub == NULL)
return NULL;
sub->instance = instance;
sub->func = cb;
sub->opaque = opaque;
msg_bank_t *bank = libvlc_bank (instance);
vlc_rwlock_wrlock (&bank->lock);
TAB_APPEND (bank->i_sub, bank->pp_sub, sub);
vlc_rwlock_unlock (&bank->lock);
return sub;
}
/**
* Initializes an interruption context.
*/
void vlc_interrupt_init(vlc_interrupt_t *ctx)
{
vlc_rwlock_wrlock(&vlc_interrupt_lock);
assert(vlc_interrupt_refs < UINT_MAX);
if (vlc_interrupt_refs++ == 0)
#ifndef NDEBUG
vlc_threadvar_create(&vlc_interrupt_var, vlc_interrupt_destructor);
#else
vlc_threadvar_create(&vlc_interrupt_var, NULL);
#endif
vlc_rwlock_unlock(&vlc_interrupt_lock);
vlc_mutex_init(&ctx->lock);
ctx->interrupted = false;
atomic_init(&ctx->killed, false);
#ifndef NDEBUG
ctx->attached = false;
#endif
ctx->callback = NULL;
}
/*****************************************************************************
* config_GetInt: get the value of an int variable
*****************************************************************************
* This function is used to get the value of variables which are internally
* represented by an integer (CONFIG_ITEM_INTEGER and
* CONFIG_ITEM_BOOL).
*****************************************************************************/
int64_t config_GetInt( vlc_object_t *p_this, const char *psz_name )
{
module_config_t *p_config = config_FindConfig( psz_name );
/* sanity checks */
if( !p_config )
{
msg_Err( p_this, "option %s does not exist", psz_name );
return -1;
}
assert(IsConfigIntegerType(p_config->i_type));
int64_t val;
vlc_rwlock_rdlock (&config_lock);
val = p_config->value.i;
vlc_rwlock_unlock (&config_lock);
return val;
}
/*****************************************************************************
* 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;
}
/*****************************************************************************
* config_LoadConfigFile: loads the configuration file.
*****************************************************************************
* This function is called to load the config options stored in the config
* file.
*****************************************************************************/
int config_LoadConfigFile( vlc_object_t *p_this )
{
FILE *file;
file = config_OpenConfigFile (p_this);
if (file == NULL)
return VLC_EGENERIC;
/* Look for UTF-8 Byte Order Mark */
char * (*convert) (const char *) = strdupnull;
char bom[3];
if ((fread (bom, 1, 3, file) != 3)
|| memcmp (bom, "\xEF\xBB\xBF", 3))
{
convert = FromLocaleDup;
rewind (file); /* no BOM, rewind */
}
char *line = NULL;
size_t bufsize;
ssize_t linelen;
/* Ensure consistent number formatting... */
locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
locale_t baseloc = uselocale (loc);
vlc_rwlock_wrlock (&config_lock);
while ((linelen = getline (&line, &bufsize, file)) != -1)
{
line[linelen - 1] = '\0'; /* trim newline */
/* Ignore comments, section and empty lines */
if (memchr ("#[", line[0], 3) != NULL)
continue;
/* look for option name */
const char *psz_option_name = line;
char *ptr = strchr (line, '=');
if (ptr == NULL)
continue; /* syntax error */
*ptr = '\0';
module_config_t *item = config_FindConfig (p_this, psz_option_name);
if (item == NULL)
continue;
const char *psz_option_value = ptr + 1;
switch (item->i_type)
{
case CONFIG_ITEM_BOOL:
case CONFIG_ITEM_INTEGER:
{
int64_t l;
errno = 0;
l = strtoi (psz_option_value);
if ((l > item->max.i) || (l < item->min.i))
errno = ERANGE;
if (errno)
msg_Warn (p_this, "Integer value (%s) for %s: %m",
psz_option_value, psz_option_name);
else
item->saved.i = item->value.i = l;
break;
}
case CONFIG_ITEM_FLOAT:
if (!*psz_option_value)
break; /* ignore empty option */
item->value.f = (float)atof (psz_option_value);
item->saved.f = item->value.f;
break;
default:
free ((char *)item->value.psz);
free ((char *)item->saved.psz);
item->value.psz = convert (psz_option_value);
item->saved.psz = strdupnull (item->value.psz);
break;
}
}
vlc_rwlock_unlock (&config_lock);
free (line);
if (ferror (file))
{
msg_Err (p_this, "error reading configuration: %m");
clearerr (file);
}
fclose (file);
if (loc != (locale_t)0)
{
uselocale (baseloc);
freelocale (loc);
}
return 0;
}
/**
* Emit a log message. This function is the variable argument list equivalent
* to vlc_Log().
*/
void vlc_vaLog (vlc_object_t *obj, int type, const char *module,
const char *format, va_list args)
{
if (obj != NULL && obj->i_flags & OBJECT_FLAGS_QUIET)
return;
/* Get basename from the module filename */
char *p = strrchr(module, '/');
if (p != NULL)
module = p;
p = strchr(module, '.');
size_t modlen = (p != NULL) ? (p - module) : 1;
char modulebuf[modlen];
if (p != NULL)
{
memcpy(modulebuf, module, modlen);
modulebuf[modlen] = '\0';
module = modulebuf;
}
/* C locale to get error messages in English in the logs */
locale_t c = newlocale (LC_MESSAGES_MASK, "C", (locale_t)0);
locale_t locale = uselocale (c);
#ifndef __GLIBC__
/* Expand %m to strerror(errno) - only once */
char buf[strlen(format) + 2001], *ptr;
strcpy (buf, format);
ptr = (char*)buf;
format = (const char*) buf;
for( ;; )
{
ptr = strchr( ptr, '%' );
if( ptr == NULL )
break;
if( ptr[1] == 'm' )
{
char errbuf[2001];
size_t errlen;
#ifndef _WIN32
strerror_r( errno, errbuf, 1001 );
#else
int sockerr = WSAGetLastError( );
if( sockerr )
{
strncpy( errbuf, net_strerror( sockerr ), 1001 );
WSASetLastError( sockerr );
}
if ((sockerr == 0)
|| (strcmp ("Unknown network stack error", errbuf) == 0))
strncpy( errbuf, strerror( errno ), 1001 );
#endif
errbuf[1000] = 0;
/* Escape '%' from the error string */
for( char *percent = strchr( errbuf, '%' );
percent != NULL;
percent = strchr( percent + 2, '%' ) )
{
memmove( percent + 1, percent, strlen( percent ) + 1 );
}
errlen = strlen( errbuf );
memmove( ptr + errlen, ptr + 2, strlen( ptr + 2 ) + 1 );
memcpy( ptr, errbuf, errlen );
break; /* Only once, so we don't overflow */
}
/* Looks for conversion specifier... */
do
ptr++;
while( *ptr && ( strchr( "diouxXeEfFgGaAcspn%", *ptr ) == NULL ) );
if( *ptr )
ptr++; /* ...and skip it */
}
#endif
/* Fill message information fields */
vlc_log_t msg;
msg.i_object_id = (uintptr_t)obj;
msg.psz_object_type = (obj != NULL) ? obj->psz_object_type : "generic";
msg.psz_module = module;
msg.psz_header = NULL;
for (vlc_object_t *o = obj; o != NULL; o = o->p_parent)
if (o->psz_header != NULL)
{
msg.psz_header = o->psz_header;
break;
}
/* Pass message to the callback */
libvlc_priv_t *priv = obj ? libvlc_priv (obj->p_libvlc) : NULL;
#ifdef _WIN32
va_list ap;
va_copy (ap, args);
Win32DebugOutputMsg (priv ? &priv->log.verbose : NULL, type, &msg, format, ap);
va_end (ap);
#endif
if (priv) {
vlc_rwlock_rdlock (&priv->log.lock);
priv->log.cb (priv->log.opaque, type, &msg, format, args);
vlc_rwlock_unlock (&priv->log.lock);
}
uselocale (locale);
freelocale (c);
}
/**
* 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;
}
/**
* Emit a log message. This function is the variable argument list equivalent
* to vlc_Log().
*/
void vlc_vaLog (vlc_object_t *obj, int type, const char *module,
const char *format, va_list args)
{
if (obj != NULL && obj->i_flags & OBJECT_FLAGS_QUIET)
return;
/* C locale to get error messages in English in the logs */
locale_t c = newlocale (LC_MESSAGES_MASK, "C", (locale_t)0);
locale_t locale = uselocale (c);
#ifndef __GLIBC__
/* Expand %m to strerror(errno) - only once */
char buf[strlen(format) + 2001], *ptr;
strcpy (buf, format);
ptr = (char*)buf;
format = (const char*) buf;
for( ;; )
{
ptr = strchr( ptr, '%' );
if( ptr == NULL )
break;
if( ptr[1] == 'm' )
{
char errbuf[2001];
size_t errlen;
#ifndef WIN32
strerror_r( errno, errbuf, 1001 );
#else
int sockerr = WSAGetLastError( );
if( sockerr )
{
strncpy( errbuf, net_strerror( sockerr ), 1001 );
WSASetLastError( sockerr );
}
if ((sockerr == 0)
|| (strcmp ("Unknown network stack error", errbuf) == 0))
strncpy( errbuf, strerror( errno ), 1001 );
#endif
errbuf[1000] = 0;
/* Escape '%' from the error string */
for( char *percent = strchr( errbuf, '%' );
percent != NULL;
percent = strchr( percent + 2, '%' ) )
{
memmove( percent + 1, percent, strlen( percent ) + 1 );
}
errlen = strlen( errbuf );
memmove( ptr + errlen, ptr + 2, strlen( ptr + 2 ) + 1 );
memcpy( ptr, errbuf, errlen );
break; /* Only once, so we don't overflow */
}
/* Looks for conversion specifier... */
do
ptr++;
while( *ptr && ( strchr( "diouxXeEfFgGaAcspn%", *ptr ) == NULL ) );
if( *ptr )
ptr++; /* ...and skip it */
}
#endif
/* Fill message information fields */
msg_item_t msg;
msg.i_object_id = (uintptr_t)obj;
msg.psz_object_type = (obj != NULL) ? obj->psz_object_type : "generic";
msg.psz_module = module;
msg.psz_header = NULL;
for (vlc_object_t *o = obj; o != NULL; o = o->p_parent)
if (o->psz_header != NULL)
{
msg.psz_header = o->psz_header;
break;
}
/* Pass message to subscribers */
libvlc_priv_t *priv = libvlc_priv (obj->p_libvlc);
va_list ap;
va_copy (ap, args);
if (priv->b_color)
PrintColorMsg (&priv->i_verbose, type, &msg, format, ap);
else
PrintMsg (&priv->i_verbose, type, &msg, format, ap);
va_end (ap);
vlc_rwlock_rdlock (&msg_lock);
for (msg_subscription_t *sub = msg_head; sub != NULL; sub = sub->next)
{
va_copy (ap, args);
sub->func (sub->opaque, type, &msg, format, ap);
va_end (ap);
}
vlc_rwlock_unlock (&msg_lock);
uselocale (locale);
freelocale (c);
}
