/***************************************************************************** * 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); }
int config_AutoSaveConfigFile( vlc_object_t *p_this ) { size_t i_index; bool save = false; assert( p_this ); /* Check if there's anything to save */ module_t **list = module_list_get (NULL); for( 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++ ) { vlc_mutex_lock (p_item->p_lock); save = p_item->b_autosave && p_item->b_dirty; vlc_mutex_unlock (p_item->p_lock); } } module_list_free (list); return save ? VLC_SUCCESS : SaveConfigFile( p_this, NULL, true ); }
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; }
int main(int argc, const char **argv) { libvlc_instance_t *libvlc = libvlc_new(argc - 1, argv + 1); if (!libvlc) return 1; size_t modules = 0; module_t **mod_list; mod_list = module_list_get(&modules); if (!mod_list || modules == 0) { libvlc_release(libvlc); return 2; } module_t **max = &mod_list[modules]; puts("#compdef vlc cvlc rvlc svlc mvlc qvlc nvlc\n" "#This file is autogenerated by zsh.cpp\n" "typeset -A opt_args\n" "local context state line ret=1\n" "local modules\n"); printf("vlc_modules=\""); for (module_t **mod = mod_list; mod < max; mod++) PrintModule(*mod); puts("\"\n"); puts("_arguments -S -s \\"); for (module_t **mod = mod_list; mod < max; mod++) ParseModule(*mod); puts(" \"(--module)-p[print help on module]:print help on module:($vlc_modules)\"\\"); puts(" \"(-p)--module[print help on module]:print help on module:($vlc_modules)\"\\"); puts(" \"(--help)-h[print help]\"\\"); puts(" \"(-h)--help[print help]\"\\"); puts(" \"(--longhelp)-H[print detailed help]\"\\"); puts(" \"(-H)--longhelp[print detailed help]\"\\"); puts(" \"(--list)-l[print a list of available modules]\"\\"); puts(" \"(-l)--list[print a list of available modules]\"\\"); puts(" \"--reset-config[reset the current config to the default values]\"\\"); puts(" \"--config[use alternate config file]\"\\"); puts(" \"--reset-plugins-cache[resets the current plugins cache]\"\\"); puts(" \"--version[print version information]\"\\"); puts(" \"*:Playlist item:->mrl\" && ret=0\n"); puts("case $state in"); puts(" mrl)"); puts(" _alternative 'files:file:_files' 'urls:URL:_urls' && ret=0"); puts(" ;;"); puts("esac\n"); puts("return ret"); module_list_free(mod_list); libvlc_release(libvlc); return 0; }
/***************************************************************************** * ModuleConfigControl implementation *****************************************************************************/ ModuleConfigControl::ModuleConfigControl( vlc_object_t *p_this, module_config_t *p_item, HWND parent, HINSTANCE hInst, int * py_pos ) : ConfigControl( p_this, p_item, parent, hInst ) { module_t **p_list; module_t *p_parser; label = CreateWindow( _T("STATIC"), _FROMMB(p_item->psz_text), WS_CHILD | WS_VISIBLE | SS_LEFT, 5, *py_pos, 200, 15, parent, NULL, hInst, NULL ); *py_pos += 15 + 10; combo = CreateWindow( _T("COMBOBOX"), _T(""), WS_CHILD | WS_VISIBLE | CBS_AUTOHSCROLL | CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL, 20, *py_pos, 180, 5*15 + 6, parent, NULL, hInst, NULL); *py_pos += 15 + 10; /* build a list of available modules */ p_list = module_list_get( NULL ); ComboBox_AddString( combo, _T("Default") ); ComboBox_SetItemData( combo, 0, (void *)NULL ); ComboBox_SetCurSel( combo, 0 ); //ComboBox_SetText( combo, _T("Default") ); for( size_t i_index = 0; p_list[i_index]; i_index++ ) { p_parser = p_list[i_index]; if( module_provides( p_parser, p_item->psz_type ) ) { ComboBox_AddString( combo, _FROMMB(module_GetLongName( p_parser ) )); ComboBox_SetItemData( combo, i_index, (void *) module_get_object( p_parser ) ); if( p_item->value.psz && !strcmp( p_item->value.psz, module_get_object( p_parser )) ) { ComboBox_SetCurSel( combo, i_index ); //ComboBox_SetText( combo, _FROMMB( module_GetLongName(p_parser)) ); } } } module_list_free( p_list ); }
/***************************************** * Get the list of available audio outputs *****************************************/ libvlc_audio_output_t * libvlc_audio_output_list_get( libvlc_instance_t *p_instance, libvlc_exception_t *p_e ) { VLC_UNUSED( p_instance ); libvlc_audio_output_t *p_list = NULL, *p_actual = NULL, *p_previous = NULL; module_t **module_list = module_list_get( NULL ); for (size_t i = 0; module_list[i]; i++) { module_t *p_module = module_list[i]; if( module_provides( p_module, "audio output" ) ) { if( p_actual == NULL) { p_actual = ( libvlc_audio_output_t * ) malloc( sizeof( libvlc_audio_output_t ) ); if( p_actual == NULL ) { libvlc_exception_raise( p_e ); libvlc_printerr( "Not enough memory" ); libvlc_audio_output_list_release( p_list ); module_list_free( module_list ); return NULL; } if( p_list == NULL ) { p_list = p_actual; p_previous = p_actual; } } p_actual->psz_name = strdup( module_get_object( p_module ) ); p_actual->psz_description = strdup( module_get_name( p_module, true ) ); p_actual->p_next = NULL; if( p_previous != p_actual ) /* not first item */ p_previous->p_next = p_actual; p_previous = p_actual; p_actual = p_actual->p_next; } } module_list_free( module_list ); return p_list; }
static libvlc_module_description_t *module_description_list_get( libvlc_instance_t *p_instance, const char *capability ) { libvlc_module_description_t *p_list = NULL, *p_actual = NULL, *p_previous = NULL; size_t count; module_t **module_list = module_list_get( &count ); for (size_t i = 0; i < count; i++) { module_t *p_module = module_list[i]; if ( !module_provides( p_module, capability ) ) continue; p_actual = ( libvlc_module_description_t * ) malloc( sizeof( libvlc_module_description_t ) ); if ( p_actual == NULL ) { libvlc_printerr( "Not enough memory" ); libvlc_module_description_list_release( p_list ); module_list_free( module_list ); return NULL; } if ( p_list == NULL ) p_list = p_actual; const char* name = module_get_object( p_module ); const char* shortname = module_get_name( p_module, false ); const char* longname = module_get_name( p_module, true ); const char* help = module_get_help( p_module ); p_actual->psz_name = name ? strdup( name ) : NULL; p_actual->psz_shortname = shortname ? strdup( shortname ) : NULL; p_actual->psz_longname = longname ? strdup( longname ) : NULL; p_actual->psz_help = help ? strdup( help ) : NULL; p_actual->p_next = NULL; if ( p_previous ) p_previous->p_next = p_actual; p_previous = p_actual; } module_list_free( module_list ); VLC_UNUSED( p_instance ); return p_list; }
void ModuleConfigControl::finish( ) { combo->setEditable( false ); /* build a list of available modules */ size_t count; module_t **p_list = module_list_get( &count ); combo->addItem( qtr("Default") ); for( size_t i = 0; i < count; i++ ) { module_t *p_parser = p_list[i]; if( !strcmp( module_get_object( p_parser ), "main" ) ) continue; unsigned confsize; module_config_t *p_config; p_config = module_config_get (p_parser, &confsize); for (size_t i = 0; i < confsize; i++) { /* Hack: required subcategory is stored in i_min */ const module_config_t *p_cfg = p_config + i; if( p_cfg->i_type == CONFIG_SUBCATEGORY && p_cfg->value.i == p_item->min.i ) combo->addItem( qtr( module_GetLongName( p_parser )), QVariant( module_get_object( p_parser ) ) ); if( p_item->value.psz && !strcmp( p_item->value.psz, module_get_object( p_parser ) ) ) combo->setCurrentIndex( combo->count() - 1 ); } module_config_free (p_config); } module_list_free( p_list ); if( p_item->psz_longtext ) { QString tipText = qtr(p_item->psz_longtext); combo->setToolTip( formatTooltip(tipText) ); if( label ) label->setToolTip( formatTooltip(tipText) ); } if( label ) label->setBuddy( combo ); }
inline void PluginDialog::FillTree() { module_t **p_list = module_list_get( NULL ); module_t *p_module; for( unsigned int i = 0; (p_module = p_list[i] ) != NULL; i++ ) { QStringList qs_item; qs_item << qfu( module_get_name( p_module, true ) ) << qfu( module_get_capability( p_module ) ) << QString::number( module_get_score( p_module ) ); #ifndef DEBUG if( qs_item.at(1).isEmpty() ) continue; #endif QTreeWidgetItem *item = new QTreeWidgetItem( qs_item ); treePlugins->addTopLevelItem( item ); } }
/** * Index the configuration items by name for faster lookups. */ int config_SortConfig (void) { size_t nmod; module_t **mlist = module_list_get (&nmod); if (unlikely(mlist == NULL)) return VLC_ENOMEM; size_t nconf = 0; for (size_t i = 0; i < nmod; i++) nconf += mlist[i]->confsize; module_config_t **clist = malloc (sizeof (*clist) * nconf); if (unlikely(clist == NULL)) { module_list_free (mlist); return VLC_ENOMEM; } 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 (item->i_type & CONFIG_HINT) continue; /* ignore hints */ clist[nconf++] = item; } } module_list_free (mlist); qsort (clist, nconf, sizeof (*clist), confcmp); config.list = clist; config.count = nconf; return VLC_SUCCESS; }
/***************************************** * Get the list of available audio outputs *****************************************/ libvlc_audio_output_t * libvlc_audio_output_list_get( libvlc_instance_t *p_instance ) { size_t count; module_t **module_list = module_list_get( &count ); libvlc_audio_output_t *list = NULL; for (size_t i = 0; i < count; i++) { module_t *module = module_list[i]; if( !module_provides( module, "audio output" ) ) continue; libvlc_audio_output_t *item = malloc( sizeof( *item ) ); if( unlikely(item == NULL) ) { error: libvlc_printerr( "Not enough memory" ); libvlc_audio_output_list_release( list ); list = NULL; break; } item->psz_name = strdup( module_get_object( module ) ); item->psz_description = strdup( module_get_name( module, true ) ); if( unlikely(item->psz_name == NULL || item->psz_description == NULL) ) { free( item->psz_name ); free( item->psz_description ); free( item ); goto error; } item->p_next = list; list = item; } module_list_free( module_list ); VLC_UNUSED( p_instance ); return list; }
/** * Loads module descriptions for all available plugins. * Fills the module bank structure with the plugin modules. * * \param p_this vlc object structure * \return total number of modules in bank after loading all plug-ins */ size_t module_LoadPlugins (vlc_object_t *obj) { /*vlc_assert_locked (&modules.lock); not for static mutexes :( */ if (modules.usage == 1) { module_InitStaticModules (); #ifdef HAVE_DYNAMIC_PLUGINS msg_Dbg (obj, "searching plug-in modules"); AllocateAllPlugins (obj); #endif config_UnsortConfig (); config_SortConfig (); } vlc_mutex_unlock (&modules.lock); size_t count; module_t **list = module_list_get (&count); module_list_free (list); msg_Dbg (obj, "plug-ins loaded: %zu modules", count); return count; }
/***************************************************************************** * ListModules: list the available modules with their description ***************************************************************************** * Print a list of all available modules (builtins and plugins) and a short * description for each one. *****************************************************************************/ static void ListModules (vlc_object_t *p_this, bool b_verbose) { bool color = false; ShowConsole(); #ifndef _WIN32 if (isatty(STDOUT_FILENO)) color = var_InheritBool(p_this, "color"); #else (void) p_this; #endif /* List all modules */ size_t count; module_t **list = module_list_get (&count); /* Enumerate each module */ for (size_t j = 0; j < count; j++) { module_t *p_parser = list[j]; const char *objname = module_get_object (p_parser); printf(color ? GREEN" %-22s "WHITE"%s\n"GRAY : " %-22s %s\n", objname, module_gettext(p_parser, p_parser->psz_longname)); if( b_verbose ) { char *const *pp_shortcuts = p_parser->pp_shortcuts; for( unsigned i = 0; i < p_parser->i_shortcuts; i++ ) if( strcmp( pp_shortcuts[i], objname ) ) printf(color ? CYAN" s %s\n"GRAY : " s %s\n", pp_shortcuts[i]); if (p_parser->psz_capability != NULL) printf(color ? MAGENTA" c %s (%d)\n"GRAY : " c %s (%d)\n", p_parser->psz_capability, p_parser->i_score); } } module_list_free (list); PauseConsole(); }
/***************************************************************************** * 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; }
/********************************************************************* * The Tree *********************************************************************/ PrefsTree::PrefsTree( intf_thread_t *_p_intf, QWidget *_parent ) : QTreeWidget( _parent ), p_intf( _p_intf ) { /* General Qt options */ setAlternatingRowColors( true ); setHeaderHidden( true ); setIconSize( QSize( ITEM_HEIGHT,ITEM_HEIGHT ) ); setTextElideMode( Qt::ElideNone ); setUniformRowHeights( true ); CONNECT( this, itemExpanded(QTreeWidgetItem*), this, resizeColumns() ); /* Nice icons */ #define BI( a,b) QIcon a##_icon = QIcon( b ) BI( audio, ":/prefsmenu/advanced/audio" ); BI( video, ":/prefsmenu/advanced/video" ); BI( input, ":/prefsmenu/advanced/codec" ); BI( sout, ":/prefsmenu/advanced/sout" ); BI( advanced, ":/prefsmenu/advanced/extended" ); BI( playlist, ":/prefsmenu/advanced/playlist" ); BI( interface, ":/prefsmenu/advanced/intf" ); #undef BI /* Build the tree for the main module */ module_t *p_module = module_get_main(); /* Initialisation and get the confsize */ PrefsItemData *data = NULL; PrefsItemData *data_sub = NULL; QTreeWidgetItem *current_item = NULL; unsigned confsize; module_config_t *const p_config = module_config_get (p_module, &confsize); /* Go through the list of conf */ for( size_t i = 0; i < confsize; i++ ) { const char *psz_help; QIcon icon; /* Work on a new item */ module_config_t *p_item = p_config + i; switch( p_item->i_type ) { /* This is a category */ case CONFIG_CATEGORY: if( p_item->value.i == -1 ) break; /* PrefsItemData Init */ data = new PrefsItemData(); data->name = qtr( config_CategoryNameGet( p_item->value.i ) ); psz_help = config_CategoryHelpGet( p_item->value.i ); if( psz_help ) data->help = qtr( psz_help ); else data->help.clear(); data->i_type = TYPE_CATEGORY; data->i_object_id = p_item->value.i; /* This is a category, put a nice icon */ switch( p_item->value.i ) { #define CI(a,b) case a: icon = b##_icon;break CI( CAT_AUDIO, audio ); CI( CAT_VIDEO, video ); CI( CAT_INPUT, input ); CI( CAT_SOUT, sout ); CI( CAT_ADVANCED, advanced ); CI( CAT_PLAYLIST, playlist ); CI( CAT_INTERFACE, interface ); } #undef CI /* Create a new QTreeItem to display it in the tree at top level */ current_item = new QTreeWidgetItem(); current_item->setText( 0, data->name ); current_item->setIcon( 0 , icon ); //current_item->setSizeHint( 0, QSize( -1, ITEM_HEIGHT ) ); current_item->setData( 0, Qt::UserRole, qVariantFromValue( data ) ); addTopLevelItem( current_item ); break; /* This is a subcategory */ case CONFIG_SUBCATEGORY: if( p_item->value.i == -1 ) break; /* Special cases: move the main subcategories to the parent cat*/ if( data && ( p_item->value.i == SUBCAT_VIDEO_GENERAL || p_item->value.i == SUBCAT_ADVANCED_MISC || p_item->value.i == SUBCAT_INPUT_GENERAL || p_item->value.i == SUBCAT_INTERFACE_GENERAL || p_item->value.i == SUBCAT_SOUT_GENERAL|| p_item->value.i == SUBCAT_PLAYLIST_GENERAL|| p_item->value.i == SUBCAT_AUDIO_GENERAL ) ) { /* Data still contains the correct thing */ data->i_type = TYPE_CATSUBCAT; data->i_subcat_id = p_item->value.i; data->name = qtr( config_CategoryNameGet( p_item->value.i ) ); psz_help = config_CategoryHelpGet( p_item->value.i ); if( psz_help ) data->help = qtr( psz_help ); else data->help.clear(); current_item->setData( 0, Qt::UserRole, QVariant::fromValue( data ) ); continue; } /* Normal Subcategories */ /* Process the Data */ data_sub = new PrefsItemData(); data_sub->name = qtr( config_CategoryNameGet( p_item->value.i) ); psz_help = config_CategoryHelpGet( p_item->value.i ); if( psz_help ) data_sub->help = qtr( psz_help ); else data_sub->help.clear(); data_sub->i_type = TYPE_SUBCATEGORY; data_sub->i_object_id = p_item->value.i; /* Create a new TreeWidget */ QTreeWidgetItem *subcat_item = new QTreeWidgetItem(); subcat_item->setText( 0, data_sub->name ); subcat_item->setData( 0, Qt::UserRole, qVariantFromValue( data_sub ) ); //subcat_item->setSizeHint( 0, QSize( -1, ITEM_HEIGHT ) ); /* Add it to the parent */ assert( current_item ); current_item->addChild( subcat_item ); break; /* Other items don't need yet a place on the tree */ } } module_config_free( p_config ); module_t **p_list = module_list_get( NULL ); /* Build the tree of plugins */ for( size_t i = 0; (p_module = p_list[i]) != NULL; i++ ) { // Main module excluded if( module_is_main( p_module) ) continue; unsigned confsize; int i_subcategory = 0, i_category = 0; bool b_options = false; module_config_t *const p_config = module_config_get (p_module, &confsize); /* Loop through the configurations items */ for (size_t i = 0; i < confsize; i++) { const module_config_t *p_item = p_config + i; if( p_item->i_type == CONFIG_CATEGORY ) i_category = p_item->value.i; else if( p_item->i_type == CONFIG_SUBCATEGORY ) i_subcategory = p_item->value.i; if( CONFIG_ITEM(p_item->i_type) ) b_options = true; if( b_options && i_category && i_subcategory ) break; } module_config_free (p_config); /* Dummy item, please proceed */ if( !b_options || i_category == 0 || i_subcategory == 0 ) continue; // Locate the category item; QTreeWidgetItem *subcat_item = NULL; bool b_found = false; for( int i_cat_index = 0 ; i_cat_index < topLevelItemCount(); i_cat_index++ ) { /* Get the treeWidgetItem that correspond to the category */ QTreeWidgetItem *cat_item = topLevelItem( i_cat_index ); PrefsItemData *data = cat_item->data( 0, Qt::UserRole ). value<PrefsItemData *>(); /* If we match the good category */ if( data->i_object_id == i_category ) { for( int i_sc_index = 0; i_sc_index < cat_item->childCount(); i_sc_index++ ) { subcat_item = cat_item->child( i_sc_index ); PrefsItemData *sc_data = subcat_item->data(0, Qt::UserRole). value<PrefsItemData *>(); if( sc_data && sc_data->i_object_id == i_subcategory ) { b_found = true; break; } } if( !b_found ) { subcat_item = cat_item; b_found = true; } break; } } if( !b_found ) continue; PrefsItemData *module_data = new PrefsItemData(); module_data->i_type = TYPE_MODULE; module_data->psz_name = strdup( module_get_object( p_module ) ); module_data->name = qtr( module_get_name( p_module, false ) ); module_data->help.clear(); const char *psz_help = module_get_help( p_module ); if ( psz_help ) module_data->help = qtr( psz_help ); QTreeWidgetItem *module_item = new QTreeWidgetItem(); module_item->setText( 0, module_data->name ); module_item->setData( 0, Qt::UserRole, QVariant::fromValue( module_data) ); //module_item->setSizeHint( 0, QSize( -1, ITEM_HEIGHT ) ); subcat_item->addChild( module_item ); } /* We got everything, just sort a bit */ sortItems( 0, Qt::AscendingOrder ); module_list_free( p_list ); resizeColumnToContents( 0 ); }
/** * Parse command line for configuration options. * * Now that the module_bank has been initialized, we can dynamically * generate the longopts structure used by getops. We have to do it this way * because we don't know (and don't want to know) in advance the configuration * options used (ie. exported) by each module. * * @param p_this object to write command line options as variables to * @param i_argc number of command line arguments * @param ppsz_args commandl ine arguments [IN/OUT] * @param pindex NULL to ignore unknown options, * otherwise index of the first non-option argument [OUT] * @return 0 on success, -1 on error. */ int config_LoadCmdLine( vlc_object_t *p_this, int i_argc, const char *ppsz_argv[], int *pindex ) { int i_cmd, i_index, i_opts, i_shortopts, flag, i_verbose = 0; module_t *p_parser; struct vlc_option *p_longopts; const char **argv_copy = NULL; #define b_ignore_errors (pindex == NULL) /* Short options */ module_config_t *pp_shortopts[256]; char *psz_shortopts; /* List all modules */ module_t **list = module_list_get (NULL); /* * Generate the longopts and shortopts structures used by getopt_long */ i_opts = 0; for (size_t i = 0; (p_parser = list[i]) != NULL; i++) /* count the number of exported configuration options (to allocate * longopts). We also need to allocate space for two options when * dealing with boolean to allow for --foo and --no-foo */ i_opts += p_parser->i_config_items + 2 * p_parser->i_bool_items; p_longopts = malloc( sizeof(*p_longopts) * (i_opts + 1) ); if( p_longopts == NULL ) { module_list_free (list); return -1; } psz_shortopts = malloc( 2 * i_opts + 1 ); if( psz_shortopts == NULL ) { free( p_longopts ); module_list_free (list); return -1; } /* If we are requested to ignore errors, then we must work on a copy * of the ppsz_argv array, otherwise getopt_long will reorder it for * us, ignoring the arity of the options */ if( b_ignore_errors ) { argv_copy = (const char**)malloc( i_argc * sizeof(char *) ); if( argv_copy == NULL ) { free( psz_shortopts ); free( p_longopts ); module_list_free (list); return -1; } memcpy( argv_copy, ppsz_argv, i_argc * sizeof(char *) ); ppsz_argv = argv_copy; } i_shortopts = 0; for( i_index = 0; i_index < 256; i_index++ ) { pp_shortopts[i_index] = NULL; } /* Fill the p_longopts and psz_shortopts structures */ i_index = 0; for (size_t i = 0; (p_parser = list[i]) != NULL; i++) { 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; p_item++ ) { /* Ignore hints */ if( p_item->i_type & CONFIG_HINT ) continue; /* Add item to long options */ p_longopts[i_index].name = strdup( p_item->psz_name ); if( p_longopts[i_index].name == NULL ) continue; p_longopts[i_index].has_arg = (p_item->i_type != CONFIG_ITEM_BOOL); p_longopts[i_index].flag = &flag; p_longopts[i_index].val = 0; i_index++; /* When dealing with bools we also need to add the --no-foo * option */ if( p_item->i_type == CONFIG_ITEM_BOOL ) { char *psz_name = malloc( strlen(p_item->psz_name) + 3 ); if( psz_name == NULL ) continue; strcpy( psz_name, "no" ); strcat( psz_name, p_item->psz_name ); p_longopts[i_index].name = psz_name; p_longopts[i_index].has_arg = false; p_longopts[i_index].flag = &flag; p_longopts[i_index].val = 1; i_index++; psz_name = malloc( strlen(p_item->psz_name) + 4 ); if( psz_name == NULL ) continue; strcpy( psz_name, "no-" ); strcat( psz_name, p_item->psz_name ); p_longopts[i_index].name = psz_name; p_longopts[i_index].has_arg = false; p_longopts[i_index].flag = &flag; p_longopts[i_index].val = 1; i_index++; } /* If item also has a short option, add it */ if( p_item->i_short ) { pp_shortopts[(int)p_item->i_short] = p_item; psz_shortopts[i_shortopts] = p_item->i_short; i_shortopts++; if( p_item->i_type != CONFIG_ITEM_BOOL && p_item->i_short != 'v' ) { psz_shortopts[i_shortopts] = ':'; i_shortopts++; } } } } /* We don't need the module list anymore */ module_list_free( list ); /* Close the longopts and shortopts structures */ memset( &p_longopts[i_index], 0, sizeof(*p_longopts) ); psz_shortopts[i_shortopts] = '\0'; int ret = -1; /* * Parse the command line options */ vlc_getopt_t state; state.optind = 0 ; /* set to 0 to tell GNU getopt to reinitialize */ while( ( i_cmd = vlc_getopt_long( i_argc, (char **)ppsz_argv, psz_shortopts, p_longopts, &i_index, &state ) ) != -1 ) { /* A long option has been recognized */ if( i_cmd == 0 ) { module_config_t *p_conf; const char *psz_name = p_longopts[i_index].name; /* Check if we deal with a --nofoo or --no-foo long option */ if( flag ) psz_name += psz_name[2] == '-' ? 3 : 2; /* Store the configuration option */ p_conf = config_FindConfig( p_this, psz_name ); if( p_conf ) { /* Check if the option is deprecated */ if( p_conf->b_removed ) { fprintf(stderr, "Warning: option --%s no longer exists.\n", psz_name); continue; } if( p_conf->psz_oldname && !strcmp( p_conf->psz_oldname, psz_name) ) { if( !b_ignore_errors ) { fprintf( stderr, "Error: option --%s is deprecated. " "Use --%s instead.\n", psz_name, p_conf->psz_name ); goto out; } psz_name = p_conf->psz_name; } switch( p_conf->i_type ) { case CONFIG_ITEM_STRING: case CONFIG_ITEM_PASSWORD: case CONFIG_ITEM_FILE: case CONFIG_ITEM_DIRECTORY: case CONFIG_ITEM_MODULE: case CONFIG_ITEM_MODULE_LIST: case CONFIG_ITEM_MODULE_LIST_CAT: case CONFIG_ITEM_MODULE_CAT: var_Create( p_this, psz_name, VLC_VAR_STRING ); var_SetString( p_this, psz_name, state.optarg ); break; case CONFIG_ITEM_INTEGER: var_Create( p_this, psz_name, VLC_VAR_INTEGER ); var_SetInteger( p_this, psz_name, strtol(state.optarg, NULL, 0)); break; case CONFIG_ITEM_FLOAT: var_Create( p_this, psz_name, VLC_VAR_FLOAT ); var_SetFloat( p_this, psz_name, us_atof(state.optarg) ); break; case CONFIG_ITEM_KEY: var_Create( p_this, psz_name, VLC_VAR_INTEGER ); var_SetInteger( p_this, psz_name, ConfigStringToKey( state.optarg ) ); break; case CONFIG_ITEM_BOOL: var_Create( p_this, psz_name, VLC_VAR_BOOL ); var_SetBool( p_this, psz_name, !flag ); break; } continue; } } /* A short option has been recognized */ if( pp_shortopts[i_cmd] != NULL ) { const char *name = pp_shortopts[i_cmd]->psz_name; switch( pp_shortopts[i_cmd]->i_type ) { case CONFIG_ITEM_STRING: case CONFIG_ITEM_PASSWORD: case CONFIG_ITEM_FILE: case CONFIG_ITEM_DIRECTORY: case CONFIG_ITEM_MODULE: case CONFIG_ITEM_MODULE_CAT: case CONFIG_ITEM_MODULE_LIST: case CONFIG_ITEM_MODULE_LIST_CAT: var_Create( p_this, name, VLC_VAR_STRING ); var_SetString( p_this, name, state.optarg ); break; case CONFIG_ITEM_INTEGER: var_Create( p_this, name, VLC_VAR_INTEGER ); if( i_cmd == 'v' ) { i_verbose++; /* -v */ var_SetInteger( p_this, name, i_verbose ); } else { var_SetInteger( p_this, name, strtol(state.optarg, NULL, 0) ); } break; case CONFIG_ITEM_BOOL: var_Create( p_this, name, VLC_VAR_BOOL ); var_SetBool( p_this, name, true ); break; } continue; } /* Internal error: unknown option */ if( !b_ignore_errors ) { fputs( "vlc: unknown option" " or missing mandatory argument ", stderr ); if( state.optopt ) { fprintf( stderr, "`-%c'\n", state.optopt ); } else { fprintf( stderr, "`%s'\n", ppsz_argv[state.optind-1] ); } fputs( "Try `vlc --help' for more information.\n", stderr ); goto out; } } ret = 0; if( pindex != NULL ) *pindex = state.optind; out: /* Free allocated resources */ for( i_index = 0; p_longopts[i_index].name; i_index++ ) free( (char *)p_longopts[i_index].name ); free( p_longopts ); free( psz_shortopts ); free( argv_copy ); return ret; }
/** * Finds and instantiates the best module of a certain type. * All candidates modules having the specified capability and name will be * sorted in decreasing order of priority. Then the probe callback will be * invoked for each module, until it succeeds (returns 0), or all candidate * module failed to initialize. * * The probe callback first parameter is the address of the module entry point. * Further parameters are passed as an argument list; it corresponds to the * variable arguments passed to this function. This scheme is meant to * support arbitrary prototypes for the module entry point. * * \param p_this VLC object * \param psz_capability capability, i.e. class of module * \param psz_name name name of the module asked, if any * \param b_strict if true, do not fallback to plugin with a different name * but the same capability * \param probe module probe callback * \return the module or NULL in case of a failure */ module_t *vlc_module_load(vlc_object_t *p_this, const char *psz_capability, const char *psz_name, bool b_strict, vlc_activate_t probe, ...) { int i_shortcuts = 0; char *psz_shortcuts = NULL, *psz_var = NULL, *psz_alias = NULL; bool b_force_backup = p_this->b_force; /* Deal with variables */ if( psz_name && psz_name[0] == '$' ) { psz_name = psz_var = var_CreateGetString( p_this, psz_name + 1 ); } /* Count how many different shortcuts were asked for */ if( psz_name && *psz_name ) { char *psz_parser, *psz_last_shortcut; /* If the user wants none, give him none. */ if( !strcmp( psz_name, "none" ) ) { free( psz_var ); return NULL; } i_shortcuts++; psz_parser = psz_shortcuts = psz_last_shortcut = strdup( psz_name ); while( ( psz_parser = strchr( psz_parser, ',' ) ) ) { *psz_parser = '\0'; i_shortcuts++; psz_last_shortcut = ++psz_parser; } /* Check if the user wants to override the "strict" mode */ if( psz_last_shortcut ) { if( !strcmp(psz_last_shortcut, "none") ) { b_strict = true; i_shortcuts--; } else if( !strcmp(psz_last_shortcut, "any") ) { b_strict = false; i_shortcuts--; } } } /* Sort the modules and test them */ size_t total, match = 0; module_t **p_all = module_list_get (&total); module_list_t *p_list = xmalloc( total * sizeof( module_list_t ) ); /* Parse the module list for capabilities and probe each of them */ for (size_t i = 0; i < total; i++) { module_t *p_module = p_all[i]; int i_shortcut_bonus = 0; /* Test that this module can do what we need */ if( !module_provides( p_module, psz_capability ) ) continue; /* If we required a shortcut, check this plugin provides it. */ if( i_shortcuts > 0 ) { const char *name = psz_shortcuts; for( unsigned i_short = i_shortcuts; i_short > 0; i_short-- ) { for( unsigned i = 0; i < p_module->i_shortcuts; i++ ) { char *c; if( ( c = strchr( name, '@' ) ) ? !strncasecmp( name, p_module->pp_shortcuts[i], c-name ) : !strcasecmp( name, p_module->pp_shortcuts[i] ) ) { /* Found it */ if( c && c[1] ) psz_alias = c+1; i_shortcut_bonus = i_short * 10000; goto found_shortcut; } } /* Go to the next shortcut... This is so lame! */ name += strlen( name ) + 1; } /* If we are in "strict" mode and we couldn't * find the module in the list of provided shortcuts, * then kick the bastard out of here!!! */ if( b_strict ) continue; } /* Trash <= 0 scored plugins (they can only be selected by shortcut) */ if( p_module->i_score <= 0 ) continue; found_shortcut: /* Store this new module */ p_list[match].p_module = p_module; p_list[match].i_score = p_module->i_score + i_shortcut_bonus; p_list[match].b_force = i_shortcut_bonus && b_strict; match++; } /* We can release the list, interesting modules are held */ module_list_free (p_all); if( match == 0 ) { msg_Dbg( p_this, "no %s module matched \"%s\"", psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); return NULL; // shortcut } /* Sort candidates by descending score */ qsort (p_list, match, sizeof (p_list[0]), modulecmp); msg_Dbg( p_this, "looking for %s module: %zu candidate%s", psz_capability, match, match == 1 ? "" : "s" ); /* Parse the linked list and use the first successful module */ module_t *p_module = NULL; va_list args; va_start(args, probe); for (size_t i = 0; (i < match) && (p_module == NULL); i++) { module_t *p_cand = p_list[i].p_module; if (module_Map (p_this, p_cand)) continue; p_this->b_force = p_list[i].b_force; int ret; if (likely(p_cand->pf_activate != NULL)) { va_list ap; va_copy(ap, args); ret = probe(p_cand->pf_activate, ap); va_end(ap); } else ret = VLC_SUCCESS; switch (ret) { case VLC_SUCCESS: /* good module! */ p_module = p_cand; break; case VLC_ETIMEOUT: /* good module, but aborted */ break; default: /* bad module */ continue; } } va_end (args); free( p_list ); p_this->b_force = b_force_backup; if( p_module != NULL ) { msg_Dbg( p_this, "using %s module \"%s\"", psz_capability, module_get_object(p_module) ); vlc_object_set_name( p_this, psz_alias ? psz_alias : module_get_object(p_module) ); } else msg_Dbg( p_this, "no %s module matching \"%s\" could be loaded", psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); free( psz_shortcuts ); free( psz_var ); /* Don't forget that the module is still locked */ return p_module; }
static void Usage (vlc_object_t *p_this, char const *psz_search) { bool b_has_advanced = false; bool found = false; unsigned i_only_advanced = 0; /* Number of modules ignored because they * only have advanced options */ bool strict = false; if (psz_search != NULL && psz_search[0] == '=') { strict = true; psz_search++; } bool color = false; #ifndef _WIN32 if (isatty(STDOUT_FILENO)) color = var_InheritBool(p_this, "color"); #endif const bool desc = var_InheritBool(p_this, "help-verbose"); const bool advanced = var_InheritBool(p_this, "advanced"); /* List all modules */ size_t count; module_t **list = module_list_get (&count); /* Enumerate the config for each module */ for (size_t i = 0; i < count; i++) { const module_t *m = list[i]; const module_config_t *section = NULL; const char *objname = module_get_object(m); if (m->i_config_items == 0) continue; /* Ignore modules without config options */ if (!module_match(m, psz_search, strict)) continue; found = true; if (!module_show(m, advanced)) { /* Ignore modules with only advanced config options if requested */ i_only_advanced++; continue; } /* Print name of module */ printf(color ? "\n " GREEN "%s" GRAY " (%s)\n" : "\n %s (%s)\n", module_gettext(m, m->psz_longname), objname); if (m->psz_help != NULL) printf(color ? CYAN" %s\n"GRAY : " %s\n", module_gettext(m, m->psz_help)); /* Print module options */ for (size_t j = 0; j < m->confsize; j++) { const module_config_t *item = m->p_config + j; if (item->b_removed) continue; /* Skip removed options */ if (item->b_advanced && !advanced) { /* Skip advanced options unless requested */ b_has_advanced = true; continue; } print_item(m, item, §ion, color, desc); } } if( b_has_advanced ) printf(color ? "\n" WHITE "%s" GRAY " %s\n" : "\n%s %s\n", _( "Note:" ), _( "add --advanced to your " "command line to see advanced options.")); if( i_only_advanced > 0 ) { printf(color ? "\n" WHITE "%s" GRAY " " : "\n%s ", _( "Note:" ) ); printf(vlc_ngettext("%u module was not displayed because it only has " "advanced options.\n", "%u modules were not displayed because " "they only have advanced options.\n", i_only_advanced), i_only_advanced); } else if (!found) printf(color ? "\n" WHITE "%s" GRAY "\n" : "\n%s\n", _("No matching module found. Use --list or " "--list-verbose to list available modules.")); /* Release the module list */ module_list_free (list); }
/***************************************************************************** * 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, const char *psz_module_name ) { FILE *file; file = config_OpenConfigFile (p_this); if (file == NULL) return VLC_EGENERIC; /* Look for the selected module, if NULL then save everything */ module_t **list = module_list_get (NULL); /* 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 */ } module_t *module = NULL; char line[1024], section[1022]; section[0] = '\0'; /* Ensure consistent number formatting... */ locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL); locale_t baseloc = uselocale (loc); while (fgets (line, 1024, file) != NULL) { /* Ignore comments and empty lines */ switch (line[0]) { case '#': case '\n': case '\0': continue; } if (line[0] == '[') { char *ptr = strchr (line, ']'); if (ptr == NULL) continue; /* syntax error; */ *ptr = '\0'; /* New section ( = a given module) */ strcpy (section, line + 1); module = NULL; if ((psz_module_name == NULL) || (strcmp (psz_module_name, section) == 0)) { for (int i = 0; list[i]; i++) { module_t *m = list[i]; if ((strcmp (section, m->psz_object_name) == 0) && (m->i_config_items > 0)) /* ignore config-less modules */ { module = m; if (psz_module_name != NULL) msg_Dbg (p_this, "loading config for module \"%s\"", section); break; } } } continue; } if (module == NULL) continue; /* no need to parse if there is no matching module */ char *ptr = strchr (line, '\n'); if (ptr != NULL) *ptr = '\0'; /* look for option name */ const char *psz_option_name = line; ptr = strchr (line, '='); if (ptr == NULL) continue; /* syntax error */ *ptr = '\0'; const char *psz_option_value = ptr + 1; /* try to match this option with one of the module's options */ for (size_t i = 0; i < module->confsize; i++) { module_config_t *p_item = module->p_config + i; if ((p_item->i_type & CONFIG_HINT) || strcmp (p_item->psz_name, psz_option_name)) continue; /* We found it */ errno = 0; vlc_mutex_lock( p_item->p_lock ); switch( p_item->i_type ) { case CONFIG_ITEM_BOOL: case CONFIG_ITEM_INTEGER: { long l = strtoi (psz_option_value); if (errno) msg_Warn (p_this, "Integer value (%s) for %s: %m", psz_option_value, psz_option_name); else p_item->saved.i = p_item->value.i = (int)l; break; } case CONFIG_ITEM_FLOAT: if( !*psz_option_value ) break; /* ignore empty option */ p_item->value.f = (float)atof (psz_option_value); p_item->saved.f = p_item->value.f; break; case CONFIG_ITEM_KEY: if( !*psz_option_value ) break; /* ignore empty option */ p_item->value.i = ConfigStringToKey(psz_option_value); p_item->saved.i = p_item->value.i; break; default: /* free old string */ free( (char*) p_item->value.psz ); free( (char*) p_item->saved.psz ); p_item->value.psz = convert (psz_option_value); p_item->saved.psz = strdupnull (p_item->value.psz); break; } vlc_mutex_unlock( p_item->p_lock ); break; } } if (ferror (file)) { msg_Err (p_this, "error reading configuration: %m"); clearerr (file); } fclose (file); module_list_free (list); if (loc != (locale_t)0) { uselocale (baseloc); freelocale (loc); } return 0; }
/** * 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; }