/***************************************************************************** * config_GetType: get the type of a variable (bool, int, float, string) ***************************************************************************** * This function is used to get the type of a variable from its name. * Beware, this is quite slow. *****************************************************************************/ int config_GetType( vlc_object_t *p_this, const char *psz_name ) { module_config_t *p_config; int i_type; p_config = config_FindConfig( p_this, psz_name ); /* sanity checks */ if( !p_config ) { return 0; } switch( CONFIG_CLASS(p_config->i_type) ) { case CONFIG_ITEM_FLOAT: i_type = VLC_VAR_FLOAT; break; case CONFIG_ITEM_INTEGER: i_type = VLC_VAR_INTEGER; break; case CONFIG_ITEM_BOOL: i_type = VLC_VAR_BOOL; break; case CONFIG_ITEM_STRING: i_type = VLC_VAR_STRING; break; default: i_type = 0; break; } return i_type; }
/***************************************************************************** * config_GetType: get the type of a variable (bool, int, float, string) ***************************************************************************** * This function is used to get the type of a variable from its name. *****************************************************************************/ int config_GetType(const char *psz_name) { module_config_t *p_config = config_FindConfig(psz_name); /* sanity checks */ if( !p_config ) { return 0; } switch( CONFIG_CLASS(p_config->i_type) ) { case CONFIG_ITEM_FLOAT: return VLC_VAR_FLOAT; case CONFIG_ITEM_INTEGER: return VLC_VAR_INTEGER; case CONFIG_ITEM_BOOL: return VLC_VAR_BOOL; case CONFIG_ITEM_STRING: return VLC_VAR_STRING; default: return 0; } }
static void print_item(const module_t *m, const module_config_t *item, const module_config_t **section, bool color, bool desc) { #ifndef _WIN32 # define OPTION_VALUE_SEP " " #else # define OPTION_VALUE_SEP "=" #endif const char *bra = OPTION_VALUE_SEP "<", *type, *ket = ">"; const char *prefix = NULL, *suffix = NULL; char *typebuf = NULL; switch (CONFIG_CLASS(item->i_type)) { case 0: // hint class switch (item->i_type) { case CONFIG_HINT_CATEGORY: case CONFIG_HINT_USAGE: printf(color ? GREEN "\n %s\n" GRAY : "\n %s\n", module_gettext(m, item->psz_text)); if (desc && item->psz_longtext != NULL) printf(color ? CYAN " %s\n" GRAY : " %s\n", module_gettext(m, item->psz_longtext)); break; case CONFIG_SECTION: *section = item; break; } return; case CONFIG_ITEM_STRING: type = _("string"); if (item->list_count > 0) { size_t len = 0; for (unsigned i = 0; i < item->list_count; i++) len += strlen(item->list.psz[i]) + 1; typebuf = malloc(len); if (typebuf == NULL) break; bra = OPTION_VALUE_SEP "{"; type = typebuf; ket = "}"; *typebuf = 0; for (unsigned i = 0; i < item->list_count; i++) { if (i > 0) strcat(typebuf, ","); strcat(typebuf, item->list.psz[i]); } } break; case CONFIG_ITEM_INTEGER: type = _("integer"); if (item->list_count > 0) { size_t len = 0; for (unsigned i = 0; i < item->list_count; i++) len += strlen(module_gettext(m, item->list_text[i])) + 4 * sizeof (int) + 5; typebuf = malloc(len); if (typebuf == NULL) break; bra = OPTION_VALUE_SEP "{"; type = typebuf; ket = "}"; *typebuf = 0; for (unsigned i = 0; i < item->list_count; i++) { if (i != 0) strcat(typebuf, ", "); sprintf(typebuf + strlen(typebuf), "%i (%s)", item->list.i[i], module_gettext(m, item->list_text[i])); } } else if (item->min.i != 0 || item->max.i != 0) { if (asprintf(&typebuf, "%s [%"PRId64" .. %"PRId64"]", type, item->min.i, item->max.i) >= 0) type = typebuf; else typebuf = NULL; } break; case CONFIG_ITEM_FLOAT: type = _("float"); if (item->min.f != 0.f || item->max.f != 0.f) { if (asprintf(&typebuf, "%s [%f .. %f]", type, item->min.f, item->max.f) >= 0) type = typebuf; else typebuf = NULL; } break; case CONFIG_ITEM_BOOL: bra = type = ket = ""; prefix = ", --no-"; suffix = item->value.i ? _("(default enabled)") : _("(default disabled)"); break; default: return; } print_section(m, section, color, desc); /* Add short option if any */ char shortopt[4]; if (item->i_short != '\0') sprintf(shortopt, "-%c,", item->i_short); else strcpy(shortopt, " "); if (CONFIG_CLASS(item->i_type) == CONFIG_ITEM_BOOL) printf(color ? WHITE" %s --%s" "%s%s%s%s%s "GRAY : " %s --%s%s%s%s%s%s ", shortopt, item->psz_name, prefix, item->psz_name, bra, type, ket); else printf(color ? WHITE" %s --%s"YELLOW"%s%s%s%s%s "GRAY : " %s --%s%s%s%s%s%s ", shortopt, item->psz_name, "", "", /* XXX */ bra, type, ket); /* Wrap description */ int offset = PADDING_SPACES - strlen(item->psz_name) - strlen(bra) - vlc_swidth(type) - strlen(ket) - 1; if (CONFIG_CLASS(item->i_type) == CONFIG_ITEM_BOOL) offset -= strlen(item->psz_name) + vlc_swidth(prefix); if (offset < 0) { putchar('\n'); offset = PADDING_SPACES + LINE_START; } printf("%*s", offset, ""); print_desc(module_gettext(m, item->psz_longtext), PADDING_SPACES + LINE_START, color); if (suffix != NULL) { printf("%*s", offset, ""); print_desc(suffix, PADDING_SPACES + LINE_START, color); } if (desc && (item->psz_longtext != NULL && item->psz_longtext[0])) { /* Wrap long description */ printf("%*s", LINE_START + 2, ""); print_desc(module_gettext(m, item->psz_longtext), LINE_START + 2, false); } free(typebuf); }
/** * 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_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 (CONFIG_CLASS(item->i_type)) { case CONFIG_ITEM_BOOL: case CONFIG_ITEM_INTEGER: { int64_t l; errno = 0; l = vlc_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: %s", psz_option_value, psz_option_name, vlc_strerror_c(errno)); else 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); break; default: free ((char *)item->value.psz); item->value.psz = convert (psz_option_value); break; } } vlc_rwlock_unlock (&config_lock); free (line); if (ferror (file)) { msg_Err (p_this, "error reading configuration: %s", vlc_strerror_c(errno)); clearerr (file); } fclose (file); if (loc != (locale_t)0) { uselocale (baseloc); freelocale (loc); } return 0; }
/***************************************************************************** * config_SaveConfigFile: Save a module's 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) { 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,']'))) { module_t *module; /* we found a new section, check if we need to do a backup */ backup = true; for (int i = 0; (module = list[i]) != NULL; i++) { const char *objname = module_get_object (module); if (!strncmp (line + 1, objname, strlen (objname))) { 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 */ module_t *p_parser; for (int i = 0; (p_parser = list[i]) != NULL; 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 : ""); } 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; } #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); free (bigbuf); return 0; error: if( file ) fclose( file ); free (temporary); free (permanent); free (bigbuf); return -1; }