/*****************************************************************************
* 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;
}
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;
}
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 );
}
/*****************************************************************************
* 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 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
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;
}
}
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
}
/*
* 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" );
}
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;
}
/*****************************************************************************
* 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 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;
}
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;
}
/*****************************************************************************
* 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 */
dialog_Fatal(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://" */
#if 0 //NOT USED
psz_url = strndup(p_buffer_pos, strcspn(p_buffer_pos, "\n"));
if (!psz_url)
goto oom;
switch(ParseURL(psz_url, &p_sys->psz_nowp_host,
&p_sys->psz_nowp_file, &p_sys->i_nowp_port))
{
case VLC_ENOMEM:
goto oom;
case VLC_EGENERIC:
goto proto;
case VLC_SUCCESS:
default:
break;
}
#endif
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, 0);
free(psz_url);
return VLC_SUCCESS;
oom:
return VLC_ENOMEM;
proto:
msg_Err(p_intf, "Handshake: can't recognize server protocol");
return VLC_EGENERIC;
}
void input_item_SetURI( input_item_t *p_i, const char *psz_uri )
{
vlc_mutex_lock( &p_i->lock );
#ifndef NDEBUG
if( !strstr( psz_uri, "://" ) || strstr( psz_uri, " " ) || strstr( psz_uri, "\"" ) )
fprintf( stderr, "input_item_SetURI() was likely called with a path. FIXME\n" );
#endif
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 );
}
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 );
}
/* 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: 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;
}
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 );
}
void MediaServerList::parseNewServer( IXML_Document *doc, const std::string &location )
{
if ( !doc )
{
msg_Err( m_sd, "Null IXML_Document" );
return;
}
if ( location.empty() )
{
msg_Err( m_sd, "Empty location" );
return;
}
const char* psz_base_url = location.c_str();
/* Try to extract baseURL */
IXML_NodeList* p_url_list = ixmlDocument_getElementsByTagName( doc, "URLBase" );
if ( p_url_list )
{
if ( IXML_Node* p_url_node = ixmlNodeList_item( p_url_list, 0 ) )
{
IXML_Node* p_text_node = ixmlNode_getFirstChild( p_url_node );
if ( p_text_node )
psz_base_url = ixmlNode_getNodeValue( p_text_node );
}
ixmlNodeList_free( p_url_list );
}
/* Get devices */
IXML_NodeList* p_device_list = ixmlDocument_getElementsByTagName( doc, "device" );
if ( !p_device_list )
return;
for ( unsigned int i = 0; i < ixmlNodeList_length( p_device_list ); i++ )
{
IXML_Element* p_device_element = ( IXML_Element* ) ixmlNodeList_item( p_device_list, i );
if( !p_device_element )
continue;
const char* psz_device_type = xml_getChildElementValue( p_device_element, "deviceType" );
if ( !psz_device_type )
{
msg_Warn( m_sd, "No deviceType found!" );
continue;
}
if ( strncmp( MEDIA_SERVER_DEVICE_TYPE, psz_device_type,
strlen( MEDIA_SERVER_DEVICE_TYPE ) - 1 )
&& strncmp( SATIP_SERVER_DEVICE_TYPE, psz_device_type,
strlen( SATIP_SERVER_DEVICE_TYPE ) - 1 ) )
continue;
const char* psz_udn = xml_getChildElementValue( p_device_element,
"UDN" );
if ( !psz_udn )
{
msg_Warn( m_sd, "No UDN!" );
continue;
}
/* Check if server is already added */
if ( getServer( psz_udn ) )
{
msg_Warn( m_sd, "Server with uuid '%s' already exists.", psz_udn );
continue;
}
const char* psz_friendly_name =
xml_getChildElementValue( p_device_element,
"friendlyName" );
if ( !psz_friendly_name )
{
msg_Dbg( m_sd, "No friendlyName!" );
continue;
}
std::string iconUrl = getIconURL( p_device_element, psz_base_url );
// We now have basic info, we need to get the content browsing url
// so the access module can browse without fetching the manifest again
if ( !strncmp( SATIP_SERVER_DEVICE_TYPE, psz_device_type,
strlen( SATIP_SERVER_DEVICE_TYPE ) - 1 ) )
{
SD::MediaServerDesc* p_server = NULL;
vlc_url_t url;
vlc_UrlParse( &url, psz_base_url );
char *psz_satip_channellist = config_GetPsz(m_sd, "satip-channelist");
if( !psz_satip_channellist ) {
break;
}
/* a user may have provided a custom playlist url */
if (strncmp(psz_satip_channellist, "CustomList", 10) == 0) {
char *psz_satip_playlist_url = config_GetPsz( m_sd, "satip-channellist-url" );
if ( psz_satip_playlist_url ) {
p_server = new(std::nothrow) SD::MediaServerDesc( psz_udn, psz_friendly_name, psz_satip_playlist_url, iconUrl );
if( likely( p_server ) ) {
p_server->satIpHost = url.psz_host;
p_server->isSatIp = true;
if( !addServer( p_server ) ) {
delete p_server;
}
}
/* to comply with the SAT>IP specification, we don't fall back on another channel list if this path failed */
free( psz_satip_playlist_url );
vlc_UrlClean( &url );
continue;
}
}
/* If requested by the user, check for a SAT>IP m3u list, which may be provided by some rare devices */
if (strncmp(psz_satip_channellist, "ServerList", 10) == 0) {
const char* psz_m3u_url = xml_getChildElementValue( p_device_element, "satip:X_SATIPM3U" );
if ( psz_m3u_url ) {
if ( strncmp( "http", psz_m3u_url, 4) )
{
char* psz_url = NULL;
if ( UpnpResolveURL2( psz_base_url, psz_m3u_url, &psz_url ) == UPNP_E_SUCCESS )
{
p_server = new(std::nothrow) SD::MediaServerDesc( psz_udn, psz_friendly_name, psz_url, iconUrl );
free(psz_url);
}
} else {
p_server = new(std::nothrow) SD::MediaServerDesc( psz_udn, psz_friendly_name, psz_m3u_url, iconUrl );
}
if ( unlikely( !p_server ) )
break;
p_server->satIpHost = url.psz_host;
p_server->isSatIp = true;
if ( !addServer( p_server ) )
delete p_server;
free(psz_satip_channellist);
} else {
msg_Warn( m_sd, "SAT>IP server '%s' did not provide a playlist", url.psz_host);
}
/* to comply with the SAT>IP specifications, we don't fallback on another channel list if this path failed */
vlc_UrlClean( &url );
continue;
}
/* Normally, fetch a playlist from the web,
* which will be processed by a lua script a bit later */
char *psz_url;
if (asprintf( &psz_url, "http://www.satip.info/Playlists/%s.m3u",
psz_satip_channellist ) < 0 ) {
vlc_UrlClean( &url );
free( psz_satip_channellist );
continue;
}
p_server = new(std::nothrow) SD::MediaServerDesc( psz_udn,
psz_friendly_name, psz_url, iconUrl );
if( likely( p_server ) ) {
p_server->satIpHost = url.psz_host;
p_server->isSatIp = true;
if( !addServer( p_server ) ) {
delete p_server;
}
}
free( psz_url );
free( psz_satip_channellist );
vlc_UrlClean( &url );
continue;
}
/* Check for ContentDirectory service. */
IXML_NodeList* p_service_list = ixmlElement_getElementsByTagName( p_device_element, "service" );
if ( !p_service_list )
continue;
for ( unsigned int j = 0; j < ixmlNodeList_length( p_service_list ); j++ )
{
IXML_Element* p_service_element = (IXML_Element*)ixmlNodeList_item( p_service_list, j );
const char* psz_service_type = xml_getChildElementValue( p_service_element, "serviceType" );
if ( !psz_service_type )
{
msg_Warn( m_sd, "No service type found." );
continue;
}
int k = strlen( CONTENT_DIRECTORY_SERVICE_TYPE ) - 1;
if ( strncmp( CONTENT_DIRECTORY_SERVICE_TYPE,
psz_service_type, k ) )
continue;
const char* psz_control_url = xml_getChildElementValue( p_service_element,
"controlURL" );
if ( !psz_control_url )
{
msg_Warn( m_sd, "No control url found." );
continue;
}
/* Try to browse content directory. */
char* psz_url = ( char* ) malloc( strlen( psz_base_url ) + strlen( psz_control_url ) + 1 );
if ( psz_url )
{
if ( UpnpResolveURL( psz_base_url, psz_control_url, psz_url ) == UPNP_E_SUCCESS )
{
SD::MediaServerDesc* p_server = new(std::nothrow) SD::MediaServerDesc( psz_udn,
psz_friendly_name, psz_url, iconUrl );
free( psz_url );
if ( unlikely( !p_server ) )
break;
if ( !addServer( p_server ) )
{
delete p_server;
continue;
}
}
else
free( psz_url );
}
}
ixmlNodeList_free( p_service_list );
}
ixmlNodeList_free( p_device_list );
}
/****************************************************************************
* 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;
}
/* Take an url key and splits it into vlc_keystore_entry values */
static int
key2values( char* psz_key, vlc_keystore_entry* p_entry )
{
vlc_url_t url;
int i_ret = VLC_ENOMEM;
for ( int inc = 0 ; inc < KEY_MAX ; ++inc )
p_entry->ppsz_values[inc] = NULL;
vlc_UrlParse( &url, psz_key );
if ( url.psz_protocol && !( p_entry->ppsz_values[KEY_PROTOCOL] =
strdup( url.psz_protocol ) ) )
goto end;
if ( url.psz_username && !( p_entry->ppsz_values[KEY_USER] =
strdup( url.psz_username ) ) )
goto end;
if ( url.psz_host && !( p_entry->ppsz_values[KEY_SERVER] =
strdup( url.psz_host ) ) )
goto end;
if ( url.i_port && asprintf( &p_entry->ppsz_values[KEY_PORT],
"%d", url.i_port) == -1 )
goto end;
if ( url.psz_path && !( p_entry->ppsz_values[KEY_PATH] =
strdup( url.psz_path ) ) )
goto end;
if ( url.psz_option )
{
char *p_savetpr;
for ( const char *psz_option = strtok_r( url.psz_option, "&", &p_savetpr );
psz_option != NULL;
psz_option = strtok_r( NULL, "&", &p_savetpr ) )
{
enum vlc_keystore_key key;
const char *psz_value;
if ( !strncmp( psz_option, "realm=", strlen( "realm=" ) ) )
{
key = KEY_REALM;
psz_value = psz_option + strlen( "realm=" );
}
else if ( !strncmp( psz_option, "authtype=", strlen( "authtype=" ) ) )
{
key = KEY_AUTHTYPE;
psz_value = psz_option + strlen( "authtype=" );
}
else
psz_value = NULL;
if ( psz_value != NULL )
{
p_entry->ppsz_values[key] = vlc_b64_decode( psz_value );
if ( !p_entry->ppsz_values[key] )
goto end;
}
}
}
i_ret = VLC_SUCCESS;
end:
vlc_UrlClean( &url );
if ( i_ret )
{
free( p_entry->ppsz_values[KEY_PROTOCOL] );
free( p_entry->ppsz_values[KEY_USER] );
free( p_entry->ppsz_values[KEY_SERVER] );
free( p_entry->ppsz_values[KEY_PORT] );
free( p_entry->ppsz_values[KEY_PATH] );
free( p_entry->ppsz_values[KEY_REALM] );
free ( p_entry->ppsz_values[KEY_AUTHTYPE] );
}
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;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
stream_t *p_access = (stream_t*)p_this;
const char *psz_url = p_access->psz_url;
char *psz;
int ret = VLC_EGENERIC;
vlc_credential credential;
access_sys_t *p_sys = vlc_obj_malloc( p_this, sizeof(*p_sys) );
if( unlikely(p_sys == NULL) )
return VLC_ENOMEM;
p_sys->stream = NULL;
p_sys->b_proxy = false;
p_sys->psz_proxy_passbuf = NULL;
p_sys->psz_mime = NULL;
p_sys->b_icecast = false;
p_sys->psz_location = NULL;
p_sys->psz_user_agent = NULL;
p_sys->psz_referrer = NULL;
p_sys->psz_username = NULL;
p_sys->psz_password = NULL;
p_sys->i_icy_meta = 0;
p_sys->i_icy_offset = 0;
p_sys->psz_icy_name = NULL;
p_sys->psz_icy_genre = NULL;
p_sys->psz_icy_title = NULL;
p_sys->b_has_size = false;
p_sys->offset = 0;
p_sys->size = 0;
p_access->p_sys = p_sys;
if( vlc_UrlParse( &p_sys->url, psz_url ) || p_sys->url.psz_host == NULL )
{
msg_Err( p_access, "invalid URL" );
vlc_UrlClean( &p_sys->url );
return VLC_EGENERIC;
}
if( p_sys->url.i_port <= 0 )
p_sys->url.i_port = 80;
vlc_credential_init( &credential, &p_sys->url );
/* Determine the HTTP user agent */
/* See RFC2616 §2.2 token and comment definition, and §3.8 and
* §14.43 user-agent header */
p_sys->psz_user_agent = var_InheritString( p_access, "http-user-agent" );
if (p_sys->psz_user_agent)
{
unsigned comment_level = 0;
for( char *p = p_sys->psz_user_agent; *p; p++ )
{
uint8_t c = *p;
if (comment_level == 0)
{
if( c < 32 || strchr( ")<>@,;:\\\"[]?={}", c ) )
*p = '_'; /* remove potentially harmful characters */
}
else
{
if (c == ')')
comment_level--;
else if( c < 32 && strchr( "\t\r\n", c ) == NULL)
*p = '_'; /* remove potentially harmful characters */
}
if (c == '(')
{
if (comment_level == UINT_MAX)
break;
comment_level++;
}
}
/* truncate evil unclosed comments */
if (comment_level > 0)
{
char *p = strchr(p_sys->psz_user_agent, '(');
*p = '\0';
}
}
/* HTTP referrer */
p_sys->psz_referrer = var_InheritString( p_access, "http-referrer" );
/* Check proxy */
psz = var_InheritString( p_access, "http-proxy" );
if( psz == NULL )
{
msg_Dbg(p_access, "querying proxy for %s", psz_url);
psz = vlc_getProxyUrl(psz_url);
if (psz != NULL)
msg_Dbg(p_access, "proxy: %s", psz);
else
msg_Dbg(p_access, "no proxy");
}
if( psz != NULL )
{
p_sys->b_proxy = true;
vlc_UrlParse( &p_sys->proxy, psz );
free( psz );
psz = var_InheritString( p_access, "http-proxy-pwd" );
if( psz )
p_sys->proxy.psz_password = p_sys->psz_proxy_passbuf = psz;
if( p_sys->proxy.psz_host == NULL || *p_sys->proxy.psz_host == '\0' )
{
msg_Warn( p_access, "invalid proxy host" );
goto error;
}
if( p_sys->proxy.i_port <= 0 )
{
p_sys->proxy.i_port = 80;
}
}
msg_Dbg( p_access, "http: server='%s' port=%d file='%s'",
p_sys->url.psz_host, p_sys->url.i_port,
p_sys->url.psz_path != NULL ? p_sys->url.psz_path : "" );
if( p_sys->b_proxy )
{
msg_Dbg( p_access, " proxy %s:%d", p_sys->proxy.psz_host,
p_sys->proxy.i_port );
}
if( p_sys->url.psz_username && *p_sys->url.psz_username )
{
msg_Dbg( p_access, " user='******'", p_sys->url.psz_username );
}
p_sys->b_reconnect = var_InheritBool( p_access, "http-reconnect" );
if( vlc_credential_get( &credential, p_access, NULL, NULL, NULL, NULL ) )
{
p_sys->url.psz_username = (char *) credential.psz_username;
p_sys->url.psz_password = (char *) credential.psz_password;
}
connect:
/* Connect */
if( Connect( p_access ) )
goto disconnect;
if( p_sys->i_code == 401 )
{
if( p_sys->auth.psz_realm == NULL )
{
msg_Err( p_access, "authentication failed without realm" );
goto disconnect;
}
/* FIXME ? */
if( p_sys->url.psz_username && p_sys->url.psz_password &&
p_sys->auth.psz_nonce && p_sys->auth.i_nonce == 0 )
{
Disconnect( p_access );
goto connect;
}
free( p_sys->psz_username );
free( p_sys->psz_password );
p_sys->psz_username = p_sys->psz_password = NULL;
msg_Dbg( p_access, "authentication failed for realm %s",
p_sys->auth.psz_realm );
credential.psz_realm = p_sys->auth.psz_realm;
credential.psz_authtype = p_sys->auth.psz_nonce ? "Digest" : "Basic";
if( vlc_credential_get( &credential, p_access, NULL, NULL,
_("HTTP authentication"),
_("Please enter a valid login name and a "
"password for realm %s."), p_sys->auth.psz_realm ) )
{
p_sys->psz_username = strdup(credential.psz_username);
p_sys->psz_password = strdup(credential.psz_password);
if (!p_sys->psz_username || !p_sys->psz_password)
goto disconnect;
msg_Err( p_access, "retrying with user=%s", p_sys->psz_username );
p_sys->url.psz_username = p_sys->psz_username;
p_sys->url.psz_password = p_sys->psz_password;
Disconnect( p_access );
goto connect;
}
else
goto disconnect;
}
else
vlc_credential_store( &credential, p_access );
if( ( p_sys->i_code == 301 || p_sys->i_code == 302 ||
p_sys->i_code == 303 || p_sys->i_code == 307 ) &&
p_sys->psz_location != NULL )
{
p_access->psz_url = p_sys->psz_location;
p_sys->psz_location = NULL;
ret = VLC_ACCESS_REDIRECT;
goto disconnect;
}
if( p_sys->b_reconnect ) msg_Dbg( p_access, "auto re-connect enabled" );
/* Set up p_access */
p_access->pf_read = Read;
p_access->pf_control = Control;
p_access->pf_seek = Seek;
vlc_credential_clean( &credential );
return VLC_SUCCESS;
disconnect:
Disconnect( p_access );
error:
vlc_credential_clean( &credential );
vlc_UrlClean( &p_sys->url );
if( p_sys->b_proxy )
vlc_UrlClean( &p_sys->proxy );
free( p_sys->psz_proxy_passbuf );
free( p_sys->psz_mime );
free( p_sys->psz_location );
free( p_sys->psz_user_agent );
free( p_sys->psz_referrer );
free( p_sys->psz_username );
free( p_sys->psz_password );
return ret;
}
/*****************************************************************************
* 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;
}
/*****************************************************************************
* Open: Initialize module's data structures and libdsm
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
access_sys_t *p_sys;
smb_stat st;
/* Init p_access */
access_InitFields( 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;
char *psz_decoded_location = vlc_uri_decode_duplicate( p_access->psz_location );
if( psz_decoded_location == NULL )
goto error;
vlc_UrlParse( &p_sys->url, psz_decoded_location );
free( psz_decoded_location );
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 ) )
{
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;
}
static int
Open(vlc_object_t *p_obj)
{
access_t *p_access = (access_t *)p_obj;
access_sys_t *p_sys = calloc(1, sizeof (*p_sys));
if (unlikely(p_sys == NULL))
goto error;
p_access->p_sys = p_sys;
p_sys->b_auto_guid = var_InheritBool(p_obj, "nfs-auto-guid");
/* nfs_* functions need a decoded url */
p_sys->psz_url_decoded = vlc_uri_decode_duplicate(p_access->psz_url);
if (p_sys->psz_url_decoded == NULL)
goto error;
/* Parse the encoded URL */
vlc_UrlParse(&p_sys->encoded_url, p_access->psz_url);
if (p_sys->encoded_url.psz_option)
{
if (strstr(p_sys->encoded_url.psz_option, "uid")
|| strstr(p_sys->encoded_url.psz_option, "gid"))
p_sys->b_auto_guid = false;
}
if (NfsInit(p_access, p_sys->psz_url_decoded) == -1)
goto error;
if (p_sys->p_nfs_url->path != NULL && p_sys->p_nfs_url->file != NULL)
{
/* The url has a valid path and file, mount the path and open/opendir
* the file */
msg_Dbg(p_access, "nfs_mount: server: '%s', path: '%s'",
p_sys->p_nfs_url->server, p_sys->p_nfs_url->path);
if (nfs_mount_async(p_sys->p_nfs, p_sys->p_nfs_url->server,
p_sys->p_nfs_url->path, nfs_mount_cb, p_access) < 0)
{
msg_Err(p_access, "nfs_mount_async failed");
goto error;
}
if (vlc_nfs_mainloop(p_access, nfs_mount_open_finished_cb) < 0)
goto error;
if (p_sys->psz_url_decoded_slash != NULL)
{
/* Retry to mount by adding a '/' to the path, see comment in
* nfs_mount_cb */
nfs_destroy_url(p_sys->p_nfs_url);
nfs_destroy_context(p_sys->p_nfs);
p_sys->p_nfs_url = NULL;
p_sys->p_nfs = NULL;
if (NfsInit(p_access, p_sys->psz_url_decoded_slash) == -1
|| p_sys->p_nfs_url->path == NULL || p_sys->p_nfs_url->file == NULL)
goto error;
if (nfs_mount_async(p_sys->p_nfs, p_sys->p_nfs_url->server,
p_sys->p_nfs_url->path, nfs_mount_cb, p_access) < 0)
{
msg_Err(p_access, "nfs_mount_async failed");
goto error;
}
if (vlc_nfs_mainloop(p_access, nfs_mount_open_slash_finished_cb) < 0)
goto error;
}
if (p_sys->p_nfsfh != NULL)
{
p_access->pf_read = FileRead;
p_access->pf_seek = FileSeek;
p_access->pf_control = FileControl;
}
else if (p_sys->p_nfsdir != NULL)
{
p_access->pf_readdir = DirRead;
p_access->pf_seek = NULL;
p_access->pf_control = DirControl;
}
else
vlc_assert_unreachable();
}
else
{
/* url is just a server: fetch exports point */
nfs_destroy_context(p_sys->p_nfs);
p_sys->p_nfs = NULL;
p_sys->p_mount = rpc_init_context();
if (p_sys->p_mount == NULL)
{
msg_Err(p_access, "rpc_init_context failed");
goto error;
}
p_sys->res.exports.ppsz_names = NULL;
p_sys->res.exports.i_count = -1;
if (mount_getexports_async(p_sys->p_mount, p_sys->p_nfs_url->server,
mount_export_cb, p_access) < 0)
{
msg_Err(p_access, "mount_getexports_async failed");
goto error;
}
if (vlc_mount_mainloop(p_access, mount_getexports_finished_cb) < 0)
goto error;
p_access->pf_readdir = MountRead;
p_access->pf_seek = NULL;
p_access->pf_control = DirControl;
}
return VLC_SUCCESS;
error:
Close(p_obj);
return VLC_EGENERIC;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t*)p_this;
sout_instance_t *p_sout = p_stream->p_sout;
slp_session_t *p_slp = NULL;
char *psz_mux;
char *psz_access;
char *psz_url;
vlc_value_t val;
sout_access_out_t *p_access;
sout_mux_t *p_mux;
char *psz_mux_byext = NULL;
sout_CfgParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
p_stream->p_cfg );
var_Get( p_stream, SOUT_CFG_PREFIX "access", &val );
psz_access = *val.psz_string ? val.psz_string : NULL;
if( val.psz_string && !*val.psz_string ) free( val.psz_string );
var_Get( p_stream, SOUT_CFG_PREFIX "mux", &val );
psz_mux = *val.psz_string ? val.psz_string : NULL;
if( val.psz_string && !*val.psz_string ) free( val.psz_string );
var_Get( p_stream, SOUT_CFG_PREFIX "url", &val );
psz_url = *val.psz_string ? val.psz_string : NULL;
if( val.psz_string && !*val.psz_string ) free( val.psz_string );
p_stream->p_sys = malloc( sizeof( sout_stream_sys_t) );
p_stream->p_sys->p_session = NULL;
msg_Dbg( p_this, "creating `%s/%s://%s'", psz_access, psz_mux, psz_url );
/* ext -> muxer name */
if( psz_url && strrchr( psz_url, '.' ) )
{
/* by extention */
static struct { char *ext; char *mux; } exttomux[] =
{
{ "avi", "avi" },
{ "ogg", "ogg" },
{ "ogm", "ogg" },
{ "mp4", "mp4" },
{ "mov", "mov" },
{ "moov","mov" },
{ "asf", "asf" },
{ "wma", "asf" },
{ "wmv", "asf" },
{ "trp", "ts" },
{ "ts", "ts" },
{ "mpg", "ps" },
{ "mpeg","ps" },
{ "ps", "ps" },
{ "mpeg1","mpeg1" },
{ NULL, NULL }
};
char *psz_ext = strrchr( psz_url, '.' ) + 1;
int i;
msg_Dbg( p_this, "extention is %s", psz_ext );
for( i = 0; exttomux[i].ext != NULL; i++ )
{
if( !strcasecmp( psz_ext, exttomux[i].ext ) )
{
psz_mux_byext = exttomux[i].mux;
break;
}
}
msg_Dbg( p_this, "extention -> mux=%s", psz_mux_byext );
}
/* We fix access/mux to valid couple */
if( !psz_access && !psz_mux )
{
if( psz_mux_byext )
{
msg_Warn( p_stream,
"no access _and_ no muxer, extention gives file/%s",
psz_mux_byext );
psz_access = strdup("file");
psz_mux = strdup(psz_mux_byext);
}
else
{
msg_Err( p_stream, "no access _and_ no muxer (fatal error)" );
return VLC_EGENERIC;
}
}
if( psz_access && !psz_mux )
{
/* access given, no mux */
if( !strncmp( psz_access, "mmsh", 4 ) )
{
psz_mux = strdup("asfh");
}
else if( !strncmp( psz_access, "udp", 3 ) )
{
psz_mux = strdup("ts");
}
else if( psz_mux_byext )
{
psz_mux = strdup(psz_mux_byext);
}
else
{
msg_Err( p_stream, "no mux specified or found by extention" );
return VLC_EGENERIC;
}
}
else if( psz_mux && !psz_access )
{
/* mux given, no access */
if( !strncmp( psz_mux, "asfh", 4 ) )
{
psz_access = strdup("mmsh");
}
else
{
/* default file */
psz_access = strdup("file");
}
}
/* fix or warm of incompatible couple */
if( psz_mux && psz_access )
{
if( !strncmp( psz_access, "mmsh", 4 ) &&
strncmp( psz_mux, "asfh", 4 ) )
{
char *p = strchr( psz_mux,'{' );
msg_Warn( p_stream, "fixing to mmsh/asfh" );
if( p )
{
/* -> a little memleak but ... */
psz_mux = malloc( strlen( "asfh" ) + strlen( p ) + 1);
sprintf( psz_mux, "asfh%s", p );
}
else
{
psz_mux = strdup("asfh");
}
}
else if( ( !strncmp( psz_access, "rtp", 3 ) ||
!strncmp( psz_access, "udp", 3 ) ) &&
strncmp( psz_mux, "ts", 2 ) )
{
msg_Err( p_stream, "for now udp and rtp are only valid with TS" );
}
else if( strncmp( psz_access, "file", 4 ) &&
( !strncmp( psz_mux, "mov", 3 ) ||
!strncmp( psz_mux, "mp4", 3 ) ) )
{
msg_Err( p_stream, "mov and mp4 work only with file output" );
}
}
msg_Dbg( p_this, "using `%s/%s://%s'", psz_access, psz_mux, psz_url );
/* *** find and open appropriate access module *** */
p_access = sout_AccessOutNew( p_sout, psz_access, psz_url );
if( p_access == NULL )
{
msg_Err( p_stream, "no suitable sout access module for `%s/%s://%s'",
psz_access, psz_mux, psz_url );
if( psz_access ) free( psz_access );
if( psz_mux ) free( psz_mux );
return VLC_EGENERIC;
}
msg_Dbg( p_stream, "access opened" );
/* *** find and open appropriate mux module *** */
p_mux = sout_MuxNew( p_sout, psz_mux, p_access );
if( p_mux == NULL )
{
msg_Err( p_stream, "no suitable sout mux module for `%s/%s://%s'",
psz_access, psz_mux, psz_url );
sout_AccessOutDelete( p_access );
if( psz_access ) free( psz_access );
if( psz_mux ) free( psz_mux );
return VLC_EGENERIC;
}
msg_Dbg( p_stream, "mux opened" );
/* *** Create the SAP Session structure *** */
var_Get( p_stream, SOUT_CFG_PREFIX "sap", &val );
if( val.b_bool &&
( strstr( psz_access, "udp" ) || strstr( psz_access , "rtp" ) ) )
{
session_descriptor_t *p_session = sout_AnnounceSessionCreate();
announce_method_t *p_method =
sout_AnnounceMethodCreate( METHOD_TYPE_SAP );
vlc_url_t url;
var_Get( p_stream, SOUT_CFG_PREFIX "name", &val );
if( *val.psz_string )
{
p_session->psz_name = strdup( val.psz_string );
}
else
{
p_session->psz_name = strdup( psz_url );
}
free( val.psz_string );
var_Get( p_stream, SOUT_CFG_PREFIX "group", &val );
if( *val.psz_string )
{
p_session->psz_group = strdup( val.psz_string );
}
free( val.psz_string );
var_Get( p_stream, SOUT_CFG_PREFIX "sap-ipv6", &val );
p_method->i_ip_version = val.b_bool ? 6 : 4;
/* Now, parse the URL to extract host and port */
vlc_UrlParse( &url, psz_url , 0);
if( url.psz_host )
{
if( url.i_port == 0 ) url.i_port = DEFAULT_PORT;
p_session->psz_uri = url.psz_host;
p_session->i_port = url.i_port;
p_session->psz_sdp = NULL;
p_session->i_ttl = config_GetInt( p_sout, "ttl" );
p_session->i_payload = 33;
msg_Info( p_this, "SAP Enabled");
sout_AnnounceRegister( p_sout, p_session, p_method );
/* FIXME: Free p_method */
p_stream->p_sys->p_session = p_session;
}
vlc_UrlClean( &url );
if( p_method->psz_address) free( p_method->psz_address );
free( p_method );
}
/* *** Register with slp *** */
#ifdef HAVE_SLP_H
var_Get( p_stream, SOUT_CFG_PREFIX "slp", &val );
if( val.b_bool &&
( strstr( psz_access, "udp" ) || strstr( psz_access , "rtp" ) ) )
{
int i_ret;
msg_Info( p_this, "SLP Enabled");
var_Get( p_stream, SOUT_CFG_PREFIX "name", &val );
if( *val.psz_string )
{
i_ret = sout_SLPReg( p_sout, psz_url, val.psz_string );
}
else
{
i_ret = sout_SLPReg( p_sout, psz_url, psz_url );
}
if( i_ret )
{
msg_Warn( p_sout, "SLP Registering failed");
}
else
{
p_slp = malloc(sizeof(slp_session_t));
p_slp->psz_url = strdup( psz_url );
p_slp->psz_name =
strdup( *val.psz_string ? val.psz_string : psz_url );
}
free( val.psz_string );
}
#endif
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->p_sys->p_mux = p_mux;
p_stream->p_sys->p_slp = p_slp;
if( psz_access ) free( psz_access );
if( psz_mux ) free( psz_mux );
if( psz_url ) free( psz_url );
return VLC_SUCCESS;
}