URL_t*
check4proxies( URL_t *url ) {
URL_t *url_out = NULL;
if( url==NULL ) return NULL;
url_out = url_new( url->url );
if( !strcasecmp(url->protocol, "http_proxy") ) {
mp_msg(MSGT_NETWORK,MSGL_V,"Using HTTP proxy: http://%s:%d\n", url->hostname, url->port );
return url_out;
}
// Check if the http_proxy environment variable is set.
if( !strcasecmp(url->protocol, "http") ) {
char *proxy;
proxy = getenv("http_proxy");
if( proxy!=NULL ) {
// We got a proxy, build the URL to use it
int len;
char *new_url;
URL_t *tmp_url;
URL_t *proxy_url = url_new( proxy );
if( proxy_url==NULL ) {
mp_msg(MSGT_NETWORK,MSGL_WARN,
MSGTR_MPDEMUX_NW_InvalidProxySettingTryingWithout);
return url_out;
}
#ifdef HAVE_AF_INET6
if (network_ipv4_only_proxy && (gethostbyname(url->hostname)==NULL)) {
mp_msg(MSGT_NETWORK,MSGL_WARN,
MSGTR_MPDEMUX_NW_CantResolvTryingWithoutProxy);
url_free(proxy_url);
return url_out;
}
#endif
mp_msg(MSGT_NETWORK,MSGL_V,"Using HTTP proxy: %s\n", proxy_url->url );
len = strlen( proxy_url->hostname ) + strlen( url->url ) + 20; // 20 = http_proxy:// + port
new_url = malloc( len+1 );
if( new_url==NULL ) {
mp_msg(MSGT_NETWORK,MSGL_FATAL,MSGTR_MemAllocFailed);
url_free(proxy_url);
return url_out;
}
sprintf(new_url, "http_proxy://%s:%d/%s", proxy_url->hostname, proxy_url->port, url->url );
tmp_url = url_new( new_url );
if( tmp_url==NULL ) {
free( new_url );
url_free( proxy_url );
return url_out;
}
url_free( url_out );
url_out = tmp_url;
free( new_url );
url_free( proxy_url );
}
}
return url_out;
}
URL_t*
check4proxies( const URL_t *url ) {
URL_t *url_out = NULL;
if( url==NULL ) return NULL;
url_out = url_new( url->url );
if( !strcasecmp(url->protocol, "mp_http_proxy") ) {
mp_msg(MSGT_NETWORK,MSGL_V,"Using HTTP proxy: http://%s:%d\n", url->hostname, url->port );
return url_out;
}
// Check if the http_proxy environment variable is set.
if( !strcasecmp(url->protocol, "mp_http") ) {
char *proxy;
proxy = getenv("http_proxy");
if( proxy!=NULL ) {
// We got a proxy, build the URL to use it
char *new_url;
URL_t *tmp_url;
URL_t *proxy_url = url_new( proxy );
if( proxy_url==NULL ) {
mp_tmsg(MSGT_NETWORK,MSGL_WARN,
"Invalid proxy setting... Trying without proxy.\n");
return url_out;
}
#ifdef HAVE_AF_INET6
if (network_ipv4_only_proxy && (gethostbyname(url->hostname)==NULL)) {
mp_tmsg(MSGT_NETWORK,MSGL_WARN,
"Could not resolve remote hostname for AF_INET. Trying without proxy.\n");
url_free(proxy_url);
return url_out;
}
#endif
mp_msg(MSGT_NETWORK,MSGL_V,"Using HTTP proxy: %s\n", proxy_url->url );
new_url = get_http_proxy_url(proxy_url, url->url);
if( new_url==NULL ) {
mp_tmsg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed.\n");
url_free(proxy_url);
return url_out;
}
tmp_url = url_new( new_url );
if( tmp_url==NULL ) {
free( new_url );
url_free( proxy_url );
return url_out;
}
url_free( url_out );
url_out = tmp_url;
free( new_url );
url_free( proxy_url );
}
}
return url_out;
}
static int
rtp_stream_open (stream_t *stream, int mode, void *opts, int *file_format)
{
mp_msg (MSGT_OPEN, MSGL_INFO, "STREAM_RTP, URL: %s\n", stream->url);
stream->streaming_ctrl = streaming_ctrl_new ();
if (!stream->streaming_ctrl)
return STREAM_ERROR;
stream->streaming_ctrl->bandwidth = network_bandwidth;
stream->streaming_ctrl->url = url_new(stream->url);
if (stream->streaming_ctrl->url->port == 0)
{
mp_msg (MSGT_NETWORK, MSGL_ERR,
"You must enter a port number for RTP streams!\n");
streaming_ctrl_free (stream->streaming_ctrl);
stream->streaming_ctrl = NULL;
return STREAM_UNSUPPORTED;
}
if (rtp_streaming_start (stream) < 0)
{
mp_msg (MSGT_NETWORK, MSGL_ERR, "rtp_streaming_start failed\n");
streaming_ctrl_free (stream->streaming_ctrl);
stream->streaming_ctrl = NULL;
return STREAM_UNSUPPORTED;
}
stream->type = STREAMTYPE_STREAM;
fixup_network_stream_cache (stream);
return STREAM_OK;
}
URL_t *url_new_with_proxy(const char *urlstr)
{
URL_t *url = url_new(urlstr);
URL_t *url_with_proxy = check4proxies(url);
url_free(url);
return url_with_proxy;
}
/* Full_URL is like "ftp://*****:*****@192.168.0.1/xxxx", user and password can be NULL*/
unsigned long libnet_download(char *full_url, char *outfile)
{
UrlResource *rsrc = NULL;
Url *u = NULL;
int retval = 0;
rsrc = url_resource_new();
u = url_new();
rsrc->url = url_init(u, full_url);
rsrc->options = 0;
rsrc->outfile = strdup(outfile);
rsrc->outfile_offset = 0;
rsrc->running = 1;
rsrc->options = OPT_RESUME; //default support the resume
u = rsrc->url;
if ( !rsrc->outfile && u->file )
rsrc->outfile = strdup(u->file);
if ( rsrc->outfile && (rsrc->options & OPT_RESUME))
{
rsrc->outfile_offset = get_file_size(rsrc->outfile);
if (rsrc->outfile_offset < 0)
rsrc->outfile_offset = 0;
}
create_transfer_task(rsrc, libnet_cb);
return (unsigned long)rsrc;
}
static int
rtsp_streaming_open (stream_t *stream, int mode, void *opts, int *file_format)
{
URL_t *url;
mp_msg (MSGT_OPEN, MSGL_V, "STREAM_RTSP, URL: %s\n", stream->url);
stream->streaming_ctrl = streaming_ctrl_new ();
if (!stream->streaming_ctrl)
return STREAM_ERROR;
stream->streaming_ctrl->bandwidth = network_bandwidth;
url = url_new (stream->url);
stream->streaming_ctrl->url = check4proxies (url);
stream->fd = -1;
index_mode = -1; /* prevent most RTSP streams from locking due to -idx */
if (rtsp_streaming_start (stream) < 0)
{
streaming_ctrl_free (stream->streaming_ctrl);
stream->streaming_ctrl = NULL;
return STREAM_UNSUPPORTED;
}
fixup_network_stream_cache (stream);
stream->type = STREAMTYPE_STREAM;
stream->close = rtsp_streaming_close;
return STREAM_OK;
}
static int open_s2(stream_t *stream,int mode, void* opts, int* file_format) {
int seekable=0;
URL_t *url;
stream->streaming_ctrl = streaming_ctrl_new();
if( stream->streaming_ctrl==NULL ) {
return STREAM_ERROR;
}
stream->streaming_ctrl->bandwidth = network_bandwidth;
url = url_new(stream->url);
stream->streaming_ctrl->url = check4proxies(url);
url_free(url);
mp_msg(MSGT_OPEN, MSGL_V, "STREAM_HTTP(2), URL: %s\n", stream->url);
seekable = http_streaming_start(stream, file_format);
if(seekable < 0) {
if (stream->fd >= 0)
closesocket(stream->fd);
stream->fd = -1;
streaming_ctrl_free(stream->streaming_ctrl);
stream->streaming_ctrl = NULL;
return STREAM_UNSUPPORTED;
}
return fixup_open(stream, seekable);
}
static int open_s(stream_t *stream,int mode, void* opts, int* file_format) {
URL_t *url;
stream->streaming_ctrl = streaming_ctrl_new();
if( stream->streaming_ctrl==NULL ) {
return STREAM_ERROR;
}
stream->streaming_ctrl->bandwidth = network_bandwidth;
url = url_new(stream->url);
stream->streaming_ctrl->url = check4proxies(url);
url_free(url);
mp_msg(MSGT_OPEN, MSGL_INFO, MSGTR_MPDEMUX_ASF_InfoStreamASFURL, stream->url);
if((!strncmp(stream->url, "http", 4)) && (*file_format!=DEMUXER_TYPE_ASF && *file_format!=DEMUXER_TYPE_UNKNOWN)) {
streaming_ctrl_free(stream->streaming_ctrl);
stream->streaming_ctrl = NULL;
return STREAM_UNSUPPORTED;
}
if(asf_streaming_start(stream, file_format) < 0) {
mp_msg(MSGT_OPEN, MSGL_ERR, MSGTR_MPDEMUX_ASF_StreamingFailed);
streaming_ctrl_free(stream->streaming_ctrl);
stream->streaming_ctrl = NULL;
return STREAM_UNSUPPORTED;
}
if (*file_format != DEMUXER_TYPE_PLAYLIST)
*file_format = DEMUXER_TYPE_ASF;
stream->type = STREAMTYPE_STREAM;
fixup_network_stream_cache(stream);
return STREAM_OK;
}
static int open_live_rtsp_sip(stream_t *stream,int mode, void* opts, int* file_format) {
URL_t *url;
stream->streaming_ctrl = streaming_ctrl_new();
if( stream->streaming_ctrl==NULL ) {
return STREAM_ERROR;
}
stream->streaming_ctrl->bandwidth = network_bandwidth;
url = url_new(stream->url);
stream->streaming_ctrl->url = check4proxies(url);
//url_free(url);
mp_msg(MSGT_OPEN, MSGL_INFO, "STREAM_LIVE555, URL: %s\n", stream->url);
if(rtsp_streaming_start(stream) < 0) {
mp_msg(MSGT_NETWORK,MSGL_ERR,"rtsp_streaming_start failed\n");
goto fail;
}
*file_format = DEMUXER_TYPE_RTP;
stream->type = STREAMTYPE_STREAM;
return STREAM_OK;
fail:
streaming_ctrl_free( stream->streaming_ctrl );
stream->streaming_ctrl = NULL;
return STREAM_ERROR;
}
static int cddb_http_request(char *command,
int (*reply_parser)(HTTP_header_t*, cddb_data_t*),
cddb_data_t *cddb_data)
{
char request[4096];
int fd, ret = 0;
URL_t *url;
HTTP_header_t *http_hdr;
if (reply_parser == NULL || command == NULL || cddb_data == NULL)
return -1;
sprintf(request, "http://%s/~cddb/cddb.cgi?cmd=%s%s&proto=%d",
cddb_data->freedb_server, command, cddb_data->cddb_hello,
cddb_data->freedb_proto_level);
mp_msg(MSGT_OPEN, MSGL_INFO,"Request[%s]\n", request);
url = url_new(request);
if (url == NULL) {
mp_msg(MSGT_DEMUX, MSGL_ERR, MSGTR_MPDEMUX_CDDB_NotAValidURL);
return -1;
}
fd = http_send_request(url,0);
if (fd < 0) {
mp_msg(MSGT_DEMUX, MSGL_ERR,
MSGTR_MPDEMUX_CDDB_FailedToSendHTTPRequest);
return -1;
}
http_hdr = http_read_response(fd);
if (http_hdr == NULL) {
mp_msg(MSGT_DEMUX, MSGL_ERR,
MSGTR_MPDEMUX_CDDB_FailedToReadHTTPResponse);
return -1;
}
http_debug_hdr(http_hdr);
mp_msg(MSGT_OPEN, MSGL_INFO,"body=[%s]\n", http_hdr->body);
switch (http_hdr->status_code) {
case 200:
ret = reply_parser(http_hdr, cddb_data);
break;
case 400:
mp_msg(MSGT_DEMUX, MSGL_ERR, MSGTR_MPDEMUX_CDDB_HTTPErrorNOTFOUND);
break;
default:
mp_msg(MSGT_DEMUX, MSGL_ERR, MSGTR_MPDEMUX_CDDB_HTTPErrorUnknown);
}
http_free(http_hdr);
url_free(url);
return ret;
}
static int cddb_http_request(char *command,
int (*reply_parser)(HTTP_header_t*, cddb_data_t*),
cddb_data_t *cddb_data)
{
char request[4096];
int fd, ret = 0;
URL_t *url;
HTTP_header_t *http_hdr;
if (reply_parser == NULL || command == NULL || cddb_data == NULL)
return -1;
sprintf(request, "http://%s/~cddb/cddb.cgi?cmd=%s%s&proto=%d",
cddb_data->freedb_server, command, cddb_data->cddb_hello,
cddb_data->freedb_proto_level);
mp_msg(MSGT_OPEN, MSGL_INFO,"Request[%s]\n", request);
url = url_new(request);
if (url == NULL) {
mp_tmsg(MSGT_DEMUX, MSGL_ERR, "not a valid URL\n");
return -1;
}
fd = http_send_request(url,0);
if (fd < 0) {
mp_tmsg(MSGT_DEMUX, MSGL_ERR, "Failed to send the HTTP request.\n");
return -1;
}
http_hdr = http_read_response(fd);
if (http_hdr == NULL) {
mp_tmsg(MSGT_DEMUX, MSGL_ERR, "Failed to read the HTTP response.\n");
return -1;
}
http_debug_hdr(http_hdr);
mp_msg(MSGT_OPEN, MSGL_INFO,"body=[%s]\n", http_hdr->body);
switch (http_hdr->status_code) {
case 200:
ret = reply_parser(http_hdr, cddb_data);
break;
case 400:
mp_tmsg(MSGT_DEMUX, MSGL_ERR, "Not Found.\n");
break;
default:
mp_tmsg(MSGT_DEMUX, MSGL_ERR, "unknown error code\n");
}
http_free(http_hdr);
url_free(url);
return ret;
}
/*
unsigned long libnet_download_to_pecache
branch from libnet_download_to_mem for download net work file to pe cache
use difference dump_data() when UrlResource rsrc->use_pecache != 0.
*/
unsigned long libnet_download_to_pecache(char *full_url, unsigned char* buffer, unsigned int buf_len, unsigned int offset)
{
UrlResource *rsrc = NULL;
Url *u = NULL;
int retval = 0;
if (offset >= buf_len)
{
return 0;
}
rsrc = url_resource_new();
u = url_new();
rsrc->url = url_init(u, full_url);
rsrc->options = OPT_RESUME; //default support the resume
rsrc->buffer = buffer;
rsrc->outfile_offset = offset;
rsrc->buffer_len = buf_len;
rsrc->running = 1;
rsrc->use_pecache = 1; //yuliang0604
u = rsrc->url;
if (0 == (rsrc->options & OPT_RESUME))
{
rsrc->outfile_offset = 0;
}
/* set rsrc->srcip and rsrc->srcport */
#ifdef LIB_W5300
UINT8 ip_addr[4];
char ip_str[32];
if (w5300_ioctl(0, W5300_GET_IP, ip_addr) == 0)
{
sprintf(ip_str, "%d.%d.%d.%d", ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]);
rsrc->srcip = (char *)strdup(ip_str);
rsrc->srcport = 1024 + RAND(5000 - 1024);
LIBNET_DEBUG("w5300 tcp using: %s:%d\n", rsrc->srcip, rsrc->srcport);
}
else
{
LIBNET_DEBUG("get ip from w5300 failed!\n");
}
#endif
create_transfer_task(rsrc, libnet_cb);
return (unsigned long)rsrc;
}
static void
bs_gocomics_show (Evas_Object *layout)
{
char dst[1024] = { 0 };
mod = calloc (1, sizeof(Bookstore_Service_GoComics));
/* create comic strips download destination path */
snprintf(dst, sizeof(dst), "~/.enna/%s",
GOCOMICS_PATH);
if (!ecore_file_is_dir(dst))
if(ecore_file_mkpath(dst)) printf("mkpath true\n");
mod->path = strdup (dst);
mod->url = url_new();
mod->layout = layout;
gocomics_set_comic_name();
gocomics_create_menu();
}
static int rtsp_streaming_open (stream_t *stream, int mode, void *opts,
int *file_format)
{
rtsp_ctrl * ctl;
URL_t *url;
stream->fd = -1;
mp_msg (MSGT_OPEN, MSGL_V, "STREAM_RTSP, URL: %s\n", stream->url);
stream->streaming_ctrl = streaming_ctrl_new ();
if (!stream->streaming_ctrl)
return STREAM_ERROR;
stream->streaming_ctrl->bandwidth = network_bandwidth;
url = url_new(stream->url);
stream->streaming_ctrl->url = check4proxies(url);
stream->streaming_ctrl->streaming_seek = rtsp_streaming_seek;
*file_format = DEMUXER_TYPE_RTP_NEMESI;
stream->type = STREAMTYPE_STREAM;
return STREAM_OK;
}
/* load a buffer asynchronously and launch the callback. The buffer
stays in 'loading' state while begin loaded. It is also marked
readonly. */
int load_buffer(EditBuffer *b, const char *filename,
int offset, int nolog,
void (*progress_cb)(void *opaque, int size),
void (*completion_cb)(void *opaque, int err), void *opaque)
{
URLContext *h;
BufferIOState *s;
/* cannot load a buffer if already I/Os or readonly */
if (b->flags & (BF_LOADING | BF_SAVING | BF_READONLY))
return -1;
s = malloc(sizeof(BufferIOState));
if (!s)
return -1;
b->io_state = s;
h = url_new();
if (!h) {
free(b->io_state);
b->io_state = NULL;
return -1;
}
s->handle = h;
s->saved_flags = b->flags;
s->nolog = nolog;
if (s->nolog) {
s->saved_log = b->save_log;
b->save_log = 0;
}
b->flags |= BF_LOADING | BF_READONLY;
s->handle = h;
s->progress_cb = progress_cb;
s->completion_cb = completion_cb;
s->opaque = opaque;
s->offset = offset;
printf("connect_async: '%s'\n", filename);
url_connect_async(s->handle, filename, URL_RDONLY,
load_connected_cb, b);
return 0;
}
struct url_t *url_parse(const char *url) {
struct url_t *self = url_new();
const char *p = url;
if (!(p = parse_protocol(self, p))) {
url_free(self);
return NULL;
}
self->has_port = has_port(p);
if (!(p = parse_host(self, p))) {
url_free(self);
return NULL;
}
if (!(p = parse_port(self, p))) {
url_free(self);
return NULL;
}
self->path = strdup(p);
return self;
}
static int nop_streaming_start( stream_t *stream ) {
HTTP_header_t *http_hdr = NULL;
char *next_url=NULL;
URL_t *rd_url=NULL;
int fd,ret;
if( stream==NULL ) return -1;
fd = stream->fd;
if( fd<0 ) {
fd = http_send_request( stream->streaming_ctrl->url, 0 );
if( fd<0 ) return -1;
http_hdr = http_read_response( fd );
if( http_hdr==NULL ) return -1;
switch( http_hdr->status_code ) {
case 200: // OK
mp_msg(MSGT_NETWORK,MSGL_V,"Content-Type: [%s]\n", http_get_field(http_hdr, "Content-Type") );
mp_msg(MSGT_NETWORK,MSGL_V,"Content-Length: [%s]\n", http_get_field(http_hdr, "Content-Length") );
if( http_hdr->body_size>0 ) {
if( streaming_bufferize( stream->streaming_ctrl, http_hdr->body, http_hdr->body_size )<0 ) {
http_free( http_hdr );
return -1;
}
}
break;
// Redirect
case 301: // Permanently
case 302: // Temporarily
case 303: // See Other
case 307: // Temporarily (since HTTP/1.1)
ret=-1;
next_url = http_get_field( http_hdr, "Location" );
if (next_url != NULL)
rd_url=url_new(next_url);
if (next_url != NULL && rd_url != NULL) {
mp_msg(MSGT_NETWORK,MSGL_STATUS,"Redirected: Using this url instead %s\n",next_url);
stream->streaming_ctrl->url=check4proxies(rd_url);
ret=nop_streaming_start(stream); //recursively get streaming started
} else {
mp_msg(MSGT_NETWORK,MSGL_ERR,"Redirection failed\n");
closesocket( fd );
fd = -1;
}
return ret;
break;
case 401: //Authorization required
case 403: //Forbidden
case 404: //Not found
case 500: //Server Error
default:
mp_msg(MSGT_NETWORK,MSGL_ERR,"Server returned code %d: %s\n", http_hdr->status_code, http_hdr->reason_phrase );
closesocket( fd );
fd = -1;
return -1;
break;
}
stream->fd = fd;
} else {
http_hdr = (HTTP_header_t*)stream->streaming_ctrl->data;
if( http_hdr->body_size>0 ) {
if( streaming_bufferize( stream->streaming_ctrl, http_hdr->body, http_hdr->body_size )<0 ) {
http_free( http_hdr );
stream->streaming_ctrl->data = NULL;
return -1;
}
}
}
if( http_hdr ) {
http_free( http_hdr );
stream->streaming_ctrl->data = NULL;
}
stream->streaming_ctrl->streaming_read = nop_streaming_read;
stream->streaming_ctrl->streaming_seek = nop_streaming_seek;
stream->streaming_ctrl->prebuffer_size = 64*1024; // 64 KBytes
stream->streaming_ctrl->buffering = 1;
stream->streaming_ctrl->status = streaming_playing_e;
return 0;
}
int
http_send_request( URL_t *url, off_t pos ) {
HTTP_header_t *http_hdr;
URL_t *server_url;
char str[256];
int fd = -1;
int ret;
int proxy = 0; // Boolean
http_hdr = http_new_header();
if( !strcasecmp(url->protocol, "http_proxy") ) {
proxy = 1;
server_url = url_new( (url->file)+1 );
http_set_uri( http_hdr, server_url->url );
} else {
server_url = url;
http_set_uri( http_hdr, server_url->file );
}
if (server_url->port && server_url->port != 80)
snprintf(str, 256, "Host: %s:%d", server_url->hostname, server_url->port );
else
snprintf(str, 256, "Host: %s", server_url->hostname );
http_set_field( http_hdr, str);
if (network_useragent)
{
snprintf(str, 256, "User-Agent: %s", network_useragent);
http_set_field(http_hdr, str);
}
else
http_set_field( http_hdr, "User-Agent: MPlayer/"VERSION);
if( strcasecmp(url->protocol, "noicyx") )
http_set_field(http_hdr, "Icy-MetaData: 1");
if(pos>0) {
// Extend http_send_request with possibility to do partial content retrieval
snprintf(str, 256, "Range: bytes=%"PRId64"-", (int64_t)pos);
http_set_field(http_hdr, str);
}
if (network_cookies_enabled) cookies_set( http_hdr, server_url->hostname, server_url->url );
http_set_field( http_hdr, "Connection: close");
http_add_basic_authentication( http_hdr, url->username, url->password );
if( http_build_request( http_hdr )==NULL ) {
goto err_out;
}
if( proxy ) {
if( url->port==0 ) url->port = 8080; // Default port for the proxy server
fd = connect2Server( url->hostname, url->port,1 );
url_free( server_url );
server_url = NULL;
} else {
if( server_url->port==0 ) server_url->port = 80; // Default port for the web server
fd = connect2Server( server_url->hostname, server_url->port,1 );
}
if( fd<0 ) {
goto err_out;
}
mp_msg(MSGT_NETWORK,MSGL_DBG2,"Request: [%s]\n", http_hdr->buffer );
ret = send( fd, http_hdr->buffer, http_hdr->buffer_size, 0 );
if( ret!=(int)http_hdr->buffer_size ) {
mp_msg(MSGT_NETWORK,MSGL_ERR,MSGTR_MPDEMUX_NW_ErrSendingHTTPRequest);
goto err_out;
}
http_free( http_hdr );
return fd;
err_out:
if (fd > 0) closesocket(fd);
http_free(http_hdr);
if (proxy && server_url)
url_free(server_url);
return -1;
}
static int
rtsp_streaming_start (stream_t *stream)
{
int fd;
rtsp_session_t *rtsp;
char *mrl;
char *file;
int port;
int redirected, temp;
if (!stream)
return -1;
/* counter so we don't get caught in infinite redirections */
temp = 5;
do {
redirected = 0;
fd = connect2Server (stream->streaming_ctrl->url->hostname,
port = (stream->streaming_ctrl->url->port ?
stream->streaming_ctrl->url->port :
RTSP_DEFAULT_PORT), 1);
if (fd < 0 && !stream->streaming_ctrl->url->port)
fd = connect2Server (stream->streaming_ctrl->url->hostname,
port = 7070, 1);
if (fd < 0)
return -1;
file = stream->streaming_ctrl->url->file;
if (file[0] == '/')
file++;
mrl = malloc (strlen (stream->streaming_ctrl->url->hostname)
+ strlen (file) + 16);
sprintf (mrl, "rtsp://%s:%i/%s",
stream->streaming_ctrl->url->hostname, port, file);
rtsp = rtsp_session_start (fd, &mrl, file,
stream->streaming_ctrl->url->hostname,
port, &redirected,
stream->streaming_ctrl->bandwidth,
stream->streaming_ctrl->url->username,
stream->streaming_ctrl->url->password);
if (redirected == 1)
{
url_free (stream->streaming_ctrl->url);
stream->streaming_ctrl->url = url_new (mrl);
closesocket (fd);
}
free (mrl);
temp--;
} while ((redirected != 0) && (temp > 0));
if (!rtsp)
return -1;
stream->fd = fd;
stream->streaming_ctrl->data = rtsp;
stream->streaming_ctrl->streaming_read = rtsp_streaming_read;
stream->streaming_ctrl->streaming_seek = NULL;
stream->streaming_ctrl->prebuffer_size = 128*1024; // 640 KBytes
stream->streaming_ctrl->buffering = 1;
stream->streaming_ctrl->status = streaming_playing_e;
return 0;
}
void* url_parse(const char* url)
{
size_t len;
url_t* uri;
const char *p;
uri = (url_t*)url_new();
if(!uri)
return NULL;
len = strlen(url);
p = strchr(url, '/');
if(!p)
{
url_parse_host(url, len, uri);
uri->path = strdup("/"); // default to root
}
else
{
// scheme
if(p>url && *(p-1)==':' && p[1]=='/' )
{
uri->scheme = strndup(url, p-1-url);
len -= p + 2 - url;
url = p + 2;
p = strchr(url, '/');
}
// host and port
if(!p)
{
url_parse_host(url, len, uri);
uri->path = strdup("/"); // default to root
}
else
{
// "/web/index.html"
if(p > url)
{
url_parse_host(url, p-url, uri);
url = p;
}
// path
p = strchr(url, '?');
if(!p)
{
uri->path = strdup(url);
}
else
{
uri->path = strndup(url, p-url);
// param
url_parse_param(p+1, uri);
}
}
}
return uri;
}
int http_transfer(UrlResource *rsrc, libnet_callback notify)
{
FILE *out = NULL;
Url *u = NULL;
Url *proxy_url = NULL;
Url *redir_u = NULL;
char *request = NULL;
//char *raw_header = NULL;
HttpHeader *header = NULL;
//char *len_string = NULL;
//char *new_location = NULL;
char *tmp_string = NULL;
//char buf[BUFSIZE];
int sock = -1;
ssize_t bytes_read = 0;
int msg_code = 0;
int retval = 0;
int i;
char *buf = MALLOC(BUFSIZE);
if (!buf)
{
LIBNET_DEBUG("No enough memory!\n");
return 0;
}
/* make sure we haven't recursed too much */
if ( redirect_count > REDIRECT_MAX )
{
LIBNET_DEBUG("redirection max count exceeded (looping redirect?)");
redirect_count = 0;
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
/* make sure everything's initialized to something useful */
u = rsrc->url;
if ( !u->host )
{
LIBNET_DEBUG("no host specified");
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
/* fill in proxyness */
if ( !rsrc->proxy )
{
rsrc->proxy = get_proxy("HTTP_PROXY");
}
if (( NULL == rsrc->outfile ) && (NULL == rsrc->buffer))
{
if ( u->file )
rsrc->outfile = strdup(u->file);
else
rsrc->outfile = strdup("index.html");
}
if ( !u->path )
u->path = strdup("/");
if ( !u->file )
u->file = strdup(""); /* funny looking */
if ( !u->port )
u->port = 80;
rsrc->options |= default_opts;
/* send the request to either the proxy or the remote host */
if ( rsrc->proxy )
{
proxy_url = url_new();
url_init(proxy_url, rsrc->proxy);
if ( !proxy_url->port )
proxy_url->port = 80;
if ( !proxy_url->host )
{
LIBNET_DEBUG( "bad proxy `%s'", rsrc->proxy);
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
if ( proxy_url->username )
rsrc->proxy_username = strdup(proxy_url->username);
if ( proxy_url->password )
rsrc->proxy_password = strdup(proxy_url->password);
#ifdef LIB_W5300
sock = w5300_tcp_connect(proxy_url->host, proxy_url->port, rsrc->srcip, rsrc->srcport);
#else
sock = util_tcp_connect(proxy_url->host, proxy_url->port);
#endif
if (sock < 0)
{
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
safe_free(u->path);
safe_free(u->file);
u->path = strdup("");
u->file = strdup(u->full_url);
request = get_request(rsrc);
LIBNET_DEBUG("sending request:\n%s", request);
S_WRITE(sock, request, STRLEN(request));
FREE(request);
}
else /* no proxy */
{
#ifdef LIB_W5300
sock = w5300_tcp_connect(u->host, u->port, rsrc->srcip, rsrc->srcport);
#else
sock = util_tcp_connect(u->host, u->port);
#endif
if (sock < 0)
{
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
request = get_request(rsrc);
LIBNET_DEBUG("sending request:\n%s", request);
S_WRITE(sock, request, STRLEN(request));
FREE(request);
}
if (rsrc->outfile)
{
if ((get_file_size(rsrc->outfile) > 0) && (rsrc->options & OPT_RESUME))
out = fopen(rsrc->outfile, "rb+");
else
out = fopen(rsrc->outfile, "wb");
if ( !out )
{
LIBNET_DEBUG( "opening %s: %s", rsrc->outfile, "");
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
/* check to see if it returned a HTTP 1.x response */
MEMSET(buf, '\0', 5);
#ifdef LIB_W5300
bytes_read = S_READ(sock, buf, BUFSIZE);
buf[bytes_read] = '\0';
LIBNET_DEBUG("receive respond:(%d)\n%s", bytes_read, buf);
#else
bytes_read = S_READ(sock, buf, 8);
#endif
if ( bytes_read <= 0 )
{
msg_code = -NET_ERR_HTTP_SERVER_ERROR;
goto cleanup;
}
if ( ! (buf[0] == 'H' && buf[1] == 'T'
&& buf[2] == 'T' && buf[3] == 'P') )
{
if((rsrc->options & OPT_RESUME) && rsrc->outfile_offset)
{
LIBNET_DEBUG("server does not support resume!");
msg_code = -NET_ERR_OPERATION_NOT_PERMIT;
goto cleanup;
}
//fwrite(buf, bytes_read, 1,out);
}
else
{
/* skip the header */
#ifdef LIB_W5300
buf[bytes_read] = '\0';
#else
char *raw_header1 = NULL;
buf[bytes_read] = '\0';
raw_header1 = get_raw_header(sock);
strconcat2(buf, raw_header1, NULL);
FREE(raw_header1);
LIBNET_DEBUG("receive respond:(%d)\n%s", bytes_read, buf);
#endif
header = make_http_header(buf);
/* check for redirects */
tmp_string = get_header_value("location", header);
if (buf[9] == '3' && tmp_string )
{
#if 1 //diable redirec function
redir_u = url_new();
/* make sure we still send user/password along */
redir_u->username = safe_strdup(u->username);
redir_u->password = safe_strdup(u->password);
url_init(redir_u, tmp_string);
rsrc->url = redir_u;
redirect_count++;
//retval = transfer(rsrc, notify);
transfer((UINT32)rsrc, (UINT32)notify);
rsrc->url =u;
redirect_count--;
if(redirect_count<0) redirect_count=0;
if (redir_u)
{
url_destroy(redir_u);
FREE(redir_u);
}
#endif
FREE(tmp_string);
tmp_string = NULL;
//msg_code = -NET_ERR_OPERATION_NOT_PERMIT;//we can support redirect now, remove this line.
goto cleanup;
}
if (tmp_string)
{
FREE(tmp_string);
tmp_string = NULL;
}
if (buf[9] == '4' || buf[9] == '5')
{
for (i = 0; buf[i] && buf[i] != '\n'; i++);
buf[i] = '\0';
LIBNET_DEBUG("HTTP error from server: %s\n", buf);
if( buf[9] == '4' && buf[10] == '0' && buf[11] == '4')
msg_code = -NET_ERR_FILE_NOT_FOUND;
else
msg_code = -NET_ERR_HTTP_SERVER_ERROR;
goto cleanup;
}
tmp_string = get_header_value("content-length", header);
if (tmp_string)
{
rsrc->outfile_size = (off_t )ATOI(tmp_string);
FREE(tmp_string);
tmp_string = NULL;
if(rsrc->use_pecache ==0)
{
if ((rsrc->buffer) && (rsrc->buffer_len < rsrc->outfile_size))
{
LIBNET_DEBUG("the buffer length less than the file fize (%d < %d)\n", rsrc->buffer, (int)rsrc->outfile_size);
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
}
tmp_string = get_header_value("content-range", header);
if (tmp_string)
{
FREE(tmp_string);
tmp_string = NULL;
rsrc->outfile_size += rsrc->outfile_offset;
}
if ((!rsrc->outfile_size) &&
(rsrc->options & OPT_RESUME) &&
!(rsrc->options & OPT_NORESUME)
&& rsrc->outfile_offset )
{
LIBNET_DEBUG("unable to determine remote file size");
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
if(rsrc->use_pecache ==0)
retval = dump_data(rsrc, sock, out, notify);
else
retval = dump_data_to_pecache(rsrc, sock, out, notify);
cleanup:
free_http_header(header);
//if (raw_header)
// FREE(raw_header);
if (proxy_url)
{
url_destroy(proxy_url);
FREE(proxy_url);
}
if (sock >= 0)
{
S_CLOSE(sock);
}
if (out)
fclose(out);
if (buf)
{
FREE(buf);
}
#ifndef WIN32
if (rsrc->outfile)
fs_sync(rsrc->outfile);
#endif
if (msg_code < 0 && rsrc->running)
{
notify(NET_MSG_DOWNLOAD_FINISH, (UINT32)msg_code);
libnet_abort_url_read(TRUE);//to break url_open while loop //retval!=1 means transfer fail
}
return retval;
}
int
http_send_request( URL_t *url, int64_t pos ) {
HTTP_header_t *http_hdr;
URL_t *server_url;
char str[256];
int fd = -1;
int ret;
int proxy = 0; // Boolean
http_hdr = http_new_header();
if( !strcasecmp(url->protocol, "http_proxy") ) {
proxy = 1;
server_url = url_new( (url->file)+1 );
if (!server_url) {
mp_msg(MSGT_NETWORK, MSGL_ERR, "Invalid URL '%s' to proxify\n", url->file+1);
goto err_out;
}
http_set_uri( http_hdr, server_url->noauth_url );
} else {
server_url = url;
http_set_uri( http_hdr, server_url->file );
}
if (server_url->port && server_url->port != 80)
snprintf(str, sizeof(str), "Host: %s:%d", server_url->hostname, server_url->port );
else
snprintf(str, sizeof(str), "Host: %s", server_url->hostname );
http_set_field( http_hdr, str);
if (network_useragent)
snprintf(str, sizeof(str), "User-Agent: %s", network_useragent);
else
snprintf(str, sizeof(str), "User-Agent: %s", mplayer_version);
http_set_field(http_hdr, str);
if (network_referrer) {
char *referrer = NULL;
size_t len = strlen(network_referrer) + 10;
// Check len to ensure we don't do something really bad in case of an overflow
if (len > 10)
referrer = malloc(len);
if (referrer == NULL) {
mp_msg(MSGT_NETWORK, MSGL_FATAL, MSGTR_MemAllocFailed);
} else {
snprintf(referrer, len, "Referer: %s", network_referrer);
http_set_field(http_hdr, referrer);
free(referrer);
}
}
if( strcasecmp(url->protocol, "noicyx") )
http_set_field(http_hdr, "Icy-MetaData: 1");
if(pos>0) {
// Extend http_send_request with possibility to do partial content retrieval
snprintf(str, sizeof(str), "Range: bytes=%"PRId64"-", (int64_t)pos);
http_set_field(http_hdr, str);
}
if (network_cookies_enabled) cookies_set( http_hdr, server_url->hostname, server_url->url );
if (network_http_header_fields) {
int i=0;
while (network_http_header_fields[i])
http_set_field(http_hdr, network_http_header_fields[i++]);
}
http_set_field( http_hdr, "Connection: close");
if (proxy)
http_add_basic_proxy_authentication(http_hdr, url->username, url->password);
http_add_basic_authentication(http_hdr, server_url->username, server_url->password);
if( http_build_request( http_hdr )==NULL ) {
goto err_out;
}
if( proxy ) {
if( url->port==0 ) url->port = 8080; // Default port for the proxy server
fd = connect2Server( url->hostname, url->port,1 );
url_free( server_url );
server_url = NULL;
} else {
if( server_url->port==0 ) server_url->port = 80; // Default port for the web server
fd = connect2Server( server_url->hostname, server_url->port,1 );
}
if( fd<0 ) {
goto err_out;
}
mp_msg(MSGT_NETWORK,MSGL_DBG2,"Request: [%s]\n", http_hdr->buffer );
ret = send( fd, http_hdr->buffer, http_hdr->buffer_size, DEFAULT_SEND_FLAGS );
if( ret!=(int)http_hdr->buffer_size ) {
mp_msg(MSGT_NETWORK,MSGL_ERR,MSGTR_MPDEMUX_NW_ErrSendingHTTPRequest);
goto err_out;
}
http_free( http_hdr );
return fd;
err_out:
if (fd > 0) closesocket(fd);
http_free(http_hdr);
if (proxy && server_url)
url_free(server_url);
return -1;
}
static HTTP_header_t *asf_http_request(streaming_ctrl_t *streaming_ctrl) {
HTTP_header_t *http_hdr;
URL_t *url = NULL;
URL_t *server_url = NULL;
asf_http_streaming_ctrl_t *asf_http_ctrl;
char str[250];
char *ptr;
int i, enable;
int offset_hi=0, offset_lo=0, length=0;
int asf_nb_stream=0, stream_id;
// Sanity check
if( streaming_ctrl==NULL ) return NULL;
url = streaming_ctrl->url;
asf_http_ctrl = (asf_http_streaming_ctrl_t*)streaming_ctrl->data;
if( url==NULL || asf_http_ctrl==NULL ) return NULL;
// Common header for all requests.
http_hdr = http_new_header();
http_set_field( http_hdr, "Accept: */*" );
http_set_field( http_hdr, "User-Agent: NSPlayer/4.1.0.3856" );
http_add_basic_authentication( http_hdr, url->username, url->password );
// Check if we are using a proxy
if( !strcasecmp( url->protocol, "http_proxy" ) ) {
server_url = url_new( (url->file)+1 );
if( server_url==NULL ) {
mp_msg(MSGT_NETWORK,MSGL_ERR,MSGTR_MPDEMUX_ASF_InvalidProxyURL);
http_free( http_hdr );
return NULL;
}
http_set_uri( http_hdr, server_url->url );
sprintf( str, "Host: %.220s:%d", server_url->hostname, server_url->port );
url_free( server_url );
} else {
http_set_uri( http_hdr, url->file );
sprintf( str, "Host: %.220s:%d", url->hostname, url->port );
}
http_set_field( http_hdr, str );
http_set_field( http_hdr, "Pragma: xClientGUID={c77e7400-738a-11d2-9add-0020af0a3278}" );
sprintf(str,
"Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=%u:%u,request-context=%d,max-duration=%u",
offset_hi, offset_lo, asf_http_ctrl->request, length );
http_set_field( http_hdr, str );
switch( asf_http_ctrl->streaming_type ) {
case ASF_Live_e:
case ASF_Prerecorded_e:
http_set_field( http_hdr, "Pragma: xPlayStrm=1" );
ptr = str;
ptr += sprintf( ptr, "Pragma: stream-switch-entry=");
if(asf_http_ctrl->n_audio > 0) {
for( i=0; i<asf_http_ctrl->n_audio ; i++ ) {
stream_id = asf_http_ctrl->audio_streams[i];
if(stream_id == asf_http_ctrl->audio_id) {
enable = 0;
} else {
enable = 2;
continue;
}
asf_nb_stream++;
ptr += sprintf(ptr, "ffff:%x:%d ", stream_id, enable);
}
}
if(asf_http_ctrl->n_video > 0) {
for( i=0; i<asf_http_ctrl->n_video ; i++ ) {
stream_id = asf_http_ctrl->video_streams[i];
if(stream_id == asf_http_ctrl->video_id) {
enable = 0;
} else {
enable = 2;
continue;
}
asf_nb_stream++;
ptr += sprintf(ptr, "ffff:%x:%d ", stream_id, enable);
}
}
http_set_field( http_hdr, str );
sprintf( str, "Pragma: stream-switch-count=%d", asf_nb_stream );
http_set_field( http_hdr, str );
break;
case ASF_Redirector_e:
break;
case ASF_Unknown_e:
// First request goes here.
break;
default:
mp_msg(MSGT_NETWORK,MSGL_ERR,MSGTR_MPDEMUX_ASF_UnknownASFStreamType);
}
http_set_field( http_hdr, "Connection: Close" );
http_build_request( http_hdr );
return http_hdr;
}
static pascal OSErr AppleEventHandlerProc(const AppleEvent *theAppleEvent, AppleEvent* reply, SInt32 handlerRefcon) {
OSErr err=errAEEventNotHandled, res=noErr;
AEDescList docList;
long itemsInList;
AERemoveEventHandler(kCoreEventClass, kAEOpenDocuments, NULL, FALSE);
if((res=AEGetParamDesc(theAppleEvent, keyDirectObject, typeAEList, &docList))==noErr) {
if((res=AECountItems(&docList, &itemsInList))==noErr) {
Size currentSize=0;
int valid=0,i;
char *parm=NULL;
play_tree_t *last_entry=NULL;
files=play_tree_new();
for(i=1;i<=itemsInList;++i) {
for(;;) {
OSErr e;
Size actualSize=0;
AEKeyword keywd;
DescType returnedType;
if((e=AEGetNthPtr(&docList, i, typeFileURL, &keywd, &returnedType, (Ptr)parm, currentSize, &actualSize))==noErr) {
if(actualSize>=currentSize) {
currentSize=actualSize+1;
parm=realloc(parm, currentSize);
}
else {
parm[actualSize]=0;
valid=1;
break;
}
}
else {
valid=0;
break;
}
}
if(valid) {
URL_t *url=url_new(parm);
if(url && !strcmp(url->protocol,"file") && !strcmp(url->hostname,"localhost")) {
play_tree_t *entry=play_tree_new();
url_unescape_string(url->file, url->file);
play_tree_add_file(entry, url->file);
add_entry(&files, &last_entry, entry);
}
url_free(url);
}
}
if(parm)
free(parm);
err=noErr;
}
else
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "AECountItems() error %d\n", res);
AEDisposeDesc(&docList);
}
else
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "AEGetParamDesc() error %d\n", res);
QuitApplicationEventLoop();
return err;
}
int
http_transfer(UrlResource *rsrc)
{
FILE *out = NULL;
Url *u = NULL;
Url *proxy_url = NULL;
Url *redir_u = NULL;
char *request = NULL;
char *raw_header = NULL;
HttpHeader *header = NULL;
char *len_string = NULL;
char *new_location = NULL;
char buf[BUFSIZE];
int sock = 0;
ssize_t bytes_read = 0;
int retval = 0;
int i;
/* make sure we haven't recursed too much */
if( redirect_count > REDIRECT_MAX ) {
report(ERR, "redirection max count exceeded "
"(looping redirect?)");
redirect_count = 0;
return 0;
}
/* make sure everything's initialized to something useful */
u = rsrc->url;
if( ! *(u->host) ) {
report(ERR, "no host specified");
return 0;
}
/* fill in proxyness */
if( !rsrc->proxy ) {
rsrc->proxy = get_proxy("HTTP_PROXY");
}
if( !rsrc->outfile ) {
if( u->file )
rsrc->outfile = strdup(u->file);
else
rsrc->outfile = strdup("index.html");
}
if( !u->path )
u->path = strdup("/");
if( !u->file )
u->file = strdup(""); /* funny looking */
if( !u->port )
u->port = 80;
rsrc->options |= default_opts;
/* send the request to either the proxy or the remote host */
if( rsrc->proxy ) {
proxy_url = url_new();
url_init(proxy_url, rsrc->proxy);
if( !proxy_url->port )
proxy_url->port = 80;
if( !proxy_url->host ) {
report(ERR, "bad proxy `%s'", rsrc->proxy);
return 0;
}
if( proxy_url->username )
rsrc->proxy_username = strdup(proxy_url->username);
if( proxy_url->password )
rsrc->proxy_password = strdup(proxy_url->password);
/* Prompt for proxy password if not specified */
if( proxy_url->username && !proxy_url->password ) {
char *prompt = NULL;
prompt = strconcat("Password for proxy ",
proxy_url->username, "@",
proxy_url->host, ": ", NULL);
proxy_url->password = strdup(getpass(prompt));
free(prompt);
}
if( ! (sock = tcp_connect(proxy_url->host, proxy_url->port)) )
return 0;
u->path = strdup("");
u->file = strdup(u->full_url);
request = get_request(rsrc);
write(sock, request, strlen(request));
} else /* no proxy */ {
if( ! (sock = tcp_connect(u->host, u->port)) )
return 0;
request = get_request(rsrc);
write(sock, request, strlen(request));
}
out = open_outfile(rsrc);
if( !out ) {
report(ERR, "opening %s: %s", rsrc->outfile, strerror(errno));
return 0;
}
/* check to see if it returned a HTTP 1.x response */
memset(buf, '\0', 5);
bytes_read = read(sock, buf, 8);
if( bytes_read == 0 ) {
close(sock);
return 0;
}
if( ! (buf[0] == 'H' && buf[1] == 'T'
&& buf[2] == 'T' && buf[3] == 'P') ) {
if ((rsrc->options & OPT_RESUME) &&
rsrc->outfile_offset) {
report(WARN,
"server does not support resume, "
"try again"
" with -n (no resume)");
retval = 0;
goto cleanup;
}
write(fileno(out), buf, bytes_read);
} else {
/* skip the header */
buf[bytes_read] = '\0';
raw_header = get_raw_header(sock);
raw_header = strconcat(buf, raw_header, NULL);
header = make_http_header(raw_header);
if (rsrc->options & OPT_VERBOSE) {
fwrite(raw_header, 1, strlen(raw_header), stderr);
}
/* check for redirects */
new_location = get_header_value("location", header);
if (raw_header[9] == '3' && new_location ) {
redir_u = url_new();
/* make sure we still send user/password along */
redir_u->username = safe_strdup(u->username);
redir_u->password = safe_strdup(u->password);
url_init(redir_u, new_location);
rsrc->url = redir_u;
redirect_count++;
retval = transfer(rsrc);
goto cleanup;
}
if (raw_header[9] == '4' || raw_header[9] == '5') {
for(i = 0; raw_header[i] && raw_header[i] != '\n'; i++);
raw_header[i] = '\0';
report(ERR, "HTTP error from server: %s", raw_header);
retval = 0;
goto cleanup;
}
len_string = get_header_value("content-length", header);
if (len_string)
rsrc->outfile_size = (off_t )atoi(len_string);
if (get_header_value("content-range", header))
rsrc->outfile_size += rsrc->outfile_offset;
if( (!rsrc->outfile_size) &&
(rsrc->options & OPT_RESUME) &&
!(rsrc->options & OPT_NORESUME)
&& rsrc->outfile_offset ) {
report(WARN,
"unable to determine remote file size, try again"
" with -n (no resume)");
retval = 0;
goto cleanup;
}
}
if( ! dump_data(rsrc, sock, out) )
retval = 0;
else
retval = 1;
cleanup:
free_http_header(header);
close(sock); fclose(out);
return retval;
}
