/*****************************************************************************
* Open a directory
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
if( !p_access->psz_filepath )
return VLC_EGENERIC;
/* Some tests can be skipped if this module was explicitly requested.
* That way, the user can play "corrupt" recordings if necessary
* and we can avoid false positives in the general case. */
bool b_strict = strcmp( p_access->psz_name, "vdr" );
/* Do a quick test based on the directory name to see if this
* directory might contain a VDR recording. We can be reasonably
* sure if ScanDirectory() actually finds files. */
if( b_strict )
{
char psz_extension[4];
int i_length = 0;
const char *psz_name = BaseName( p_access->psz_filepath );
if( sscanf( psz_name, "%*u-%*u-%*u.%*u.%*u.%*u%*[-.]%*u.%3s%n",
psz_extension, &i_length ) != 1 || strcasecmp( psz_extension, "rec" ) ||
( psz_name[i_length] != DIR_SEP_CHAR && psz_name[i_length] != '\0' ) )
return VLC_EGENERIC;
}
/* Only directories can be recordings */
struct stat st;
if( vlc_stat( p_access->psz_filepath, &st ) ||
!S_ISDIR( st.st_mode ) )
return VLC_EGENERIC;
access_sys_t *p_sys = vlc_calloc( p_this, 1, sizeof( *p_sys ) );
if( unlikely(p_sys == NULL) )
return VLC_ENOMEM;
p_access->p_sys = p_sys;
p_sys->fd = -1;
p_sys->cur_seekpoint = 0;
p_sys->fps = var_InheritFloat( p_access, "vdr-fps" );
ARRAY_INIT( p_sys->file_sizes );
/* Import all files and prepare playback. */
if( !ScanDirectory( p_access ) ||
!SwitchFile( p_access, 0 ) )
{
Close( p_this );
return VLC_EGENERIC;
}
ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
return VLC_SUCCESS;
}
static int open(access_t* p_access)
{
lt::add_torrent_params params;
if (TorrentAccess::ParseURI(p_access->psz_location, params) != VLC_SUCCESS)
return VLC_EGENERIC;
auto dir = var_GetDownloadDir(p_access);
if (dir == nullptr)
return VLC_EGENERIC;
p_access->p_sys = new access_sys_t{{p_access}};
auto& torrent = p_access->p_sys->torrent;
auto file_at = var_InheritInteger(p_access, "torrent-file-index");
torrent.set_parameters(std::move(params));
torrent.set_download_dir(std::move(dir));
if (!torrent.has_torrent_metadata()) {
// This is a magnet link, first we need to generate the torrent file.
if (torrent.RetrieveTorrentMetadata() != VLC_SUCCESS)
return VLC_EGENERIC;
}
if (file_at < 0) {
// Browse the torrent metadata and generate a playlist with the files in it.
ACCESS_SET_CALLBACKS(nullptr, nullptr, Control, nullptr);
p_access->pf_readdir = ReadDir;
return VLC_SUCCESS;
}
else {
// Torrent file has been browsed, start the download.
ACCESS_SET_CALLBACKS(nullptr, Block, Control, Seek);
torrent.StartDownload(file_at);
return VLC_SUCCESS;
}
}
/*****************************************************************************
* Open: open the file
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
access_sys_t *p_sys;
struct raw1394_portinfo port_inf[ 16 ];
msg_Dbg( p_access, "opening device" );
/* Set up p_access */
access_InitFields( p_access );
ACCESS_SET_CALLBACKS( NULL, Block, Control, NULL );
p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
if( !p_sys )
return VLC_EGENERIC;
p_sys->i_cards = 0;
p_sys->i_node = 0;
p_sys->i_port = 0;
p_sys->i_guid = 0;
p_sys->i_channel = 63;
p_sys->p_raw1394 = NULL;
p_sys->p_avc1394 = NULL;
p_sys->p_frame = NULL;
p_sys->p_ev = NULL;
vlc_mutex_init( &p_sys->lock );
p_sys->i_node = DiscoverAVC( p_access, &p_sys->i_port, p_sys->i_guid );
if( p_sys->i_node < 0 )
{
msg_Err( p_access, "failed to open a Firewire (IEEE1394) connection" );
Close( p_this );
return VLC_EGENERIC;
}
p_sys->p_avc1394 = AVCOpen( p_access, p_sys->i_port );
if( !p_sys->p_avc1394 )
{
msg_Err( p_access, "no Digital Video Control device found" );
Close( p_this );
return VLC_EGENERIC;
}
p_sys->p_raw1394 = raw1394_new_handle();
if( !p_sys->p_raw1394 )
{
msg_Err( p_access, "no Digital Video device found" );
Close( p_this );
return VLC_EGENERIC;
}
p_sys->i_cards = raw1394_get_port_info( p_sys->p_raw1394, port_inf, 16 );
if( p_sys->i_cards < 0 )
{
msg_Err( p_access, "failed to get port info" );
Close( p_this );
return VLC_EGENERIC;
}
if( raw1394_set_port( p_sys->p_raw1394, p_sys->i_port ) < 0 )
{
msg_Err( p_access, "failed to set port info" );
Close( p_this );
return VLC_EGENERIC;
}
if ( raw1394_iso_recv_init( p_sys->p_raw1394, Raw1394Handler,
ISOCHRONOUS_QUEUE_LENGTH, ISOCHRONOUS_MAX_PACKET_SIZE,
p_sys->i_channel, RAW1394_DMA_PACKET_PER_BUFFER, -1 ) < 0 )
{
msg_Err( p_access, "failed to init isochronous recv" );
Close( p_this );
return VLC_EGENERIC;
}
raw1394_set_userdata( p_sys->p_raw1394, p_access );
raw1394_iso_recv_start( p_sys->p_raw1394, -1, -1, 0 );
p_sys->raw1394_poll.fd = raw1394_get_fd( p_sys->p_raw1394 );
p_sys->raw1394_poll.events = POLLIN | POLLPRI;
/* Now create our event thread catcher */
p_sys->p_ev = calloc( 1, sizeof( *p_sys->p_ev ) );
if( !p_sys->p_ev )
{
msg_Err( p_access, "failed to create event thread struct" );
Close( p_this );
return VLC_ENOMEM;
}
p_sys->p_ev->p_frame = NULL;
p_sys->p_ev->pp_last = &p_sys->p_ev->p_frame;
p_sys->p_ev->p_access = p_access;
vlc_mutex_init( &p_sys->p_ev->lock );
if( vlc_clone( &p_sys->p_ev->thread, Raw1394EventThread,
p_sys->p_ev, VLC_THREAD_PRIORITY_OUTPUT ) )
{
msg_Err( p_access, "failed to clone event thread" );
Close( p_this );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: Initialize module's data structures and libdsm
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
stream_t *p_access = (stream_t*)p_this;
access_sys_t *p_sys;
smb_stat st;
/* Init p_access */
p_sys = p_access->p_sys = (access_sys_t*)calloc( 1, sizeof( access_sys_t ) );
if( p_access->p_sys == NULL )
return VLC_ENOMEM;
p_sys->p_ns = netbios_ns_new();
if( p_sys->p_ns == NULL )
goto error;
p_sys->p_session = smb_session_new();
if( p_sys->p_session == NULL )
goto error;
if( vlc_UrlParseFixup( &p_sys->url, p_access->psz_url ) != 0 )
goto error;
if( get_address( p_access ) != VLC_SUCCESS )
goto error;
msg_Dbg( p_access, "Session: Host name = %s, ip = %s", p_sys->netbios_name,
inet_ntoa( p_sys->addr ) );
/* Now that we have the required data, let's establish a session */
if( smb_session_connect( p_sys->p_session, p_sys->netbios_name,
p_sys->addr.s_addr, SMB_TRANSPORT_TCP )
!= DSM_SUCCESS )
{
msg_Err( p_access, "Unable to connect/negotiate SMB session");
goto error;
}
get_path( p_access );
if( login( p_access ) != VLC_SUCCESS )
{
msg_Err( p_access, "Unable to open file with path %s (in share %s)",
p_sys->psz_path, p_sys->psz_share );
goto error;
}
/* If there is no shares, browse them */
if( !p_sys->psz_share )
return BrowserInit( p_access );
assert(p_sys->i_fd > 0);
msg_Dbg( p_access, "Path: Share name = %s, path = %s", p_sys->psz_share,
p_sys->psz_path );
st = smb_stat_fd( p_sys->p_session, p_sys->i_fd );
if( smb_stat_get( st, SMB_STAT_ISDIR ) )
{
smb_fclose( p_sys->p_session, p_sys->i_fd );
return BrowserInit( p_access );
}
msg_Dbg( p_access, "Successfully opened smb://%s", p_access->psz_location );
ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
return VLC_SUCCESS;
error:
Close( p_this );
return VLC_EGENERIC;
}
/****************************************************************************
* Open: connect to smb server and ask for file
****************************************************************************/
static int Open( vlc_object_t *p_this )
{
stream_t *p_access = (stream_t*)p_this;
access_sys_t *p_sys;
struct stat filestat;
vlc_url_t url;
vlc_credential credential;
char *psz_decoded_path = NULL, *psz_uri = NULL,
*psz_var_domain = NULL;
int i_ret;
int i_smb;
uint64_t i_size;
bool b_is_dir = false;
#ifndef _WIN32
if( smbc_init( smb_auth, 0 ) )
return VLC_EGENERIC;
#endif
/*
** some version of glibc defines open as a macro, causing havoc
** with other macros using 'open' under the hood, such as the
** following one:
*/
#if defined(smbc_open) && defined(open)
# undef open
#endif
vlc_UrlParse( &url, p_access->psz_url );
if( url.psz_path )
{
psz_decoded_path = vlc_uri_decode_duplicate( url.psz_path );
if( !psz_decoded_path )
{
vlc_UrlClean( &url );
return VLC_EGENERIC;
}
}
vlc_credential_init( &credential, &url );
psz_var_domain = var_InheritString( p_access, "smb-domain" );
credential.psz_realm = psz_var_domain;
vlc_credential_get( &credential, p_access, "smb-user", "smb-pwd",
NULL, NULL );
for (;;)
{
if( smb_get_uri( p_access, &psz_uri, credential.psz_realm,
credential.psz_username, credential.psz_password,
url.psz_host, psz_decoded_path, NULL ) == -1 )
{
vlc_credential_clean( &credential );
free(psz_var_domain);
free( psz_decoded_path );
vlc_UrlClean( &url );
return VLC_ENOMEM;
}
if( ( i_ret = smbc_stat( psz_uri, &filestat ) ) && errno == EACCES )
{
errno = 0;
if( vlc_credential_get( &credential, p_access, "smb-user", "smb-pwd",
SMB_LOGIN_DIALOG_TITLE,
SMB_LOGIN_DIALOG_TEXT, url.psz_host) )
continue;
}
/* smbc_stat fails with servers or shares. Assume they are directory */
if( i_ret || S_ISDIR( filestat.st_mode ) )
b_is_dir = true;
break;
}
vlc_credential_store( &credential, p_access );
vlc_credential_clean( &credential );
free(psz_var_domain);
free( psz_decoded_path );
/* Init p_access */
p_sys =
p_access->p_sys = vlc_calloc( p_this, 1, sizeof( access_sys_t ) );
if( !p_sys )
{
free( psz_uri );
vlc_UrlClean( &url );
return VLC_ENOMEM;
}
if( b_is_dir )
{
p_sys->url = url;
p_access->pf_readdir = DirRead;
p_access->pf_control = access_vaDirectoryControlHelper;
i_size = 0;
#ifndef _WIN32
i_smb = smbc_opendir( psz_uri );
if( i_smb < 0 )
vlc_UrlClean( &p_sys->url );
#endif
}
else
{
ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
i_smb = smbc_open( psz_uri, O_RDONLY, 0 );
i_size = filestat.st_size;
vlc_UrlClean( &url );
}
free( psz_uri );
#ifndef _WIN32
if( i_smb < 0 )
{
msg_Err( p_access, "open failed for '%s' (%s)",
p_access->psz_location, vlc_strerror_c(errno) );
return VLC_EGENERIC;
}
#endif
p_sys->size = i_size;
p_sys->i_smb = i_smb;
return VLC_SUCCESS;
}
