char *vlc_uri_decode_duplicate (const char *str)
{
char *buf = strdup (str);
if (vlc_uri_decode (buf) == NULL)
{
free (buf);
buf = NULL;
}
return buf;
}
void InputManager::UpdateName()
{
/* Update text, name and nowplaying */
QString name;
/* Try to get the nowplaying */
char *format = var_InheritString( p_intf, "input-title-format" );
char *formatted = NULL;
if (format != NULL)
{
formatted = vlc_strfinput( p_input, format );
free( format );
if( formatted != NULL )
{
name = qfu(formatted);
free( formatted );
}
}
/* If we have Nothing */
if( name.simplified().isEmpty() )
{
char *uri = input_item_GetURI( input_GetItem( p_input ) );
char *file = uri ? strrchr( uri, '/' ) : NULL;
if( file != NULL )
{
vlc_uri_decode( ++file );
name = qfu(file);
}
else
name = qfu(uri);
free( uri );
}
name = name.trimmed();
if( oldName != name )
{
emit nameChanged( name );
oldName = name;
}
}
void input_item_SetURI( input_item_t *p_i, const char *psz_uri )
{
assert( psz_uri );
#ifndef NDEBUG
if( !strstr( psz_uri, "://" )
|| strchr( psz_uri, ' ' ) || strchr( psz_uri, '"' ) )
fprintf( stderr, "Warning: %s(\"%s\"): file path instead of URL.\n",
__func__, psz_uri );
#endif
vlc_mutex_lock( &p_i->lock );
free( p_i->psz_uri );
p_i->psz_uri = strdup( psz_uri );
p_i->i_type = GuessType( p_i, &p_i->b_net );
if( p_i->psz_name )
;
else
if( p_i->i_type == ITEM_TYPE_FILE || p_i->i_type == ITEM_TYPE_DIRECTORY )
{
const char *psz_filename = strrchr( p_i->psz_uri, '/' );
if( psz_filename && *psz_filename == '/' )
psz_filename++;
if( psz_filename && *psz_filename )
p_i->psz_name = strdup( psz_filename );
/* Make the name more readable */
if( p_i->psz_name )
{
vlc_uri_decode( p_i->psz_name );
EnsureUTF8( p_i->psz_name );
}
}
else
{ /* Strip login and password from title */
int r;
vlc_url_t url;
vlc_UrlParse( &url, psz_uri );
if( url.psz_protocol )
{
if( url.i_port > 0 )
r=asprintf( &p_i->psz_name, "%s://%s:%d%s", url.psz_protocol,
url.psz_host, url.i_port,
url.psz_path ? url.psz_path : "" );
else
r=asprintf( &p_i->psz_name, "%s://%s%s", url.psz_protocol,
url.psz_host ? url.psz_host : "",
url.psz_path ? url.psz_path : "" );
}
else
{
if( url.i_port > 0 )
r=asprintf( &p_i->psz_name, "%s:%d%s", url.psz_host, url.i_port,
url.psz_path ? url.psz_path : "" );
else
r=asprintf( &p_i->psz_name, "%s%s", url.psz_host,
url.psz_path ? url.psz_path : "" );
}
vlc_UrlClean( &url );
if( -1==r )
p_i->psz_name=NULL; /* recover from undefined value */
}
vlc_mutex_unlock( &p_i->lock );
}
int RarAccessOpen(vlc_object_t *object)
{
access_t *access = (access_t*)object;
const char *name = strchr(access->psz_location, '|');
if (name == NULL)
return VLC_EGENERIC;
char *base = strndup(access->psz_location, name - access->psz_location);
if (unlikely(base == NULL))
return VLC_ENOMEM;
name++;
vlc_uri_decode(base);
stream_t *s = vlc_stream_NewMRL(access, base);
if (!s || RarProbe(s))
goto error;
struct
{
int filescount;
rar_file_t **files;
unsigned int i_nbvols;
} newscheme = { 0, NULL, 0 }, oldscheme = { 0, NULL, 0 }, *p_scheme;
if (RarParse(s, &newscheme.filescount, &newscheme.files, &newscheme.i_nbvols, false)
|| newscheme.filescount < 1 || newscheme.i_nbvols < 2 )
{
/* We might want to lookup old naming scheme, could be a part1.rar,part1.r00 */
vlc_stream_Seek(s, 0);
RarParse(s, &oldscheme.filescount, &oldscheme.files, &oldscheme.i_nbvols, true);
}
if (oldscheme.filescount >= newscheme.filescount && oldscheme.i_nbvols > newscheme.i_nbvols)
{
for (int i = 0; i < newscheme.filescount; i++)
RarFileDelete(newscheme.files[i]);
free(newscheme.files);
p_scheme = &oldscheme;
msg_Dbg(s, "using rar old naming for %d files nbvols %u", p_scheme->filescount, oldscheme.i_nbvols);
}
else if (newscheme.filescount)
{
for (int i = 0; i < oldscheme.filescount; i++)
RarFileDelete(oldscheme.files[i]);
free(oldscheme.files);
p_scheme = &newscheme;
msg_Dbg(s, "using rar new naming for %d files nbvols %u", p_scheme->filescount, oldscheme.i_nbvols);
}
else
{
msg_Info(s, "Invalid or unsupported RAR archive");
for (int i = 0; i < oldscheme.filescount; i++)
RarFileDelete(oldscheme.files[i]);
free(oldscheme.files);
for (int i = 0; i < newscheme.filescount; i++)
RarFileDelete(newscheme.files[i]);
free(newscheme.files);
goto error;
}
rar_file_t *file = NULL;
for (int i = 0; i < p_scheme->filescount; i++) {
if (!file && !strcmp(p_scheme->files[i]->name, name))
file = p_scheme->files[i];
else
RarFileDelete(p_scheme->files[i]);
}
free(p_scheme->files);
if (!file)
goto error;
access_sys_t *sys = access->p_sys = malloc(sizeof(*sys));
sys->s = s;
sys->file = file;
access->pf_read = Read;
access->pf_block = NULL;
access->pf_control = Control;
access->pf_seek = Seek;
rar_file_chunk_t dummy = {
.mrl = base,
};
sys->chunk = &dummy;
Seek(access, 0);
free(base);
return VLC_SUCCESS;
error:
if (s)
vlc_stream_Delete(s);
free(base);
return VLC_EGENERIC;
}
int AccessOpen(vlc_object_t *p_object)
{
access_t *p_access = (access_t*)p_object;
const char *sep = strchr(p_access->psz_location, ARCHIVE_SEP_CHAR);
if (sep == NULL)
return VLC_EGENERIC;
char *psz_base = strdup(p_access->psz_location);
if (unlikely(psz_base == NULL))
return VLC_ENOMEM;
char *psz_name = psz_base + (sep - p_access->psz_location);
*(psz_name++) = '\0';
if (vlc_uri_decode(psz_base) == NULL)
{
free(psz_base);
return VLC_EGENERIC;
}
access_sys_t *p_sys = p_access->p_sys = calloc(1, sizeof(access_sys_t));
p_sys->p_archive = archive_read_new();
if (!p_sys->p_archive)
{
msg_Err(p_access, "can't create libarchive instance: %s",
archive_error_string(p_sys->p_archive));
free(psz_base);
goto error;
}
EnableArchiveFormats(p_sys->p_archive);
/* Set up the switch callback for multiple volumes handling */
archive_read_set_switch_callback(p_sys->p_archive, SwitchCallback);
/* !Warn: sucks because libarchive can't guess format without reading 1st header
* and it can't tell either if volumes are missing neither set following
* volumes after the first Open().
* We need to know volumes uri in advance then :/
*/
/* Try to list existing volumes */
char **ppsz_files = NULL;
unsigned int i_files = 0;
FindVolumes(p_access, p_sys->p_archive, psz_base, &ppsz_files, &i_files);
p_sys->i_callback_data = 1 + i_files;
p_sys->p_callback_data = malloc(sizeof(callback_data_t) * p_sys->i_callback_data);
if (!p_sys->p_callback_data)
{
for(unsigned int i=0; i<i_files; i++)
free(ppsz_files[i]);
free(ppsz_files);
free(psz_base);
AccessClose(p_object);
return VLC_ENOMEM;
}
/* set up our callback struct for our main uri */
p_sys->p_callback_data[0].psz_uri = psz_base;
p_sys->p_callback_data[0].p_access = p_access;
archive_read_append_callback_data(p_sys->p_archive, &p_sys->p_callback_data[0]);
/* and register other volumes */
for(unsigned int i=0; i<i_files; i++)
{
p_sys->p_callback_data[1+i].psz_uri = ppsz_files[i];
p_sys->p_callback_data[1+i].p_access = p_access;
archive_read_append_callback_data(p_sys->p_archive, &p_sys->p_callback_data[1+i]);
}
free(ppsz_files);
if (archive_read_open2(p_sys->p_archive, &p_sys->p_callback_data[0],
OpenCallback, ReadCallback, SkipCallback, CloseCallback) != ARCHIVE_OK)
{
msg_Err(p_access, "can't open archive: %s",
archive_error_string(p_sys->p_archive));
AccessClose(p_object);
return VLC_EGENERIC;
}
bool b_present = false;
while(archive_read_next_header(p_sys->p_archive, &p_sys->p_entry) == ARCHIVE_OK)
{
if (!strcmp(archive_entry_pathname(p_sys->p_entry), psz_name))
{
b_present = true;
break;
}
msg_Dbg(p_access, "skipping entry %s != %s", archive_entry_pathname(p_sys->p_entry), psz_name);
}
if (!b_present)
{
msg_Err(p_access, "entry '%s' not found in archive", psz_name);
/* entry not found */
goto error;
}
msg_Dbg(p_access, "reading entry %s %"PRId64, archive_entry_pathname(p_sys->p_entry),
archive_entry_size(p_sys->p_entry));
/* try to guess if it is seekable or not (does not depend on backend) */
p_sys->b_seekable = (archive_seek_data(p_sys->p_archive, 0, SEEK_SET) >= 0);
p_access->pf_read = Read;
p_access->pf_block = NULL; /* libarchive's zerocopy keeps owning block :/ */
p_access->pf_control = Control;
p_access->pf_seek = Seek;
return VLC_SUCCESS;
error:
AccessClose(p_object);
return VLC_EGENERIC;
}