/**
* 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);
}
static int Remove( addons_storage_t *p_storage, addon_entry_t *p_entry )
{
vlc_mutex_lock( &p_entry->lock );
FOREACH_ARRAY( addon_file_t *p_file, p_entry->files )
switch( p_file->e_filetype )
{
case ADDON_EXTENSION:
case ADDON_PLAYLIST_PARSER:
case ADDON_SERVICE_DISCOVERY:
case ADDON_INTERFACE:
case ADDON_META:
case ADDON_SKIN2:
{
char *psz_dest;
char *psz_translated_filename = strdup( p_file->psz_filename );
if ( !psz_translated_filename )
return VLC_ENOMEM;
char *tmp = psz_translated_filename;
while (*tmp++) if ( *tmp == '/' ) *tmp = DIR_SEP_CHAR;
char *psz_dir = getAddonInstallDir( p_file->e_filetype );
if ( !psz_dir || asprintf( &psz_dest, "%s"DIR_SEP"%s", psz_dir,
psz_translated_filename ) < 1 )
{
free( psz_dir );
free( psz_translated_filename );
return VLC_EGENERIC;
}
free( psz_dir );
free( psz_translated_filename );
vlc_unlink( psz_dest );
msg_Dbg( p_storage, "removing %s", psz_dest );
free( psz_dest );
break;
}
/* Ignore all other unhandled files */
case ADDON_UNKNOWN:
case ADDON_PLUGIN:
case ADDON_OTHER:
default:
break;
}
FOREACH_END()
/* Remove file info on success */
FOREACH_ARRAY( addon_file_t *p_file, p_entry->files )
free( p_file->psz_filename );
free( p_file->psz_download_uri );
free( p_file );
FOREACH_END()
ARRAY_RESET( p_entry->files );
vlc_mutex_unlock( &p_entry->lock );
return VLC_SUCCESS;
}
/*****************************************************************************
* 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);
}
/*****************************************************************************
* Open: open the file
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
sout_access_out_sys_t *p_sys;
char *psz_idx;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access, "no file name specified" );
return VLC_EGENERIC;
}
if( !( p_sys = malloc ( sizeof( *p_sys ) ) ) )
return VLC_ENOMEM;
p_sys->i_seglen = var_GetInteger( p_access, SOUT_CFG_PREFIX "seglen" );
p_sys->i_seglenm = CLOCK_FREQ * p_sys->i_seglen;
p_sys->i_numsegs = var_GetInteger( p_access, SOUT_CFG_PREFIX "numsegs" );
p_sys->b_splitanywhere = var_GetBool( p_access, SOUT_CFG_PREFIX "splitanywhere" );
p_sys->b_delsegs = var_GetBool( p_access, SOUT_CFG_PREFIX "delsegs" );
p_sys->b_ratecontrol = var_GetBool( p_access, SOUT_CFG_PREFIX "ratecontrol") ;
p_sys->psz_indexPath = NULL;
psz_idx = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "index" );
if ( psz_idx )
{
char *psz_tmp;
psz_tmp = str_format( p_access, psz_idx );
free( psz_idx );
if ( !psz_tmp )
{
free( p_sys );
return VLC_ENOMEM;
}
path_sanitize( psz_tmp );
p_sys->psz_indexPath = psz_tmp;
vlc_unlink( p_sys->psz_indexPath );
}
p_sys->psz_indexUrl = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "index-url" );
p_access->p_sys = p_sys;
p_sys->i_handle = -1;
p_sys->i_segment = 0;
p_sys->psz_cursegPath = NULL;
p_access->pf_write = Write;
p_access->pf_seek = Seek;
p_access->pf_control = Control;
return VLC_SUCCESS;
}
void CacheDelete( vlc_object_t *obj, const char *dir )
{
char *path;
assert( dir != NULL );
if( asprintf( &path, "%s"DIR_SEP CACHE_NAME, dir ) == -1 )
return;
msg_Dbg( obj, "removing plugins cache file %s", path );
vlc_unlink( path );
free( path );
}
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;
}
static int Retrieve( addons_finder_t *p_finder, addon_entry_t *p_entry )
{
if ( !p_entry->psz_archive_uri )
return VLC_EGENERIC;
/* get archive and parse manifest */
stream_t *p_stream;
if ( p_entry->psz_archive_uri[0] == '/' )
{
/* Relative path */
char *psz_uri;
if ( ! asprintf( &psz_uri, ADDONS_REPO_SCHEMEHOST"%s", p_entry->psz_archive_uri ) )
return VLC_ENOMEM;
p_stream = stream_UrlNew( p_finder, psz_uri );
free( psz_uri );
}
else
{
p_stream = stream_UrlNew( p_finder, p_entry->psz_archive_uri );
}
msg_Dbg( p_finder, "downloading archive %s", p_entry->psz_archive_uri );
if ( !p_stream ) return VLC_EGENERIC;
/* In case of pf_ reuse */
if ( p_finder->p_sys->psz_tempfile )
{
vlc_unlink( p_finder->p_sys->psz_tempfile );
FREENULL( p_finder->p_sys->psz_tempfile );
}
p_finder->p_sys->psz_tempfile = tempnam( NULL, "vlp" );
if ( !p_finder->p_sys->psz_tempfile )
{
msg_Err( p_finder, "Can't create temp storage file" );
stream_Delete( p_stream );
return VLC_EGENERIC;
}
FILE *p_destfile = vlc_fopen( p_finder->p_sys->psz_tempfile, "w" );
if( !p_destfile )
{
msg_Err( p_finder, "Failed to open addon temp storage file" );
FREENULL(p_finder->p_sys->psz_tempfile);
stream_Delete( p_stream );
return VLC_EGENERIC;
}
char buffer[1<<10];
int i_read = 0;
while ( ( i_read = stream_Read( p_stream, &buffer, 1<<10 ) ) )
{
if ( fwrite( &buffer, i_read, 1, p_destfile ) < 1 )
{
msg_Err( p_finder, "Failed to write to Addon file" );
fclose( p_destfile );
stream_Delete( p_stream );
return VLC_EGENERIC;
}
}
fclose( p_destfile );
stream_Delete( p_stream );
msg_Dbg( p_finder, "Reading manifest from %s", p_finder->p_sys->psz_tempfile );
char *psz_manifest;
if ( asprintf( &psz_manifest, "unzip://%s!/manifest.xml",
p_finder->p_sys->psz_tempfile ) < 1 )
return VLC_ENOMEM;
p_stream = stream_UrlNew( p_finder, psz_manifest );
free( psz_manifest );
int i_ret = ( ParseManifest( p_finder, p_entry,
p_finder->p_sys->psz_tempfile, p_stream ) > 0 )
? VLC_SUCCESS : VLC_EGENERIC;
stream_Delete( p_stream );
return i_ret;
}
/*****************************************************************************
* 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 );
}
/*****************************************************************************
* Open: open the file
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
sout_access_out_sys_t *p_sys;
char *psz_idx;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access, "no file name specified" );
return VLC_EGENERIC;
}
if( unlikely( !( p_sys = calloc ( 1, sizeof( *p_sys ) ) ) ) )
return VLC_ENOMEM;
/* Try to get within asked segment length */
p_sys->i_seglen = var_GetInteger( p_access, SOUT_CFG_PREFIX "seglen" );
p_sys->i_seglenm = CLOCK_FREQ * p_sys->i_seglen;
p_sys->full_segments = NULL;
p_sys->full_segments_end = &p_sys->full_segments;
p_sys->ongoing_segment = NULL;
p_sys->ongoing_segment_end = &p_sys->ongoing_segment;
p_sys->i_numsegs = var_GetInteger( p_access, SOUT_CFG_PREFIX "numsegs" );
p_sys->i_initial_segment = var_GetInteger( p_access, SOUT_CFG_PREFIX "initial-segment-number" );
p_sys->b_splitanywhere = var_GetBool( p_access, SOUT_CFG_PREFIX "splitanywhere" );
p_sys->b_delsegs = var_GetBool( p_access, SOUT_CFG_PREFIX "delsegs" );
p_sys->b_ratecontrol = var_GetBool( p_access, SOUT_CFG_PREFIX "ratecontrol") ;
p_sys->b_caching = var_GetBool( p_access, SOUT_CFG_PREFIX "caching") ;
p_sys->b_generate_iv = var_GetBool( p_access, SOUT_CFG_PREFIX "generate-iv") ;
p_sys->b_segment_has_data = false;
p_sys->segments_t = vlc_array_new();
p_sys->stuffing_size = 0;
p_sys->i_opendts = VLC_TS_INVALID;
p_sys->i_dts_offset = 0;
p_sys->psz_indexPath = NULL;
psz_idx = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "index" );
if ( psz_idx )
{
char *psz_tmp;
psz_tmp = vlc_strftime( psz_idx );
free( psz_idx );
if ( !psz_tmp )
{
free( p_sys );
return VLC_ENOMEM;
}
p_sys->psz_indexPath = psz_tmp;
if( p_sys->i_initial_segment != 1 )
vlc_unlink( p_sys->psz_indexPath );
}
p_sys->psz_indexUrl = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "index-url" );
p_sys->psz_keyfile = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "key-loadfile" );
p_sys->key_uri = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "key-uri" );
p_access->p_sys = p_sys;
if( p_sys->psz_keyfile && ( LoadCryptFile( p_access ) < 0 ) )
{
free( p_sys->psz_indexUrl );
free( p_sys->psz_indexPath );
free( p_sys );
msg_Err( p_access, "Encryption init failed" );
return VLC_EGENERIC;
}
else if( !p_sys->psz_keyfile && ( CryptSetup( p_access, NULL ) < 0 ) )
{
free( p_sys->psz_indexUrl );
free( p_sys->psz_indexPath );
free( p_sys );
msg_Err( p_access, "Encryption init failed" );
return VLC_EGENERIC;
}
p_sys->i_handle = -1;
p_sys->i_segment = p_sys->i_initial_segment-1;
p_sys->psz_cursegPath = NULL;
p_access->pf_write = Write;
p_access->pf_seek = Seek;
p_access->pf_control = Control;
return VLC_SUCCESS;
}
static void OutputStart( sout_stream_t *p_stream )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
/* */
if( p_sys->b_drop )
return;
/* From now on drop packet that cannot be handled */
p_sys->b_drop = true;
/* Detect streams to smart select muxer */
const char *psz_muxer = NULL;
const char *psz_extension = NULL;
/* Look for preferred muxer
* TODO we could insert transcode in a few cases like
* s16l <-> s16b
*/
for( unsigned i = 0; i < sizeof(p_muxers) / sizeof(*p_muxers); i++ )
{
bool b_ok;
if( p_sys->i_id > p_muxers[i].i_es_max )
continue;
b_ok = true;
for( int j = 0; j < p_sys->i_id; j++ )
{
es_format_t *p_fmt = &p_sys->id[j]->fmt;
b_ok = false;
for( int k = 0; p_muxers[i].codec[k] != 0; k++ )
{
if( p_fmt->i_codec == p_muxers[i].codec[k] )
{
b_ok = true;
break;
}
}
if( !b_ok )
break;
}
if( !b_ok )
continue;
psz_muxer = p_muxers[i].psz_muxer;
psz_extension = p_muxers[i].psz_extension;
break;
}
/* If failed, brute force our demuxers and select the one that
* keeps most of our stream */
if( !psz_muxer || !psz_extension )
{
static const char ppsz_muxers[][2][4] = {
{ "avi", "avi" }, { "mp4", "mp4" }, { "ogg", "ogg" },
{ "asf", "asf" }, { "ts", "ts" }, { "ps", "mpg" },
{ "mkv", "mkv" },
#if 0
// XXX ffmpeg sefault really easily if you try an unsupported codec
// mov and avi at least segfault
{ "avformat{mux=avi}", "avi" },
{ "avformat{mux=mov}", "mov" },
{ "avformat{mux=mp4}", "mp4" },
{ "avformat{mux=nsv}", "nsv" },
{ "avformat{mux=flv}", "flv" },
#endif
};
int i_best = 0;
int i_best_es = 0;
msg_Warn( p_stream, "failed to find an adequate muxer, probing muxers" );
for( unsigned i = 0; i < sizeof(ppsz_muxers) / sizeof(*ppsz_muxers); i++ )
{
char *psz_file;
int i_es;
psz_file = tempnam( NULL, "vlc" );
if( !psz_file )
continue;
msg_Dbg( p_stream, "probing muxer %s", ppsz_muxers[i][0] );
i_es = OutputNew( p_stream, ppsz_muxers[i][0], psz_file, NULL );
if( i_es < 0 )
{
vlc_unlink( psz_file );
free( psz_file );
continue;
}
/* */
for( int i = 0; i < p_sys->i_id; i++ )
{
sout_stream_id_t *id = p_sys->id[i];
if( id->id )
sout_StreamIdDel( p_sys->p_out, id->id );
id->id = NULL;
}
if( p_sys->p_out )
sout_StreamChainDelete( p_sys->p_out, p_sys->p_out );
p_sys->p_out = NULL;
if( i_es > i_best_es )
{
i_best_es = i_es;
i_best = i;
if( i_best_es >= p_sys->i_id )
break;
}
vlc_unlink( psz_file );
free( psz_file );
}
/* */
psz_muxer = ppsz_muxers[i_best][0];
psz_extension = ppsz_muxers[i_best][1];
msg_Dbg( p_stream, "using muxer %s with extension %s (%d/%d streams accepted)",
psz_muxer, psz_extension, i_best_es, p_sys->i_id );
}
/* Create the output */
if( OutputNew( p_stream, psz_muxer, p_sys->psz_prefix, psz_extension ) < 0 )
{
msg_Err( p_stream, "failed to open output");
return;
}
/* Compute highest timestamp of first I over all streams */
p_sys->i_dts_start = 0;
for( int i = 0; i < p_sys->i_id; i++ )
{
sout_stream_id_t *id = p_sys->id[i];
block_t *p_block;
if( !id->id || !id->p_first )
continue;
mtime_t i_dts = id->p_first->i_dts;
for( p_block = id->p_first; p_block != NULL; p_block = p_block->p_next )
{
if( p_block->i_flags & BLOCK_FLAG_TYPE_I )
{
i_dts = p_block->i_dts;
break;
}
}
if( i_dts > p_sys->i_dts_start )
p_sys->i_dts_start = i_dts;
}
/* Send buffered data */
for( int i = 0; i < p_sys->i_id; i++ )
{
sout_stream_id_t *id = p_sys->id[i];
if( !id->id )
continue;
block_t *p_block = id->p_first;
while( p_block )
{
block_t *p_next = p_block->p_next;
p_block->p_next = NULL;
OutputSend( p_stream, id, p_block );
p_block = p_next;
}
id->p_first = NULL;
id->pp_last = &id->p_first;
}
}
/**
* 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;
}
int tar_extract_all( TAR *t, char *prefix )
{
union tar_buffer buffer;
int len, err, getheader = 1, remaining = 0;
FILE *outfile = NULL;
long path_max = pathconf (".", _PC_PATH_MAX);
size_t maxsize = (path_max == -1 || path_max > 4096) ? 4096 : path_max;
char fname[BLOCKSIZE + maxsize];
while( 1 )
{
len = gzread( *t, &buffer, BLOCKSIZE );
if( len < 0 )
{
fprintf( stderr, "%s\n", gzerror(*t, &err) );
}
/*
* Always expect complete blocks to process
* the tar information.
*/
if( len != 0 && len != BLOCKSIZE )
{
fprintf( stderr, "gzread: incomplete block read\n" );
return -1;
}
/*
* If we have to get a tar header
*/
if( getheader == 1 )
{
/*
* If we met the end of the tar
* or the end-of-tar block, we are done
*/
if( (len == 0) || (buffer.header.name[0] == 0) )
{
break;
}
snprintf( fname, sizeof(fname), "%s/%s", prefix, buffer.header.name );
/* Check magic value in header */
if( strncmp( buffer.header.magic, "GNUtar", 6 ) &&
strncmp( buffer.header.magic, "ustar", 5 ) )
{
//fprintf(stderr, "not a tar file\n");
return -1;
}
switch( buffer.header.typeflag )
{
case DIRTYPE:
makedir( fname );
break;
case REGTYPE:
case AREGTYPE:
remaining = getoct( buffer.header.size, 12 );
if( !remaining ) outfile = NULL; else
{
outfile = vlc_fopen( fname, "wb" );
if( outfile == NULL )
{
/* try creating directory */
char *p = strrchr( fname, '/' );
if( p != NULL )
{
*p = '\0';
makedir( fname );
*p = '/';
outfile = vlc_fopen( fname, "wb" );
if( !outfile )
{
fprintf( stderr, "tar couldn't create %s\n",
fname );
}
}
}
}
/*
* could have no contents
*/
getheader = (remaining) ? 0 : 1;
break;
default:
break;
}
}
else
{
unsigned int bytes = (remaining > BLOCKSIZE)?BLOCKSIZE:remaining;
if( outfile != NULL )
{
if( fwrite( &buffer, sizeof(char), bytes, outfile ) != bytes )
{
fprintf( stderr, "error writing %s skipping...\n", fname );
fclose( outfile );
outfile = NULL;
vlc_unlink( fname );
}
}
remaining -= bytes;
if( remaining == 0 )
{
getheader = 1;
if( outfile != NULL )
{
fclose(outfile);
outfile = NULL;
}
}
}
}
return 0;
}
static int Retrieve( addons_finder_t *p_finder, addon_entry_t *p_entry )
{
vlc_mutex_lock( &p_entry->lock );
if ( !p_entry->psz_archive_uri )
{
vlc_mutex_unlock( &p_entry->lock );
return VLC_EGENERIC;
}
char *psz_archive_uri = strdup( p_entry->psz_archive_uri );
vlc_mutex_unlock( &p_entry->lock );
if ( !psz_archive_uri )
return VLC_ENOMEM;
/* get archive and parse manifest */
stream_t *p_stream;
if ( psz_archive_uri[0] == '/' )
{
/* Relative path */
char *psz_uri;
if ( ! asprintf( &psz_uri, ADDONS_REPO_SCHEMEHOST"%s", psz_archive_uri ) )
{
free( psz_archive_uri );
return VLC_ENOMEM;
}
p_stream = vlc_stream_NewURL_ND( p_finder, psz_uri );
free( psz_uri );
}
else
{
p_stream = vlc_stream_NewURL_ND( p_finder, psz_archive_uri );
}
msg_Dbg( p_finder, "downloading archive %s", psz_archive_uri );
free ( psz_archive_uri );
if ( !p_stream ) return VLC_EGENERIC;
/* In case of pf_ reuse */
if ( p_finder->p_sys->psz_tempfile )
{
vlc_unlink( p_finder->p_sys->psz_tempfile );
FREENULL( p_finder->p_sys->psz_tempfile );
}
p_finder->p_sys->psz_tempfile = tempnam( NULL, "vlp" );
if ( !p_finder->p_sys->psz_tempfile )
{
msg_Err( p_finder, "Can't create temp storage file" );
vlc_stream_Delete( p_stream );
return VLC_EGENERIC;
}
int fd = vlc_open( p_finder->p_sys->psz_tempfile,
O_WRONLY | O_CREAT | O_EXCL, 0600 );
if( fd == -1 )
{
msg_Err( p_finder, "Failed to open addon temp storage file" );
FREENULL(p_finder->p_sys->psz_tempfile);
vlc_stream_Delete( p_stream );
return VLC_EGENERIC;
}
char buffer[1<<10];
ssize_t i_read = 0;
int i_ret = VLC_SUCCESS;
while ( ( i_read = vlc_stream_Read( p_stream, &buffer, 1<<10 ) ) > 0 )
{
if ( write( fd, buffer, i_read ) != i_read )
{
msg_Err( p_finder, "Failed to write to Addon file" );
i_ret = VLC_EGENERIC;
break;
}
}
vlc_close( fd );
vlc_stream_Delete( p_stream );
if (i_ret)
return i_ret;
msg_Dbg( p_finder, "Reading manifest from %s", p_finder->p_sys->psz_tempfile );
char *psz_tempfileuri = vlc_path2uri( p_finder->p_sys->psz_tempfile, NULL );
if ( !psz_tempfileuri )
return VLC_ENOMEM;
char *psz_manifest_uri;
if ( asprintf( &psz_manifest_uri, "%s#!/manifest.xml", psz_tempfileuri ) < 1 )
{
free( psz_tempfileuri );
return VLC_ENOMEM;
}
p_stream = vlc_stream_NewMRL( p_finder, psz_manifest_uri );
free( psz_manifest_uri );
if ( !p_stream )
{
free( psz_tempfileuri );
return VLC_EGENERIC;
}
vlc_mutex_lock( &p_entry->lock );
i_ret = ( ParseManifest( p_finder, p_entry, psz_tempfileuri, p_stream ) > 0 )
? VLC_SUCCESS : VLC_EGENERIC;
vlc_mutex_unlock( &p_entry->lock );
free( psz_tempfileuri );
vlc_stream_Delete( p_stream );
return i_ret;
}
