/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_intf->p_sys;
vlc_cancel(p_sys->thread);
vlc_join(p_sys->thread, NULL);
var_DelCallback(pl_Get(p_intf), "input-current", ItemChange, p_intf);
if (p_sys->p_input != NULL)
{
var_DelCallback(p_sys->p_input, "intf-event", PlayingChange, p_intf);
vlc_object_release(p_sys->p_input);
}
int i;
for (i = 0; i < p_sys->i_songs; i++)
DeleteSong(&p_sys->p_queue[i]);
vlc_UrlClean(&p_sys->p_submit_url);
vlc_UrlClean(&p_sys->p_nowp_url);
vlc_cond_destroy(&p_sys->wait);
vlc_mutex_destroy(&p_sys->lock);
free(p_sys);
}
/*****************************************************************************
* Open: Starts the RTSP server module
*****************************************************************************/
int OpenVoD( vlc_object_t *p_this )
{
vod_t *p_vod = (vod_t *)p_this;
vod_sys_t *p_sys = NULL;
char *psz_url;
p_vod->p_sys = p_sys = malloc( sizeof( vod_sys_t ) );
if( !p_sys ) goto error;
psz_url = var_InheritString( p_vod, "rtsp-host" );
if( psz_url == NULL )
p_sys->psz_rtsp_path = strdup( "/" );
else
{
vlc_url_t url;
vlc_UrlParse( &url, psz_url, 0 );
free( psz_url );
if( url.psz_path == NULL )
p_sys->psz_rtsp_path = strdup( "/" );
else
if( !( strlen( url.psz_path ) > 0
&& url.psz_path[strlen( url.psz_path ) - 1] == '/' ) )
{
if( asprintf( &p_sys->psz_rtsp_path, "%s/", url.psz_path ) == -1 )
{
p_sys->psz_rtsp_path = NULL;
vlc_UrlClean( &url );
goto error;
}
}
else
p_sys->psz_rtsp_path = strdup( url.psz_path );
vlc_UrlClean( &url );
}
p_vod->pf_media_new = MediaNew;
p_vod->pf_media_del = MediaAskDel;
p_sys->p_fifo_cmd = block_FifoNew();
if( vlc_clone( &p_sys->thread, CommandThread, p_vod, VLC_THREAD_PRIORITY_LOW ) )
{
msg_Err( p_vod, "cannot spawn rtsp vod thread" );
block_FifoRelease( p_sys->p_fifo_cmd );
goto error;
}
return VLC_SUCCESS;
error:
if( p_sys )
{
free( p_sys->psz_rtsp_path );
free( p_sys );
}
return VLC_EGENERIC;
}
/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_intf->p_sys;
vlc_playlist_t *playlist = p_sys->playlist;
vlc_cancel(p_sys->thread);
vlc_join(p_sys->thread, NULL);
int i;
for (i = 0; i < p_sys->i_songs; i++)
DeleteSong(&p_sys->p_queue[i]);
vlc_UrlClean(&p_sys->p_submit_url);
vlc_UrlClean(&p_sys->p_nowp_url);
vlc_cond_destroy(&p_sys->wait);
vlc_mutex_destroy(&p_sys->lock);
vlc_playlist_Lock(playlist);
vlc_player_RemoveListener(
vlc_playlist_GetPlayer(playlist), p_sys->player_listener);
vlc_playlist_RemoveListener(playlist, p_sys->playlist_listener);
vlc_playlist_Unlock(playlist);
free(p_sys);
}
/*****************************************************************************
* Open: initialize dummy interface
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
vlm_t *mediatheque;
char *psz_address;
vlc_url_t url;
int i_telnetport;
if( !(mediatheque = vlm_New( p_intf )) )
{
msg_Err( p_intf, "cannot start VLM" );
return VLC_EGENERIC;
}
msg_Info( p_intf, "using the VLM interface plugin..." );
i_telnetport = config_GetInt( p_intf, "telnet-port" );
psz_address = config_GetPsz( p_intf, "telnet-host" );
vlc_UrlParse(&url, psz_address, 0);
// There might be two ports given, resolve any potentially
// conflict
url.i_port = getPort(p_intf, url, i_telnetport);
p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
if( ( p_intf->p_sys->pi_fd = net_ListenTCP( p_intf, url.psz_host, url.i_port ) )
== NULL )
{
msg_Err( p_intf, "cannot listen for telnet" );
vlc_UrlClean(&url);
free( psz_address );
free( p_intf->p_sys );
return VLC_EGENERIC;
}
msg_Info( p_intf,
"telnet interface started on interface %s %d",
url.psz_host, url.i_port );
p_intf->p_sys->i_clients = 0;
p_intf->p_sys->clients = NULL;
p_intf->p_sys->mediatheque = mediatheque;
p_intf->pf_run = Run;
vlc_UrlClean(&url);
free( psz_address );
return VLC_SUCCESS;
}
static int vlclua_url_parse( lua_State *L )
{
const char *psz_url = luaL_checkstring( L, 1 );
const char *psz_option = luaL_optstring( L, 2, NULL );
vlc_url_t url;
vlc_UrlParse( &url, psz_url, psz_option?*psz_option:0 );
lua_newtable( L );
lua_pushstring( L, url.psz_protocol );
lua_setfield( L, -2, "protocol" );
lua_pushstring( L, url.psz_username );
lua_setfield( L, -2, "username" );
lua_pushstring( L, url.psz_password );
lua_setfield( L, -2, "password" );
lua_pushstring( L, url.psz_host );
lua_setfield( L, -2, "host" );
lua_pushinteger( L, url.i_port );
lua_setfield( L, -2, "port" );
lua_pushstring( L, url.psz_path );
lua_setfield( L, -2, "path" );
lua_pushstring( L, url.psz_option );
lua_setfield( L, -2, "option" );
vlc_UrlClean( &url );
return 1;
}
/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_intf->p_sys;
var_DelCallback(pl_Get(p_intf), "activity", ItemChange, p_intf);
vlc_cancel(p_sys->thread);
vlc_join(p_sys->thread, NULL);
input_thread_t *p_input = pl_CurrentInput(p_intf);
if (p_input)
{
if (p_sys->b_state_cb)
var_DelCallback(p_input, "intf-event", PlayingChange, p_intf);
vlc_object_release(p_input);
}
int i;
for (i = 0; i < p_sys->i_songs; i++)
DeleteSong(&p_sys->p_queue[i]);
vlc_UrlClean(&p_sys->p_submit_url);
#if 0 //NOT USED
free(p_sys->psz_nowp_host);
free(p_sys->psz_nowp_file);
#endif
vlc_cond_destroy(&p_sys->wait);
vlc_mutex_destroy(&p_sys->lock);
free(p_sys);
}
static void
Close(vlc_object_t *p_obj)
{
access_t *p_access = (access_t *)p_obj;
access_sys_t *p_sys = p_access->p_sys;
if (p_sys->p_nfsfh != NULL)
nfs_close(p_sys->p_nfs, p_sys->p_nfsfh);
if (p_sys->p_nfsdir != NULL)
nfs_closedir(p_sys->p_nfs, p_sys->p_nfsdir);
if (p_sys->p_nfs != NULL)
nfs_destroy_context(p_sys->p_nfs);
if (p_sys->p_mount != NULL)
{
for (int i = 0; i < p_sys->res.exports.i_count; ++i)
free(p_sys->res.exports.ppsz_names[i]);
free(p_sys->res.exports.ppsz_names);
rpc_destroy_context(p_sys->p_mount);
}
if (p_sys->p_nfs_url != NULL)
nfs_destroy_url(p_sys->p_nfs_url);
vlc_UrlClean(&p_sys->encoded_url);
free(p_sys->psz_url_decoded);
free(p_sys->psz_url_decoded_slash);
free(p_sys);
}
/*****************************************************************************
* Close: close the target
*****************************************************************************/
static void Close( vlc_object_t * p_this )
{
sout_access_out_t *p_access = (sout_access_out_t *) p_this;
sout_access_out_sys_t *p_sys = p_access->p_sys;
int i;
vlc_cancel( p_sys->p_thread->thread );
vlc_join( p_sys->p_thread->thread, NULL );
vlc_cond_destroy( &p_sys->p_thread->wait );
vlc_mutex_destroy( &p_sys->p_thread->lock );
block_FifoRelease( p_sys->p_thread->p_fifo_input );
block_FifoRelease( p_sys->p_thread->p_empty_blocks );
for( i = 0; i < 64; i++ ) /* RTMP_HEADER_STREAM_INDEX_MASK */
{
if( p_sys->p_thread->rtmp_headers_recv[i].body != NULL )
{
free( p_sys->p_thread->rtmp_headers_recv[i].body->body );
free( p_sys->p_thread->rtmp_headers_recv[i].body );
}
}
net_Close( p_sys->p_thread->fd );
vlc_object_release( p_sys->p_thread );
vlc_UrlClean( &p_sys->p_thread->url );
free( p_sys->p_thread->psz_application );
free( p_sys->p_thread->psz_media );
free( p_sys );
}
static int Open (vlc_object_t *obj)
{
access_t *access = (access_t *)obj;
vlc_url_t url;
vlc_UrlParse (&url, access->psz_location, 0);
int fd = net_ConnectTCP (obj, url.psz_host,
url.i_port ? url.i_port : IPPORT_HTCPCP);
if (fd == -1)
{
vlc_UrlClean (&url);
return VLC_EGENERIC;
}
access_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
goto error;
sys->fd = fd;
net_Printf (obj, fd, NULL, "BREW %s HTTP/1.1\r\n",
url.psz_path ? url.psz_path : "/");
if (url.i_port)
net_Printf (obj, fd, NULL, "Host: %s:%u\r\n",
url.psz_host, url.i_port);
else
net_Printf (obj, fd, NULL, "Host: %s\r\n", url.psz_host);
net_Printf (obj, fd, NULL,
"User-Agent: "PACKAGE_NAME"/"PACKAGE_VERSION"\r\n"
"Accept-Additions: \r\n"
"Content-Type: application/coffee-pot-command\r\n"
"Content-Length: 0\r\n"
"\r\n");
vlc_UrlClean (&url);
access->p_sys = sys;
access->pf_read = Read;
access->pf_seek = Seek;
access->pf_control = Control;
return VLC_SUCCESS;
error:
net_Close (fd);
free (sys);
vlc_UrlClean (&url);
return VLC_EGENERIC;
}
static void Close(vlc_object_t *obj)
{
stream_t *access = (stream_t *)obj;
access_sys_t *sys = access->p_sys;
vlc_UrlClean(&sys->url);
close(sys->i_smb);
}
static void
nfs_mount_cb(int i_status, struct nfs_context *p_nfs, void *p_data,
void *p_private_data)
{
VLC_UNUSED(p_nfs);
access_t *p_access = p_private_data;
access_sys_t *p_sys = p_access->p_sys;
assert(p_sys->p_nfs == p_nfs);
(void) p_data;
/* If a directory url doesn't end with '/', there is no way to know which
* part of the url is the export point and which part is the path. An
* example with "nfs://myhost/mnt/data": we can't know if /mnt or /mnt/data
* is the export point. Therefore, in case of EACCES error, retry to mount
* the url by adding a '/' to the decoded path. */
if (i_status == -EACCES && p_sys->psz_url_decoded_slash == NULL)
{
vlc_url_t url;
vlc_UrlParse(&url, p_sys->psz_url_decoded);
if (url.psz_path == NULL || url.psz_path[0] == '\0'
|| url.psz_path[strlen(url.psz_path) - 1] == '/'
|| (p_sys->psz_url_decoded_slash = NfsGetUrl(&url, "/")) == NULL)
{
vlc_UrlClean(&url);
NFS_CHECK_STATUS(p_access, i_status, p_data);
return;
}
else
{
vlc_UrlClean(&url);
msg_Warn(p_access, "trying to mount '%s' again by adding a '/'",
p_access->psz_url);
return;
}
}
if (NFS_CHECK_STATUS(p_access, i_status, p_data))
return;
if (nfs_stat64_async(p_sys->p_nfs, p_sys->p_nfs_url->file, nfs_stat64_cb,
p_access) < 0)
{
msg_Err(p_access, "nfs_stat64_async failed");
p_sys->b_error = true;
}
}
input_item_t* MediaServer::newItem(const char *objectID, const char *title )
{
vlc_url_t url;
vlc_UrlParse( &url, url_.c_str(), '?' );
char* psz_url;
if (asprintf( &psz_url, "upnp://%s://%s:%u%s?ObjectID=%s", url.psz_protocol,
url.psz_host, url.i_port ? url.i_port : 80, url.psz_path, objectID ) < 0 )
{
vlc_UrlClean( &url );
return NULL;
}
vlc_UrlClean( &url );
input_item_t* p_item = input_item_NewWithTypeExt( psz_url, title, 0, NULL,
0, -1, ITEM_TYPE_DIRECTORY, 1 );
free( psz_url);
return p_item;
}
std::string MediaServerList::getIconURL( IXML_Element* p_device_elem, const char* psz_base_url )
{
std::string res;
IXML_NodeList* p_icon_lists = ixmlElement_getElementsByTagName( p_device_elem, "iconList" );
if ( p_icon_lists == NULL )
return res;
IXML_Element* p_icon_list = (IXML_Element*)ixmlNodeList_item( p_icon_lists, 0 );
if ( p_icon_list != NULL )
{
IXML_NodeList* p_icons = ixmlElement_getElementsByTagName( p_icon_list, "icon" );
if ( p_icons != NULL )
{
unsigned int maxWidth = 0;
unsigned int maxHeight = 0;
for ( unsigned int i = 0; i < ixmlNodeList_length( p_icons ); ++i )
{
IXML_Element* p_icon = (IXML_Element*)ixmlNodeList_item( p_icons, i );
const char* widthStr = xml_getChildElementValue( p_icon, "width" );
const char* heightStr = xml_getChildElementValue( p_icon, "height" );
if ( widthStr == NULL || heightStr == NULL )
continue;
unsigned int width = atoi( widthStr );
unsigned int height = atoi( heightStr );
if ( width <= maxWidth || height <= maxHeight )
continue;
const char* iconUrl = xml_getChildElementValue( p_icon, "url" );
if ( iconUrl == NULL )
continue;
maxWidth = width;
maxHeight = height;
res = iconUrl;
}
ixmlNodeList_free( p_icons );
}
}
ixmlNodeList_free( p_icon_lists );
if ( res.empty() == false )
{
vlc_url_t url;
vlc_UrlParse( &url, psz_base_url );
char* psz_url;
if ( asprintf( &psz_url, "%s://%s:%u%s", url.psz_protocol, url.psz_host, url.i_port, res.c_str() ) < 0 )
res.clear();
else
{
res = psz_url;
free( psz_url );
}
vlc_UrlClean( &url );
}
return res;
}
void input_item_SetURI( input_item_t *p_i, const char *psz_uri )
{
vlc_mutex_lock( &p_i->lock );
free( p_i->psz_uri );
p_i->psz_uri = strdup( psz_uri );
GuessType( p_i );
if( !p_i->psz_name && p_i->i_type == ITEM_TYPE_FILE )
{
const char *psz_filename = strrchr( p_i->psz_uri, DIR_SEP_CHAR );
if( psz_filename && *psz_filename == DIR_SEP_CHAR )
psz_filename++;
if( psz_filename && *psz_filename )
p_i->psz_name = strdup( psz_filename );
}
/* The name is NULL: fill it with everything except login and password */
if( !p_i->psz_name )
{
int r;
vlc_url_t url;
vlc_UrlParse( &url, psz_uri, 0 );
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 );
}
/*****************************************************************************
* Close:
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
stream_t *p_access = (stream_t*)p_this;
access_sys_t *p_sys = p_access->p_sys;
vlc_UrlClean( &p_sys->url );
if( p_sys->b_proxy )
vlc_UrlClean( &p_sys->proxy );
free( p_sys->psz_mime );
free( p_sys->psz_location );
free( p_sys->psz_icy_name );
free( p_sys->psz_icy_genre );
free( p_sys->psz_icy_title );
free( p_sys->psz_user_agent );
free( p_sys->psz_referrer );
free( p_sys->psz_username );
free( p_sys->psz_password );
Disconnect( p_access );
}
/*****************************************************************************
* Close: free unused data structures
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
stream_t *p_access = (stream_t*)p_this;
access_sys_t *p_sys = p_access->p_sys;
vlc_UrlClean( &p_sys->url );
#ifndef _WIN32
if( p_access->pf_readdir )
smbc_closedir( p_sys->i_smb );
else
#endif
smbc_close( p_sys->i_smb );
}
/*****************************************************************************
* Close: free unused data structures
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
stream_t *p_access = (stream_t*)p_this;
access_sys_t *p_sys = p_access->p_sys;
if( p_sys->p_ns )
netbios_ns_destroy( p_sys->p_ns );
if( p_sys->i_fd )
smb_fclose( p_sys->p_session, p_sys->i_fd );
if( p_sys->p_session )
smb_session_destroy( p_sys->p_session );
vlc_UrlClean( &p_sys->url );
free( p_sys->psz_fullpath );
free( p_sys );
}
/*
* Fetches and parses the UPNP response
*/
void MediaServer::fetchContents()
{
const char* objectID = "";
vlc_url_t url;
vlc_UrlParse( &url, access_->psz_location, '?');
if ( url.psz_option && !strncmp( url.psz_option, "ObjectID=", strlen( "ObjectID=" ) ) )
{
objectID = &url.psz_option[strlen( "ObjectID=" )];
}
IXML_Document* p_response = _browseAction( objectID,
"BrowseDirectChildren",
"id,dc:title,res," /* Filter */
"sec:CaptionInfo,sec:CaptionInfoEx,"
"pv:subtitlefile",
"0", /* RequestedCount */
"" /* SortCriteria */
);
vlc_UrlClean( &url );
if ( !p_response )
{
msg_Err( access_, "No response from browse() action" );
return;
}
xmlDocument_ = parseBrowseResult( p_response );
ixmlDocument_free( p_response );
if ( !xmlDocument_ )
{
msg_Err( access_, "browse() response parsing failed" );
return;
}
#ifndef NDEBUG
msg_Dbg( access_, "Got DIDL document: %s", ixmlPrintDocument( xmlDocument_ ) );
#endif
containerNodeList_ = ixmlDocument_getElementsByTagName( xmlDocument_, "container" );
itemNodeList_ = ixmlDocument_getElementsByTagName( xmlDocument_, "item" );
}
static void test_url_parse(const char* in, const char* protocol, const char* user,
const char* pass, const char* host, unsigned i_port,
const char* path, const char* option )
{
#define CHECK( a, b ) assert(((a == NULL) && (b == NULL)) || !strcmp((a), (b)))
vlc_url_t url;
vlc_UrlParse( &url, in, '?' );
CHECK( url.psz_protocol, protocol );
CHECK( url.psz_username, user );
CHECK( url.psz_password, pass );
CHECK( url.psz_host, host );
CHECK( url.psz_path, path );
assert( url.i_port == i_port );
CHECK( url.psz_option, option );
vlc_UrlClean( &url );
#undef CHECK
}
/*****************************************************************************
* Close: free unused data structures
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
access_sys_t *p_sys = p_access->p_sys;
if( p_sys->p_ns )
netbios_ns_destroy( p_sys->p_ns );
if( p_sys->i_fd )
smb_fclose( p_sys->p_session, p_sys->i_fd );
if( p_sys->p_session )
smb_session_destroy( p_sys->p_session );
vlc_UrlClean( &p_sys->url );
if( p_sys->shares )
smb_share_list_destroy( p_sys->shares );
if( p_sys->files )
smb_stat_list_destroy( p_sys->files );
free( p_sys->psz_user_opt );
free( p_sys->psz_pwd_opt );
free( p_sys->psz_domain_opt );
free( p_sys->psz_share );
free( p_sys->psz_path );
free( p_sys );
}
/*****************************************************************************
* Handshake : Init audioscrobbler connection
*****************************************************************************/
static int Handshake(intf_thread_t *p_this)
{
char *psz_username, *psz_password;
char *psz_scrobbler_url;
time_t timestamp;
char psz_timestamp[21];
struct md5_s p_struct_md5;
stream_t *p_stream;
char *psz_handshake_url;
uint8_t p_buffer[1024];
char *p_buffer_pos;
int i_ret;
char *psz_url;
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_this->p_sys;
psz_username = var_InheritString(p_this, "lastfm-username");
psz_password = var_InheritString(p_this, "lastfm-password");
/* username or password have not been setup */
if (EMPTY_STR(psz_username) || EMPTY_STR(psz_password))
{
free(psz_username);
free(psz_password);
return VLC_ENOVAR;
}
time(×tamp);
/* generates a md5 hash of the password */
InitMD5(&p_struct_md5);
AddMD5(&p_struct_md5, (uint8_t*) psz_password, strlen(psz_password));
EndMD5(&p_struct_md5);
free(psz_password);
char *psz_password_md5 = psz_md5_hash(&p_struct_md5);
if (!psz_password_md5)
{
free(psz_username);
return VLC_ENOMEM;
}
snprintf(psz_timestamp, sizeof(psz_timestamp), "%"PRIu64,
(uint64_t)timestamp);
/* generates a md5 hash of :
* - md5 hash of the password, plus
* - timestamp in clear text
*/
InitMD5(&p_struct_md5);
AddMD5(&p_struct_md5, (uint8_t*) psz_password_md5, 32);
AddMD5(&p_struct_md5, (uint8_t*) psz_timestamp, strlen(psz_timestamp));
EndMD5(&p_struct_md5);
free(psz_password_md5);
char *psz_auth_token = psz_md5_hash(&p_struct_md5);
if (!psz_auth_token)
{
free(psz_username);
return VLC_ENOMEM;
}
psz_scrobbler_url = var_InheritString(p_this, "scrobbler-url");
if (!psz_scrobbler_url)
{
free(psz_auth_token);
free(psz_username);
return VLC_ENOMEM;
}
i_ret = asprintf(&psz_handshake_url,
"http://%s/?hs=true&p=1.2&c="CLIENT_NAME"&v="CLIENT_VERSION"&u=%s&t=%s&a=%s"
, psz_scrobbler_url, psz_username, psz_timestamp, psz_auth_token);
free(psz_auth_token);
free(psz_scrobbler_url);
free(psz_username);
if (i_ret == -1)
return VLC_ENOMEM;
/* send the http handshake request */
p_stream = stream_UrlNew(p_intf, psz_handshake_url);
free(psz_handshake_url);
if (!p_stream)
return VLC_EGENERIC;
/* read answer */
i_ret = stream_Read(p_stream, p_buffer, sizeof(p_buffer) - 1);
if (i_ret <= 0)
{
stream_Delete(p_stream);
return VLC_EGENERIC;
}
p_buffer[i_ret] = '\0';
stream_Delete(p_stream);
p_buffer_pos = strstr((char*) p_buffer, "FAILED ");
if (p_buffer_pos)
{
/* handshake request failed, sorry */
msg_Err(p_this, "last.fm handshake failed: %s", p_buffer_pos + 7);
return VLC_EGENERIC;
}
if (strstr((char*) p_buffer, "BADAUTH"))
{
/* authentication failed, bad username/password combination */
vlc_dialog_display_error(p_this,
_("last.fm: Authentication failed"),
"%s", _("last.fm username or password is incorrect. "
"Please verify your settings and relaunch VLC."));
return VLC_AUDIOSCROBBLER_EFATAL;
}
if (strstr((char*) p_buffer, "BANNED"))
{
/* oops, our version of vlc has been banned by last.fm servers */
msg_Err(p_intf, "This version of VLC has been banned by last.fm. "
"You should upgrade VLC, or disable the last.fm plugin.");
return VLC_AUDIOSCROBBLER_EFATAL;
}
if (strstr((char*) p_buffer, "BADTIME"))
{
/* The system clock isn't good */
msg_Err(p_intf, "last.fm handshake failed because your clock is too "
"much shifted. Please correct it, and relaunch VLC.");
return VLC_AUDIOSCROBBLER_EFATAL;
}
p_buffer_pos = strstr((char*) p_buffer, "OK");
if (!p_buffer_pos)
goto proto;
p_buffer_pos = strstr(p_buffer_pos, "\n");
if (!p_buffer_pos || strlen(p_buffer_pos) < 33)
goto proto;
p_buffer_pos++; /* we skip the '\n' */
/* save the session ID */
memcpy(p_sys->psz_auth_token, p_buffer_pos, 32);
p_sys->psz_auth_token[32] = '\0';
p_buffer_pos = strstr(p_buffer_pos, "http://");
if (!p_buffer_pos || strlen(p_buffer_pos) == 7)
goto proto;
/* We need to read the nowplaying url */
p_buffer_pos += 7; /* we skip "http://" */
psz_url = strndup(p_buffer_pos, strcspn(p_buffer_pos, "\n"));
if (!psz_url)
goto oom;
vlc_UrlParse(&p_sys->p_nowp_url, psz_url);
free(psz_url);
if (p_sys->p_nowp_url.psz_host == NULL ||
p_sys->p_nowp_url.i_port == 0)
{
vlc_UrlClean(&p_sys->p_nowp_url);
goto proto;
}
p_buffer_pos = strstr(p_buffer_pos, "http://");
if (!p_buffer_pos || strlen(p_buffer_pos) == 7)
goto proto;
/* We need to read the submission url */
p_buffer_pos += 7; /* we skip "http://" */
psz_url = strndup(p_buffer_pos, strcspn(p_buffer_pos, "\n"));
if (!psz_url)
goto oom;
/* parse the submission url */
vlc_UrlParse(&p_sys->p_submit_url, psz_url);
free(psz_url);
if (p_sys->p_submit_url.psz_host == NULL ||
p_sys->p_submit_url.i_port == 0)
{
vlc_UrlClean(&p_sys->p_nowp_url);
vlc_UrlClean(&p_sys->p_submit_url);
goto proto;
}
return VLC_SUCCESS;
oom:
return VLC_ENOMEM;
proto:
msg_Err(p_intf, "Handshake: can't recognize server protocol");
return VLC_EGENERIC;
}
/*****************************************************************************
* Open: open the shout connection
*****************************************************************************/
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;
shout_t *p_shout;
long i_ret;
char *psz_val;
char *psz_name;
char *psz_description;
char *psz_genre;
char *psz_url;
vlc_url_t url;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access,
"please specify url=user:password@host:port/mountpoint" );
return VLC_EGENERIC;
}
vlc_UrlParse( &url , p_access->psz_path, 0 );
if( url.i_port <= 0 )
url.i_port = 8000;
p_sys = p_access->p_sys = malloc( sizeof( sout_access_out_sys_t ) );
if( !p_sys )
{
vlc_UrlClean( &url );
return VLC_ENOMEM;
}
psz_name = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "name" );
psz_description = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "description" );
psz_genre = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "genre" );
psz_url = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "url" );
p_shout = p_sys->p_shout = shout_new();
if( !p_shout
|| shout_set_host( p_shout, url.psz_host ) != SHOUTERR_SUCCESS
|| shout_set_protocol( p_shout, SHOUT_PROTOCOL_ICY ) != SHOUTERR_SUCCESS
|| shout_set_port( p_shout, url.i_port ) != SHOUTERR_SUCCESS
|| shout_set_password( p_shout, url.psz_password ) != SHOUTERR_SUCCESS
|| shout_set_mount( p_shout, url.psz_path ) != SHOUTERR_SUCCESS
|| shout_set_user( p_shout, url.psz_username ) != SHOUTERR_SUCCESS
|| shout_set_agent( p_shout, "VLC media player " VERSION ) != SHOUTERR_SUCCESS
|| shout_set_name( p_shout, psz_name ) != SHOUTERR_SUCCESS
|| shout_set_description( p_shout, psz_description ) != SHOUTERR_SUCCESS
|| shout_set_genre( p_shout, psz_genre ) != SHOUTERR_SUCCESS
|| shout_set_url( p_shout, psz_url ) != SHOUTERR_SUCCESS
/* || shout_set_nonblocking( p_shout, 1 ) != SHOUTERR_SUCCESS */
)
{
msg_Err( p_access, "failed to initialize shout streaming to %s:%i/%s",
url.psz_host, url.i_port, url.psz_path );
free( psz_name );
free( psz_description );
free( psz_genre );
free( psz_url );
goto error;
}
free( psz_name );
free( psz_description );
free( psz_genre );
free( psz_url );
i_ret = shout_set_format( p_shout, var_GetBool( p_access, SOUT_CFG_PREFIX "mp3" ) ?
SHOUT_FORMAT_MP3 : SHOUT_FORMAT_OGG );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the shoutcast streaming format" );
goto error;
}
/* Don't force bitrate to 0 but only use when specified. This will otherwise
show an empty field on icecast directory listing instead of NA */
psz_val = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "bitrate" );
if( psz_val )
{
i_ret = shout_set_audio_info( p_shout, SHOUT_AI_BITRATE, psz_val );
free( psz_val );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the information about the bitrate" );
goto error;
}
}
else
{
/* Bitrate information is used for icecast/shoutcast servers directory
listings (sorting, stream info etc.) */
msg_Warn( p_access, "no bitrate information specified (required for listing " \
"the server as public on the shoutcast website)" );
}
/* Information about samplerate, channels and quality will not be propagated
through the YP protocol for icecast to the public directory listing when
the icecast server is operating in shoutcast compatibility mode */
psz_val = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "samplerate" );
if( psz_val )
{
i_ret = shout_set_audio_info( p_shout, SHOUT_AI_SAMPLERATE, psz_val );
free( psz_val );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the information about the samplerate" );
goto error;
}
}
psz_val = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "channels" );
if( psz_val )
{
i_ret = shout_set_audio_info( p_shout, SHOUT_AI_CHANNELS, psz_val );
free( psz_val );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the information about the number of channels" );
goto error;
}
}
psz_val = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "quality" );
if( psz_val )
{
i_ret = shout_set_audio_info( p_shout, SHOUT_AI_QUALITY, psz_val );
free( psz_val );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the information about Ogg Vorbis quality" );
goto error;
}
}
if( var_GetBool( p_access, SOUT_CFG_PREFIX "public" ) )
{
i_ret = shout_set_public( p_shout, 1 );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the server status setting to public" );
goto error;
}
}
/* Connect at startup. Cycle through the possible protocols. */
i_ret = shout_get_connected( p_shout );
while ( i_ret != SHOUTERR_CONNECTED )
{
/* Shout parameters cannot be changed on an open connection */
i_ret = shout_close( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_UNCONNECTED;
}
/* Re-initialize for Shoutcast using ICY protocol. Not needed for initial connection
but it is when we are reconnecting after other protocol was tried. */
i_ret = shout_set_protocol( p_shout, SHOUT_PROTOCOL_ICY );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the protocol to 'icy'" );
goto error;
}
i_ret = shout_open( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_CONNECTED;
msg_Dbg( p_access, "connected using 'icy' (shoutcast) protocol" );
}
else
{
msg_Warn( p_access, "failed to connect using 'icy' (shoutcast) protocol" );
/* Shout parameters cannot be changed on an open connection */
i_ret = shout_close( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_UNCONNECTED;
}
/* IceCAST using HTTP protocol */
i_ret = shout_set_protocol( p_shout, SHOUT_PROTOCOL_HTTP );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the protocol to 'http'" );
goto error;
}
i_ret = shout_open( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_CONNECTED;
msg_Dbg( p_access, "connected using 'http' (icecast 2.x) protocol" );
}
else
msg_Warn( p_access, "failed to connect using 'http' (icecast 2.x) protocol " );
}
/*
for non-blocking, use:
while( i_ret == SHOUTERR_BUSY )
{
sleep( 1 );
i_ret = shout_get_connected( p_shout );
}
*/
if ( i_ret != SHOUTERR_CONNECTED )
{
msg_Warn( p_access, "unable to establish connection, retrying..." );
msleep( 30000000 );
}
}
if( i_ret != SHOUTERR_CONNECTED )
{
msg_Err( p_access, "failed to open shout stream to %s:%i/%s: %s",
url.psz_host, url.i_port, url.psz_path, shout_get_error(p_shout) );
goto error;
}
p_access->pf_write = Write;
p_access->pf_seek = Seek;
p_access->pf_control = Control;
msg_Dbg( p_access, "shout access output opened (%s@%s:%i/%s)",
url.psz_username, url.psz_host, url.i_port, url.psz_path );
vlc_UrlClean( &url );
return VLC_SUCCESS;
error:
if( p_sys->p_shout )
shout_free( p_sys->p_shout );
vlc_UrlClean( &url );
free( p_sys );
return VLC_EGENERIC;
}
/*****************************************************************************
* Activate: initialize and create stuff
*****************************************************************************/
static int Activate( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*)p_this;
char *psz_host, *psz_unix_path;
int i_socket = -1;
#if defined(HAVE_ISATTY) && !defined(WIN32)
/* Check that stdin is a TTY */
if( !config_GetInt( p_intf, "rtci-fake-tty" ) && !isatty( 0 ) )
{
msg_Warn( p_intf, "fd 0 is not a TTY" );
return VLC_EGENERIC;
}
#endif
psz_unix_path = config_GetPsz( p_intf, "rtci-unix" );
if( psz_unix_path )
{
#ifndef PF_LOCAL
msg_Warn( p_intf, "your OS doesn't support filesystem sockets" );
free( psz_unix_path );
return VLC_EGENERIC;
#else
struct sockaddr_un addr;
int i_ret;
memset( &addr, 0, sizeof(struct sockaddr_un) );
msg_Dbg( p_intf, "trying UNIX socket" );
if( (i_socket = socket( PF_LOCAL, SOCK_STREAM, 0 ) ) < 0 )
{
msg_Warn( p_intf, "can't open socket: %s", strerror(errno) );
free( psz_unix_path );
return VLC_EGENERIC;
}
addr.sun_family = AF_LOCAL;
strncpy( addr.sun_path, psz_unix_path, sizeof( addr.sun_path ) );
addr.sun_path[sizeof( addr.sun_path ) - 1] = '\0';
if( (i_ret = bind( i_socket, (struct sockaddr*)&addr,
sizeof(struct sockaddr_un) ) ) < 0 )
{
msg_Warn( p_intf, "couldn't bind socket to address: %s",
strerror(errno) );
free( psz_unix_path );
net_Close( i_socket );
return VLC_EGENERIC;
}
if( ( i_ret = listen( i_socket, 1 ) ) < 0 )
{
msg_Warn( p_intf, "can't listen on socket: %s", strerror(errno));
free( psz_unix_path );
net_Close( i_socket );
return VLC_EGENERIC;
}
#endif
}
if( ( i_socket == -1) &&
( psz_host = config_GetPsz( p_intf, "rtci-host" ) ) != NULL )
{
vlc_url_t url;
vlc_UrlParse( &url, psz_host, 0 );
msg_Dbg( p_intf, "base %s port %d", url.psz_host, url.i_port );
if( (i_socket = net_ListenTCP(p_this, url.psz_host, url.i_port)) == -1)
{
msg_Warn( p_intf, "can't listen to %s port %i",
url.psz_host, url.i_port );
vlc_UrlClean( &url );
free( psz_host );
return VLC_EGENERIC;
}
vlc_UrlClean( &url );
free( psz_host );
}
p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
if( !p_intf->p_sys )
{
msg_Err( p_intf, "no memory" );
return VLC_ENOMEM;
}
p_intf->p_sys->i_socket_listen = i_socket;
p_intf->p_sys->i_socket = -1;
p_intf->p_sys->psz_unix_path = psz_unix_path;
/* Non-buffered stdout */
setvbuf( stdout, (char *)NULL, _IOLBF, 0 );
p_intf->pf_run = Run;
#ifdef WIN32
if( !config_GetInt( p_intf, "rtci-quiet" ) ) { CONSOLE_INTRO_MSG; }
#else
CONSOLE_INTRO_MSG;
#endif
msg_rtci( _("Real time control interface initialized, `h' for help\n") );
return VLC_SUCCESS;
}
/* Performs login with existing credentials and ask the user for new ones on
failure */
static int login( access_t *p_access )
{
int i_ret = VLC_EGENERIC;
access_sys_t *p_sys = p_access->p_sys;
vlc_url_t url;
vlc_credential credential;
char *psz_var_domain;
const char *psz_login, *psz_password, *psz_domain;
bool b_guest = false;
vlc_UrlParse( &url, p_access->psz_url );
vlc_credential_init( &credential, &url );
psz_var_domain = var_InheritString( p_access, "smb-domain" );
credential.psz_realm = psz_var_domain ? psz_var_domain : p_sys->netbios_name;
vlc_credential_get( &credential, p_access, "smb-user", "smb-pwd",
NULL, NULL );
if( !credential.psz_username )
{
psz_login = "******";
psz_password = "******";
b_guest = true;
}
else
{
psz_login = credential.psz_username;
psz_password = credential.psz_password;
}
psz_domain = credential.psz_realm;
/* Try to authenticate on the remote machine */
if( smb_connect( p_access, psz_login, psz_password, psz_domain )
!= VLC_SUCCESS )
{
while( vlc_credential_get( &credential, p_access, "smb-user", "smb-pwd",
SMB_LOGIN_DIALOG_TITLE,
SMB_LOGIN_DIALOG_TEXT, p_sys->netbios_name ) )
{
b_guest = false;
psz_login = credential.psz_username;
psz_password = credential.psz_password;
psz_domain = credential.psz_realm;
if( smb_connect( p_access, psz_login, psz_password, psz_domain )
== VLC_SUCCESS )
goto success;
}
msg_Err( p_access, "Unable to login with username = '******', domain = '%s'",
psz_login, psz_domain );
goto error;
}
else if( smb_session_is_guest( p_sys->p_session ) )
{
msg_Warn( p_access, "Login failure but you were logged in as a Guest");
b_guest = true;
}
success:
msg_Warn( p_access, "Creds: username = '******', domain = '%s'",
psz_login, psz_domain );
if( p_sys->psz_share != NULL && !b_guest )
{
if( asprintf( &p_sys->psz_user_opt, "smb-user=%s", psz_login ) == -1 )
p_sys->psz_user_opt = NULL;
if( asprintf( &p_sys->psz_domain_opt, "smb-domain=%s", psz_domain ) == -1 )
p_sys->psz_domain_opt = NULL;
if( !vlc_credential_store( &credential )
&& asprintf( &p_sys->psz_pwd_opt, "smb-pwd=%s", psz_password ) == -1 )
p_sys->psz_pwd_opt = NULL;
}
i_ret = VLC_SUCCESS;
error:
vlc_credential_clean( &credential );
vlc_UrlClean( &url );
free( psz_var_domain );
return i_ret;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
if (p_demux->out == NULL)
return VLC_EGENERIC;
p_sys = vlc_obj_calloc( p_this, 1, sizeof(demux_sys_t) );
if( !p_sys ) return VLC_ENOMEM;
p_sys->f_fps = var_InheritFloat( p_demux, CFG_PREFIX "fps" );
if ( p_sys->f_fps <= 0 ) p_sys->f_fps = 1.0;
p_sys->i_frame_interval = CLOCK_FREQ / p_sys->f_fps;
#if FREERDP_VERSION_MAJOR == 1 && FREERDP_VERSION_MINOR < 2
freerdp_channels_global_init();
#endif
p_sys->p_instance = freerdp_new();
if ( !p_sys->p_instance )
{
msg_Err( p_demux, "rdp instantiation error" );
return VLC_EGENERIC;
}
p_demux->p_sys = p_sys;
p_sys->p_instance->PreConnect = preConnectHandler;
p_sys->p_instance->PostConnect = postConnectHandler;
p_sys->p_instance->Authenticate = authenticateHandler;
/* Set up context handlers and let it be allocated */
p_sys->p_instance->ContextSize = sizeof( vlcrdp_context_t );
freerdp_context_new( p_sys->p_instance );
vlcrdp_context_t * p_vlccontext = (vlcrdp_context_t *) p_sys->p_instance->context;
p_vlccontext->p_demux = p_demux;
/* Parse uri params for pre-connect */
vlc_url_t url;
vlc_UrlParse( &url, p_demux->psz_location );
if ( !EMPTY_STR(url.psz_host) )
p_sys->psz_hostname = strdup( url.psz_host );
else
p_sys->psz_hostname = strdup( "localhost" );
p_sys->i_port = ( url.i_port > 0 ) ? url.i_port : 3389;
vlc_UrlClean( &url );
if ( ! freerdp_connect( p_sys->p_instance ) )
{
msg_Err( p_demux, "can't connect to rdp server" );
goto error;
}
if ( vlc_clone( &p_sys->thread, DemuxThread, p_demux, VLC_THREAD_PRIORITY_INPUT ) != VLC_SUCCESS )
{
msg_Err( p_demux, "can't spawn thread" );
freerdp_disconnect( p_sys->p_instance );
goto error;
}
p_demux->pf_demux = NULL;
p_demux->pf_control = Control;
return VLC_SUCCESS;
error:
freerdp_free( p_sys->p_instance );
free( p_sys->psz_hostname );
return VLC_EGENERIC;
}
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 );
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 )
{
decode_URI( 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, 0 );
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 );
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
if (p_demux->out == NULL)
return VLC_EGENERIC;
p_sys = vlc_obj_calloc( p_this, 1, sizeof(demux_sys_t) );
if( !p_sys ) return VLC_ENOMEM;
p_sys->f_fps = var_InheritFloat( p_demux, CFG_PREFIX "fps" );
if ( p_sys->f_fps <= 0 ) p_sys->f_fps = 1.0;
p_sys->i_frame_interval = vlc_tick_rate_duration( p_sys->f_fps );
char *psz_chroma = var_InheritString( p_demux, CFG_PREFIX "chroma" );
vlc_fourcc_t i_chroma = vlc_fourcc_GetCodecFromString( VIDEO_ES, psz_chroma );
free( psz_chroma );
if ( !i_chroma || vlc_fourcc_IsYUV( i_chroma ) )
{
msg_Err( p_demux, "Only RGB chroma are supported" );
return VLC_EGENERIC;
}
const vlc_chroma_description_t *p_chroma_desc = vlc_fourcc_GetChromaDescription( i_chroma );
if ( !p_chroma_desc )
{
msg_Err( p_demux, "Unable to get RGB chroma description" );
return VLC_EGENERIC;
}
#ifdef NDEBUG
rfbEnableClientLogging = FALSE;
#endif
p_sys->p_client = rfbGetClient( p_chroma_desc->pixel_bits / 3, // bitsPerSample
3, // samplesPerPixel
p_chroma_desc->pixel_size ); // bytesPerPixel
if ( ! p_sys->p_client )
{
msg_Dbg( p_demux, "Unable to set up client for %s",
vlc_fourcc_GetDescription( VIDEO_ES, i_chroma ) );
return VLC_EGENERIC;
}
msg_Dbg( p_demux, "set up client for %s %d %d %d",
vlc_fourcc_GetDescription( VIDEO_ES, i_chroma ),
p_chroma_desc->pixel_bits / 3, 3, p_chroma_desc->pixel_size );
p_sys->p_client->MallocFrameBuffer = mallocFrameBufferHandler;
p_sys->p_client->canHandleNewFBSize = TRUE;
p_sys->p_client->GetCredential = getCredentialHandler;
p_sys->p_client->GetPassword = getPasswordHandler; /* VNC simple auth */
/* Set compression and quality levels */
p_sys->p_client->appData.compressLevel =
var_InheritInteger( p_demux, CFG_PREFIX "compress-level" );
p_sys->p_client->appData.qualityLevel =
var_InheritInteger( p_demux, CFG_PREFIX "quality-level" );
/* Parse uri params */
vlc_url_t url;
vlc_UrlParse( &url, p_demux->psz_location );
if ( !EMPTY_STR(url.psz_host) )
p_sys->p_client->serverHost = strdup( url.psz_host );
else
p_sys->p_client->serverHost = strdup( "localhost" );
p_sys->p_client->appData.viewOnly = TRUE;
p_sys->p_client->serverPort = ( url.i_port > 0 ) ? url.i_port : 5900;
msg_Dbg( p_demux, "VNC init %s host=%s port=%d",
p_demux->psz_location,
p_sys->p_client->serverHost,
p_sys->p_client->serverPort );
vlc_UrlClean( &url );
/* make demux available for callback handlers */
rfbClientSetClientData( p_sys->p_client, DemuxThread, p_demux );
p_demux->p_sys = p_sys;
if( !rfbInitClient( p_sys->p_client, NULL, NULL ) )
{
msg_Err( p_demux, "can't connect to RFB server" );
return VLC_EGENERIC;
}
p_sys->i_starttime = vlc_tick_now();
if ( vlc_clone( &p_sys->thread, DemuxThread, p_demux, VLC_THREAD_PRIORITY_INPUT ) != VLC_SUCCESS )
{
msg_Err( p_demux, "can't spawn thread" );
return VLC_EGENERIC;
}
p_demux->pf_demux = NULL;
p_demux->pf_control = Control;
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: open the rtmp connection
*****************************************************************************/
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, *p;
int length_path, length_media_name;
int i;
if( !( p_sys = calloc ( 1, sizeof( sout_access_out_sys_t ) ) ) )
return VLC_ENOMEM;
p_access->p_sys = p_sys;
p_sys->p_thread =
vlc_object_create( p_access, sizeof( rtmp_control_thread_t ) );
if( !p_sys->p_thread )
{
free( p_sys );
return VLC_ENOMEM;
}
vlc_object_attach( p_sys->p_thread, p_access );
/* Parse URI - remove spaces */
p = psz = strdup( p_access->psz_path );
while( ( p = strchr( p, ' ' ) ) != NULL )
*p = '+';
vlc_UrlParse( &p_sys->p_thread->url, psz, 0 );
free( psz );
if( p_sys->p_thread->url.psz_host == NULL
|| *p_sys->p_thread->url.psz_host == '\0' )
{
msg_Warn( p_access, "invalid host" );
goto error;
}
if( p_sys->p_thread->url.i_port <= 0 )
p_sys->p_thread->url.i_port = 1935;
if ( p_sys->p_thread->url.psz_path == NULL )
{
msg_Warn( p_access, "invalid path" );
goto error;
}
length_path = strlen( p_sys->p_thread->url.psz_path );
char* psz_tmp = strrchr( p_sys->p_thread->url.psz_path, '/' );
if( !psz_tmp )
goto error;
length_media_name = strlen( psz_tmp ) - 1;
p_sys->p_thread->psz_application = strndup( p_sys->p_thread->url.psz_path + 1, length_path - length_media_name - 2 );
p_sys->p_thread->psz_media = strdup( p_sys->p_thread->url.psz_path + ( length_path - length_media_name ) );
msg_Dbg( p_access, "rtmp: host='%s' port=%d path='%s'",
p_sys->p_thread->url.psz_host, p_sys->p_thread->url.i_port, p_sys->p_thread->url.psz_path );
if( p_sys->p_thread->url.psz_username && *p_sys->p_thread->url.psz_username )
{
msg_Dbg( p_access, " user='******'", p_sys->p_thread->url.psz_username );
}
/* Initialize thread variables */
p_sys->p_thread->b_error= 0;
p_sys->p_thread->p_fifo_input = block_FifoNew();
p_sys->p_thread->p_empty_blocks = block_FifoNew();
p_sys->p_thread->has_audio = 0;
p_sys->p_thread->has_video = 0;
p_sys->p_thread->metadata_received = 0;
p_sys->p_thread->first_media_packet = 1;
p_sys->p_thread->flv_tag_previous_tag_size = 0x00000000; /* FLV_TAG_FIRST_PREVIOUS_TAG_SIZE */
p_sys->p_thread->flv_body = rtmp_body_new( -1 );
p_sys->p_thread->flv_length_body = 0;
p_sys->p_thread->chunk_size_recv = 128; /* RTMP_DEFAULT_CHUNK_SIZE */
p_sys->p_thread->chunk_size_send = 128; /* RTMP_DEFAULT_CHUNK_SIZE */
for(i = 0; i < 64; i++)
{
memset( &p_sys->p_thread->rtmp_headers_recv[i], 0, sizeof( rtmp_packet_t ) );
p_sys->p_thread->rtmp_headers_send[i].length_header = -1;
p_sys->p_thread->rtmp_headers_send[i].stream_index = -1;
p_sys->p_thread->rtmp_headers_send[i].timestamp = -1;
p_sys->p_thread->rtmp_headers_send[i].timestamp_relative = -1;
p_sys->p_thread->rtmp_headers_send[i].length_encoded = -1;
p_sys->p_thread->rtmp_headers_send[i].length_body = -1;
p_sys->p_thread->rtmp_headers_send[i].content_type = -1;
p_sys->p_thread->rtmp_headers_send[i].src_dst = -1;
p_sys->p_thread->rtmp_headers_send[i].body = NULL;
}
vlc_cond_init( &p_sys->p_thread->wait );
vlc_mutex_init( &p_sys->p_thread->lock );
p_sys->p_thread->result_connect = 1;
/* p_sys->p_thread->result_publish = only used on access */
p_sys->p_thread->result_play = 1;
p_sys->p_thread->result_stop = 0;
p_sys->p_thread->fd = -1;
/* Open connection */
if( var_CreateGetBool( p_access, "rtmp-connect" ) > 0 )
{
#if 0
p_sys->p_thread->fd = net_ConnectTCP( p_access,
p_sys->p_thread->url.psz_host,
p_sys->p_thread->url.i_port );
#endif
msg_Err( p_access, "to be implemented" );
goto error2;
}
else
{
int *p_fd_listen;
p_sys->active = 0;
p_fd_listen = net_ListenTCP( p_access, p_sys->p_thread->url.psz_host,
p_sys->p_thread->url.i_port );
if( p_fd_listen == NULL )
{
msg_Warn( p_access, "cannot listen to %s port %i",
p_sys->p_thread->url.psz_host,
p_sys->p_thread->url.i_port );
goto error2;
}
do
p_sys->p_thread->fd = net_Accept( p_access, p_fd_listen );
while( p_sys->p_thread->fd == -1 );
net_ListenClose( p_fd_listen );
if( rtmp_handshake_passive( p_this, p_sys->p_thread->fd ) < 0 )
{
msg_Err( p_access, "handshake passive failed");
goto error2;
}
}
if( vlc_clone( &p_sys->p_thread->thread, ThreadControl, p_sys->p_thread,
VLC_THREAD_PRIORITY_INPUT ) )
{
msg_Err( p_access, "cannot spawn rtmp control thread" );
goto error2;
}
if( !p_sys->active )
{
if( rtmp_connect_passive( p_sys->p_thread ) < 0 )
{
msg_Err( p_access, "connect passive failed");
vlc_cancel( p_sys->p_thread->thread );
vlc_join( p_sys->p_thread->thread, NULL );
goto error2;
}
}
p_access->pf_write = Write;
p_access->pf_seek = Seek;
return VLC_SUCCESS;
error2:
vlc_cond_destroy( &p_sys->p_thread->wait );
vlc_mutex_destroy( &p_sys->p_thread->lock );
free( p_sys->p_thread->psz_application );
free( p_sys->p_thread->psz_media );
if( p_sys->p_thread->fd != -1 )
net_Close( p_sys->p_thread->fd );
error:
vlc_UrlClean( &p_sys->p_thread->url );
vlc_object_release( p_sys->p_thread );
free( p_sys );
return VLC_EGENERIC;
}
static char *MakeConfig( intf_thread_t *p_intf, const char *name )
{
char *psz_config = NULL;
if( !strcmp( name, "http" ) )
{
char *psz_http_src = var_InheritString( p_intf, "http-src" );
bool b_http_index = var_InheritBool( p_intf, "http-index" );
if( psz_http_src )
{
char *psz_esc = config_StringEscape( psz_http_src );
if( asprintf( &psz_config, "http={dir='%s',no_index=%s}", psz_esc,
b_http_index ? "true" : "false" ) == -1 )
psz_config = NULL;
free( psz_esc );
free( psz_http_src );
}
else
{
if( asprintf( &psz_config, "http={no_index=%s}",
b_http_index ? "true" : "false" ) == -1 )
psz_config = NULL;
}
}
else if( !strcmp( name, "telnet" ) )
{
char *psz_host = var_InheritString( p_intf, "telnet-host" );
if( !strcmp( psz_host, "*console" ) )
;
else
{
vlc_url_t url;
vlc_UrlParse( &url, psz_host, 0 );
unsigned i_port = var_InheritInteger( p_intf, "telnet-port" );
if ( url.i_port != 0 )
{
if ( i_port == TELNETPORT_DEFAULT )
i_port = url.i_port;
else if ( url.i_port != i_port )
msg_Warn( p_intf, "ignoring port %d (using %d)",
url.i_port, i_port );
}
char *psz_esc_host = config_StringEscape( url.psz_host );
free( psz_host );
vlc_UrlClean( &url );
if( asprintf( &psz_host, "telnet://%s:%d",
psz_esc_host ? psz_esc_host : "", i_port ) == -1 )
psz_host = NULL;
free( psz_esc_host );
}
char *psz_passwd = var_InheritString( p_intf, "telnet-password" );
char *psz_esc_passwd = config_StringEscape( psz_passwd );
if( asprintf( &psz_config, "telnet={host='%s',password='******'}",
psz_host, psz_esc_passwd ) == -1 )
psz_config = NULL;
free( psz_esc_passwd );
free( psz_passwd );
free( psz_host );
}
else if( !strcmp( name, "cli" ) )
{
char *psz_rc_host = var_InheritString( p_intf, "rc-host" );
if( !psz_rc_host )
psz_rc_host = var_InheritString( p_intf, "cli-host" );
if( psz_rc_host )
{
char *psz_esc_host = config_StringEscape( psz_rc_host );
if( asprintf( &psz_config, "cli={host='%s'}", psz_esc_host ) == -1 )
psz_config = NULL;
free( psz_esc_host );
free( psz_rc_host );
}
}
return psz_config;
}
static int Start_LuaIntf( vlc_object_t *p_this, const char *name )
{
intf_thread_t *p_intf = (intf_thread_t*)p_this;
intf_sys_t *p_sys;
lua_State *L;
config_ChainParse( p_intf, "lua-", ppsz_intf_options, p_intf->p_cfg );
char *psz_config;
bool b_config_set = false;
if( name == NULL )
{
char *n = var_InheritString( p_this, "lua-intf" );
if( unlikely(n == NULL) )
return VLC_EGENERIC;
name = p_intf->psz_header = n;
}
else
/* Cleaned up by vlc_object_release() */
p_intf->psz_header = strdup( name );
p_intf->p_sys = (intf_sys_t*)malloc( sizeof(intf_sys_t) );
if( !p_intf->p_sys )
{
free( p_intf->psz_header );
p_intf->psz_header = NULL;
return VLC_ENOMEM;
}
p_sys = p_intf->p_sys;
p_sys->psz_filename = vlclua_find_file( p_this, "intf", name );
if( !p_sys->psz_filename )
{
msg_Err( p_intf, "Couldn't find lua interface script \"%s\".",
name );
goto error;
}
msg_Dbg( p_intf, "Found lua interface script: %s", p_sys->psz_filename );
L = luaL_newstate();
if( !L )
{
msg_Err( p_intf, "Could not create new Lua State" );
goto error;
}
vlclua_set_this( L, p_intf );
vlclua_set_intf( L, p_sys );
luaL_openlibs( L );
/* register our functions */
luaL_register( L, "vlc", p_reg );
/* register submodules */
luaopen_acl( L );
luaopen_config( L );
luaopen_volume( L );
luaopen_httpd( L );
luaopen_input( L );
luaopen_msg( L );
luaopen_misc( L );
luaopen_net( L );
luaopen_object( L );
luaopen_osd( L );
luaopen_playlist( L );
luaopen_sd( L );
luaopen_stream( L );
luaopen_strings( L );
luaopen_variables( L );
luaopen_video( L );
luaopen_vlm( L );
luaopen_volume( L );
luaopen_gettext( L );
luaopen_xml( L );
luaopen_equalizer( L );
/* clean up */
lua_pop( L, 1 );
/* Setup the module search path */
if( vlclua_add_modules_path( p_intf, L, p_sys->psz_filename ) )
{
msg_Warn( p_intf, "Error while setting the module search path for %s",
p_sys->psz_filename );
lua_close( L );
goto error;
}
/*
* Get the lua-config string.
* If the string is empty, try with the old http-* or telnet-* options
* and build the right configuration line
*/
psz_config = var_CreateGetNonEmptyString( p_intf, "lua-config" );
if( !psz_config )
{
if( !strcmp( name, "http" ) )
{
char *psz_http_src = var_CreateGetNonEmptyString( p_intf, "http-src" );
bool b_http_index = var_CreateGetBool( p_intf, "http-index" );
if( psz_http_src )
{
char *psz_esc = config_StringEscape( psz_http_src );
if( psz_config )
{
char *psz_tmp;
asprintf( &psz_tmp, "%s,dir='%s'", psz_config, psz_esc );
free( psz_config );
psz_config = psz_tmp;
}
else
asprintf( &psz_config, "http={dir='%s'", psz_esc );
free( psz_esc );
free( psz_http_src );
}
if( psz_config )
{
char *psz_tmp;
asprintf( &psz_tmp, "%s,no_index=%s}", psz_config, b_http_index ? "true" : "false" );
free( psz_config );
psz_config = psz_tmp;
}
else
asprintf( &psz_config, "http={no_index=%s}", b_http_index ? "true" : "false" );
}
else if( !strcmp( name, "telnet" ) )
{
char *psz_telnet_host = var_CreateGetString( p_intf, "telnet-host" );
if( !strcmp( psz_telnet_host, "*console" ) )
;
else
{
vlc_url_t url;
vlc_UrlParse( &url, psz_telnet_host, 0 );
int i_telnet_port = var_CreateGetInteger( p_intf, "telnet-port" );
if ( url.i_port != 0 )
{
if ( i_telnet_port == TELNETPORT_DEFAULT )
i_telnet_port = url.i_port;
else if ( url.i_port != i_telnet_port )
msg_Warn( p_intf, "ignoring port %d (using %d)", url.i_port, i_telnet_port );
}
char *psz_esc_host = config_StringEscape( url.psz_host );
free( psz_telnet_host );
vlc_UrlClean( &url );
asprintf( &psz_telnet_host, "telnet://%s:%d", psz_esc_host ? psz_esc_host : "", i_telnet_port );
free( psz_esc_host );
}
char *psz_telnet_passwd = var_CreateGetString( p_intf, "telnet-password" );
char *psz_esc_passwd = config_StringEscape( psz_telnet_passwd );
asprintf( &psz_config, "telnet={host='%s',password='******'}", psz_telnet_host, psz_esc_passwd );
free( psz_esc_passwd );
free( psz_telnet_passwd );
free( psz_telnet_host );
}
else if( !strcmp( name, "cli" ) )
{
char *psz_rc_host = var_CreateGetNonEmptyString( p_intf, "rc-host" );
if( !psz_rc_host )
psz_rc_host = var_CreateGetNonEmptyString( p_intf, "cli-host" );
if( psz_rc_host )
{
char *psz_esc_host = config_StringEscape( psz_rc_host );
asprintf( &psz_config, "cli={host='%s'}", psz_esc_host );
free( psz_esc_host );
free( psz_rc_host );
}
}
}
if( psz_config )
{
char *psz_buffer;
if( asprintf( &psz_buffer, "config={%s}", psz_config ) != -1 )
{
char *psz_log = StripPasswords( psz_buffer );
if( psz_log != NULL )
{
msg_Dbg( p_intf, "Setting config variable: %s", psz_log );
free( psz_log );
}
if( luaL_dostring( L, psz_buffer ) == 1 )
msg_Err( p_intf, "Error while parsing \"lua-config\"." );
free( psz_buffer );
lua_getglobal( L, "config" );
if( lua_istable( L, -1 ) )
{
if( !strcmp( name, "cli" ) )
{
lua_getfield( L, -1, "rc" );
if( lua_istable( L, -1 ) )
{
/* msg_Warn( p_intf, "The `rc' lua interface script "
"was renamed `cli', please update "
"your configuration!" ); */
lua_setfield( L, -2, "cli" );
}
else
lua_pop( L, 1 );
}
lua_getfield( L, -1, name );
if( lua_istable( L, -1 ) )
{
lua_setglobal( L, "config" );
b_config_set = true;
}
}
}
free( psz_config );
}
if( !b_config_set )
{
lua_newtable( L );
lua_setglobal( L, "config" );
}
/* Wrapper for legacy telnet config */
if ( !strcmp( name, "telnet" ) )
{
/* msg_Warn( p_intf, "The `telnet' lua interface script was replaced "
"by `cli', please update your configuration!" ); */
char *wrapped_file = vlclua_find_file( p_this, "intf", "cli" );
if( !wrapped_file )
{
msg_Err( p_intf, "Couldn't find lua interface script \"cli\", "
"needed by telnet wrapper" );
lua_close( p_sys->L );
goto error;
}
lua_pushstring( L, wrapped_file );
lua_setglobal( L, "wrapped_file" );
free( wrapped_file );
}
p_sys->L = L;
vlc_mutex_init( &p_sys->lock );
vlc_cond_init( &p_sys->wait );
p_sys->exiting = false;
if( vlc_clone( &p_sys->thread, Run, p_intf, VLC_THREAD_PRIORITY_LOW ) )
{
vlc_cond_destroy( &p_sys->wait );
vlc_mutex_destroy( &p_sys->lock );
lua_close( p_sys->L );
goto error;
}
return VLC_SUCCESS;
error:
free( p_sys->psz_filename );
free( p_sys );
free( p_intf->psz_header );
p_intf->psz_header = NULL;
return VLC_EGENERIC;
}
