/**
* Saves a module cache to disk, and release cache data from memory.
*/
void CacheSave (vlc_object_t *p_this, const char *dir,
module_cache_t *entries, size_t n)
{
char *filename = NULL, *tmpname = NULL;
if (asprintf (&filename, "%s"DIR_SEP CACHE_NAME, dir ) == -1)
goto out;
if (asprintf (&tmpname, "%s.%"PRIu32, filename, (uint32_t)getpid ()) == -1)
goto out;
msg_Dbg (p_this, "saving plugins cache %s", filename);
FILE *file = vlc_fopen (tmpname, "wb");
if (file == NULL)
{
if (errno != EACCES && errno != ENOENT)
msg_Warn (p_this, "cannot create %s: %s", tmpname,
vlc_strerror_c(errno));
goto out;
}
if (CacheSaveBank (file, entries, n))
{
msg_Warn (p_this, "cannot write %s: %s", tmpname,
vlc_strerror_c(errno));
clearerr (file);
fclose (file);
vlc_unlink (tmpname);
goto out;
}
#if !defined( _WIN32 ) && !defined( __OS2__ )
vlc_rename (tmpname, filename); /* atomically replace old cache */
fclose (file);
#else
vlc_unlink (filename);
fclose (file);
vlc_rename (tmpname, filename);
#endif
out:
free (filename);
free (tmpname);
for (size_t i = 0; i < n; i++)
free (entries[i].path);
free (entries);
}
/*****************************************************************************
* SavePluginsCache: saves the plugins cache to a file
*****************************************************************************/
void CacheSave (vlc_object_t *p_this, const char *dir,
module_cache_t *const *pp_cache, size_t n)
{
char *filename, *tmpname;
if (asprintf (&filename, "%s"DIR_SEP CACHE_NAME, dir ) == -1)
return;
if (asprintf (&tmpname, "%s.%"PRIu32, filename, (uint32_t)getpid ()) == -1)
{
free (filename);
return;
}
msg_Dbg (p_this, "saving plugins cache %s", filename);
FILE *file = vlc_fopen (tmpname, "wb");
if (file == NULL)
{
if (errno != EACCES && errno != ENOENT)
msg_Warn (p_this, "cannot create %s (%m)", tmpname);
goto out;
}
if (CacheSaveBank (file, pp_cache, n))
{
msg_Warn (p_this, "cannot write %s (%m)", tmpname);
clearerr (file);
fclose (file);
vlc_unlink (tmpname);
goto out;
}
#if !defined( WIN32 ) && !defined( __OS2__ )
vlc_rename (tmpname, filename); /* atomically replace old cache */
fclose (file);
#else
vlc_unlink (filename);
fclose (file);
vlc_rename (tmpname, filename);
#endif
out:
free (filename);
free (tmpname);
}
int playlist_MLDump( playlist_t *p_playlist )
{
char *psz_temp;
psz_temp = config_GetUserDir( VLC_DATA_DIR );
if( !psz_temp ) /* XXX: This should never happen */
{
msg_Err( p_playlist, "no data directory, cannot save media library") ;
return VLC_EGENERIC;
}
char psz_dirname[ strlen( psz_temp ) + sizeof( DIR_SEP "ml.xspf")];
strcpy( psz_dirname, psz_temp );
free( psz_temp );
if( config_CreateDir( (vlc_object_t *)p_playlist, psz_dirname ) )
{
return VLC_EGENERIC;
}
strcat( psz_dirname, DIR_SEP "ml.xspf" );
if ( asprintf( &psz_temp, "%s.tmp%"PRIu32, psz_dirname, (uint32_t)getpid() ) < 1 )
return VLC_EGENERIC;
int i_ret = playlist_Export( p_playlist, psz_temp, p_playlist->p_media_library,
"export-xspf" );
if ( i_ret != VLC_SUCCESS )
{
vlc_unlink( psz_temp );
free( psz_temp );
return i_ret;
}
i_ret = vlc_rename( psz_temp, psz_dirname );
free( psz_temp );
if( i_ret == -1 )
{
msg_Err( p_playlist, "could not rename %s.tmp: %s",
psz_dirname, vlc_strerror_c(errno) );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* 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;
}
/*****************************************************************************
* Save Picture to disk
*****************************************************************************/
static void SavePicture( filter_t *p_filter, picture_t *p_pic )
{
filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys;
video_format_t fmt_in, fmt_out;
char *psz_filename = NULL;
char *psz_temp = NULL;
int i_ret;
memset( &fmt_in, 0, sizeof(video_format_t) );
memset( &fmt_out, 0, sizeof(video_format_t) );
/* Save snapshot psz_format to a memory zone */
fmt_in = p_pic->format;
fmt_out.i_sar_num = fmt_out.i_sar_den = 1;
fmt_out.i_width = p_sys->i_width;
fmt_out.i_height = p_sys->i_height;
fmt_out.i_chroma = p_sys->i_format;
/*
* Save the snapshot to a temporary file and
* switch it to the real name afterwards.
*/
if( p_sys->b_replace )
i_ret = asprintf( &psz_filename, "%s" DIR_SEP "%s.%s",
p_sys->psz_path, p_sys->psz_prefix,
p_sys->psz_format );
else
i_ret = asprintf( &psz_filename, "%s" DIR_SEP "%s%05d.%s",
p_sys->psz_path, p_sys->psz_prefix,
p_sys->i_frames, p_sys->psz_format );
if( i_ret == -1 )
{
msg_Err( p_filter, "could not create snapshot %s", psz_filename );
goto error;
}
path_sanitize( psz_filename );
i_ret = asprintf( &psz_temp, "%s.swp", psz_filename );
if( i_ret == -1 )
{
msg_Err( p_filter, "could not create snapshot temporarily file %s", psz_temp );
goto error;
}
path_sanitize( psz_temp );
/* Save the image */
i_ret = image_WriteUrl( p_sys->p_image, p_pic, &fmt_in, &fmt_out,
psz_temp );
if( i_ret != VLC_SUCCESS )
{
msg_Err( p_filter, "could not create snapshot %s", psz_temp );
}
else
{
/* switch to the final destination */
#if defined (_WIN32) || defined(__OS2__)
vlc_unlink( psz_filename );
#endif
i_ret = vlc_rename( psz_temp, psz_filename );
if( i_ret == -1 )
{
msg_Err( p_filter, "could not rename snapshot %s %m", psz_filename );
goto error;
}
}
error:
free( psz_temp );
free( psz_filename );
}
static int WriteCatalog( addons_storage_t *p_storage,
addon_entry_t **pp_entries, int i_entries )
{
addon_entry_t *p_entry;
char *psz_file;
char *psz_file_tmp;
char *psz_tempstring;
char *psz_userdir = config_GetUserDir( VLC_DATA_DIR );
if ( !psz_userdir ) return VLC_ENOMEM;
if ( asprintf( &psz_file, "%s%s", psz_userdir, ADDONS_CATALOG ) < 1 )
{
free( psz_userdir );
return VLC_ENOMEM;
}
free( psz_userdir );
if ( asprintf( &psz_file_tmp, "%s.tmp%"PRIu32, psz_file, (uint32_t)getpid() ) < 1 )
{
free( psz_file );
return VLC_ENOMEM;
}
char *psz_path = strdup( psz_file );
if ( !psz_path )
{
free( psz_file );
free( psz_file_tmp );
return VLC_ENOMEM;
}
char *psz_buf = strrchr( psz_path, DIR_SEP_CHAR );
if( psz_buf )
{
*++psz_buf = '\0';
/* ensure directory exists */
if( !EMPTY_STR( psz_path ) ) recursive_mkdir( VLC_OBJECT(p_storage), psz_path );
}
free( psz_path );
FILE *p_catalog = vlc_fopen( psz_file_tmp, "wt" );
if ( !p_catalog )
{
free( psz_file );
free( psz_file_tmp );
return VLC_EGENERIC;
}
/* write XML header */
fprintf( p_catalog, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
fprintf( p_catalog, "<videolan xmlns=\"http://videolan.org/ns/vlc/addons/1.0\">\n" );
fprintf( p_catalog, "\t<addons>\n" );
for ( int i=0; i<i_entries; i++ )
{
p_entry = pp_entries[i];
vlc_mutex_lock( &p_entry->lock );
psz_tempstring = NULL;
if ( ( p_entry->e_state != ADDON_INSTALLED ) ||
!( p_entry->e_flags & ADDON_MANAGEABLE ) )
{
vlc_mutex_unlock( &p_entry->lock );
continue;
}
if ( p_entry->psz_source_module )
psz_tempstring = vlc_xml_encode( p_entry->psz_source_module );
char *psz_uuid = addons_uuid_to_psz( ( const addon_uuid_t * ) & p_entry->uuid );
fprintf( p_catalog, "\t\t<addon source=\"%s\" type=\"%s\" id=\"%s\" "
"downloads=\"%ld\" score=\"%d\"",
( psz_tempstring ) ? psz_tempstring : "",
getTypePsz( p_entry->e_type ),
psz_uuid,
p_entry->i_downloads,
p_entry->i_score );
free( psz_uuid );
free( psz_tempstring );
WRITE_WITH_ENTITIES( " version=\"%s\"", p_entry->psz_version )
fprintf( p_catalog, ">\n" );
WRITE_WITH_ENTITIES( "\t\t\t<name>%s</name>\n", p_entry->psz_name )
WRITE_WITH_ENTITIES( "\t\t\t<summary>%s</summary>\n", p_entry->psz_summary )
if ( p_entry->psz_description )
{
psz_tempstring = p_entry->psz_description;
/* FIXME: do real escaping */
while( ( psz_tempstring = strstr( psz_tempstring, "]]>" ) ) )
*psz_tempstring = ' ';
fprintf( p_catalog, "\t\t\t<description><![CDATA[%s]]></description>\n", p_entry->psz_description );
}
WRITE_WITH_ENTITIES( "\t\t\t<image>%s</image>\n", p_entry->psz_image_data )
WRITE_WITH_ENTITIES( "\t\t\t<archive>%s</archive>\n", p_entry->psz_archive_uri )
fprintf( p_catalog, "\t\t\t<authorship>\n" );
WRITE_WITH_ENTITIES( "\t\t\t\t<creator>%s</creator>\n", p_entry->psz_author )
WRITE_WITH_ENTITIES( "\t\t\t\t<sourceurl>%s</sourceurl>\n", p_entry->psz_source_uri )
fprintf( p_catalog, "\t\t\t</authorship>\n" );
FOREACH_ARRAY( addon_file_t *p_file, p_entry->files )
psz_tempstring = vlc_xml_encode( p_file->psz_filename );
fprintf( p_catalog, "\t\t\t<resource type=\"%s\">%s</resource>\n",
getTypePsz( p_file->e_filetype ), psz_tempstring );
free( psz_tempstring );
FOREACH_END();
fprintf( p_catalog, "\t\t</addon>\n" );
vlc_mutex_unlock( &p_entry->lock );
}
fprintf( p_catalog, "\t</addons>\n" );
fprintf( p_catalog, "</videolan>\n" );
fclose( p_catalog );
int i_ret = vlc_rename( psz_file_tmp, psz_file );
free( psz_file );
free( psz_file_tmp );
if( i_ret == -1 )
{
msg_Err( p_storage, "could not rename temp catalog: %s",
vlc_strerror_c(errno) );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/**
* 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;
}
/************************************************************************
* updateIndexAndDel: If necessary, update index file & delete old segments
************************************************************************/
static int updateIndexAndDel( sout_access_out_t *p_access, sout_access_out_sys_t *p_sys, bool b_isend )
{
uint32_t i_firstseg;
if ( p_sys->i_numsegs == 0 || p_sys->i_segment < p_sys->i_numsegs )
i_firstseg = 1;
else
i_firstseg = ( p_sys->i_segment - p_sys->i_numsegs ) + 1;
// First update index
if ( p_sys->psz_indexPath )
{
int val;
FILE *fp;
char *psz_idxTmp;
if ( asprintf( &psz_idxTmp, "%s.tmp", p_sys->psz_indexPath ) < 0)
return -1;
fp = vlc_fopen( psz_idxTmp, "wt");
if ( !fp )
{
msg_Err( p_access, "cannot open index file `%s'", psz_idxTmp );
free( psz_idxTmp );
return -1;
}
if ( fprintf( fp, "#EXTM3U\n#EXT-X-TARGETDURATION:%zu\n#EXT-X-MEDIA-SEQUENCE:%"PRIu32"\n", p_sys->i_seglen, i_firstseg ) < 0 )
{
free( psz_idxTmp );
fclose( fp );
return -1;
}
char *psz_idxFormat = p_sys->psz_indexUrl ? p_sys->psz_indexUrl : p_access->psz_path;
for ( uint32_t i = i_firstseg; i <= p_sys->i_segment; i++ )
{
char *psz_name;
if ( ! ( psz_name = formatSegmentPath( p_access, psz_idxFormat, i, false ) ) )
{
free( psz_idxTmp );
fclose( fp );
return -1;
}
val = fprintf( fp, "#EXTINF:%zu,\n%s\n", p_sys->i_seglen, psz_name );
free( psz_name );
if ( val < 0 )
{
free( psz_idxTmp );
fclose( fp );
return -1;
}
}
if ( b_isend )
{
if ( fputs ( STR_ENDLIST, fp ) < 0)
{
free( psz_idxTmp );
fclose( fp ) ;
return -1;
}
}
fclose( fp );
val = vlc_rename ( psz_idxTmp, p_sys->psz_indexPath);
if ( val < 0 )
{
vlc_unlink( psz_idxTmp );
msg_Err( p_access, "Error moving LiveHttp index file" );
}
else
msg_Info( p_access, "LiveHttpIndexComplete: %s" , p_sys->psz_indexPath );
free( psz_idxTmp );
}
// Then take care of deletion
if ( p_sys->b_delsegs && i_firstseg > 1 )
{
char *psz_name = formatSegmentPath( p_access, p_access->psz_path, i_firstseg-1, true );
if ( psz_name )
{
vlc_unlink( psz_name );
free( psz_name );
}
}
return 0;
}
