631 lines
14 KiB
C++
631 lines
14 KiB
C++
#include "HTTPReader.h"
|
|
#include "..\Components\wac_network\wac_network_http_receiver_api.h"
|
|
#include "api__filereader.h"
|
|
#include "../nu/AutoChar.h"
|
|
#include <api/service/waservicefactory.h>
|
|
#include <api/filereader/api_readercallback.h>
|
|
#include <wchar.h>
|
|
#include <bfc/platform/strcmp.h>
|
|
#include <bfc/platform/minmax.h>
|
|
#ifdef _WIN32
|
|
#include <shlwapi.h>
|
|
#endif
|
|
|
|
#ifdef __APPLE__
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include <stdexcept>
|
|
|
|
// so we don't accidently call these CRT functions
|
|
#ifdef close
|
|
#undef close
|
|
#endif
|
|
#ifdef open
|
|
#undef open
|
|
#endif
|
|
#ifdef read
|
|
#undef read
|
|
#endif
|
|
|
|
#define config_guess_prebuffer true
|
|
#define config_buffer_size 64
|
|
#define config_prebuffer_size 24
|
|
#define config_prebuffer_min 0
|
|
#define config_allowseek true
|
|
#define config_fullseek true
|
|
#define config_seekprebuffer 1
|
|
#define config_suppressstatus false
|
|
|
|
// {C0A565DC-0CFE-405a-A27C-468B0C8A3A5C}
|
|
static const GUID internetConfigGroupGUID =
|
|
{
|
|
0xc0a565dc, 0xcfe, 0x405a, { 0xa2, 0x7c, 0x46, 0x8b, 0xc, 0x8a, 0x3a, 0x5c }
|
|
};
|
|
|
|
class HttpReader
|
|
{
|
|
public:
|
|
HttpReader(const char *url, uint64_t start_offset = 0, uint64_t total_len = 0, int is_seek = 0);
|
|
~HttpReader();
|
|
|
|
int connect();
|
|
int read(int8_t *buffer, int length);
|
|
|
|
void abort() { killswitch = 1; }
|
|
|
|
int bytesAvailable();
|
|
|
|
uint64_t getContentLength()
|
|
{
|
|
if (m_contentlength)
|
|
return m_contentlength;
|
|
|
|
return -1;
|
|
}
|
|
|
|
int canSeek()
|
|
{
|
|
return (m_contentlength &&
|
|
/* JF> this is correct but not as compatible: m_accept_ranges && */
|
|
!m_meta_interval);
|
|
}
|
|
|
|
uint64_t getPos() { return m_contentpos; }
|
|
|
|
const char *getHeader( const char *header ) { return httpGetter->getheader( (char *)header ); }
|
|
|
|
void setMetaCB( api_readercallback *cb ) { metacb = cb; }
|
|
|
|
//static BOOL CALLBACK httpDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
private:
|
|
api_httpreceiver *httpGetter = NULL;
|
|
api_dns *dns = NULL;
|
|
|
|
char *m_AllHeaders;
|
|
|
|
int buffer_size;
|
|
int prebuffer_size, prebuffer_min;
|
|
int need_prebuffer;
|
|
uint64_t m_contentlength, m_contentpos;
|
|
int m_accept_ranges;
|
|
|
|
int proxy_enabled;
|
|
char *proxy;
|
|
|
|
int killswitch = -1;
|
|
|
|
int m_meta_init, m_meta_interval, m_meta_pos, m_meta_size, m_meta_buf_pos;
|
|
char m_meta_buf[4096];
|
|
|
|
api_readercallback *metacb;
|
|
|
|
int guessed_prebuffer_size;
|
|
|
|
char lpinfo[256];
|
|
char force_lpinfo[256];
|
|
char *dlg_realm;
|
|
char *m_url;
|
|
};
|
|
|
|
|
|
HttpReader::HttpReader( const char *url, uint64_t start_offset, uint64_t total_len, int is_seek )
|
|
{
|
|
m_accept_ranges = 0;
|
|
buffer_size = (config_buffer_size * 1024);
|
|
prebuffer_size = (config_prebuffer_size * 1024);
|
|
prebuffer_min = (config_prebuffer_min * 1024);
|
|
guessed_prebuffer_size = !config_guess_prebuffer;
|
|
|
|
if (is_seek)
|
|
{
|
|
prebuffer_min = prebuffer_size = config_seekprebuffer;
|
|
guessed_prebuffer_size = 1;
|
|
}
|
|
|
|
proxy_enabled = 0;
|
|
killswitch = 0;
|
|
need_prebuffer = 0;
|
|
m_contentlength = total_len;
|
|
m_contentpos = start_offset;
|
|
m_meta_init = m_meta_interval = m_meta_pos = m_meta_size = m_meta_buf_pos = 0;
|
|
m_meta_buf[0] = 0;
|
|
metacb = NULL;
|
|
force_lpinfo[0] = 0;
|
|
lpinfo[0] = 0;
|
|
|
|
m_url = _strdup(url);
|
|
|
|
int use_proxy = 1;
|
|
bool proxy80 = AGAVE_API_CONFIG->GetBool(internetConfigGroupGUID, L"proxy80", false);
|
|
if (proxy80 && strstr(url, ":") && (!strstr(url, ":80/") && strstr(url, ":80") != (url + strlen(url) - 3)))
|
|
use_proxy = 0;
|
|
|
|
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid( httpreceiverGUID );
|
|
if (sf)
|
|
httpGetter = (api_httpreceiver *)sf->getInterface();
|
|
|
|
const wchar_t *proxy = AGAVE_API_CONFIG->GetString(internetConfigGroupGUID, L"proxy", 0);
|
|
|
|
httpGetter->open(API_DNS_AUTODNS, buffer_size, (use_proxy && proxy && proxy[0]) ? (char *)AutoChar(proxy) : NULL);
|
|
httpGetter->addheader("Accept:*/*");
|
|
if (!_strnicmp(url, "uvox://", 7))
|
|
{
|
|
httpGetter->addheader("User-Agent: ultravox/2.0");
|
|
}
|
|
else
|
|
{
|
|
httpGetter->AddHeaderValue("User-Agent", AutoChar(WASABI_API_APP->main_getVersionString()));
|
|
}
|
|
|
|
if (start_offset > 0)
|
|
{
|
|
char temp[128];
|
|
sprintf(temp, "Range: bytes=%d-", (int)start_offset);
|
|
httpGetter->addheader(temp);
|
|
}
|
|
else
|
|
httpGetter->addheader("Icy-Metadata:1");
|
|
|
|
httpGetter->connect((char *)m_url, start_offset > 0);
|
|
HttpReader::connect();
|
|
HttpReader::read(0, 0);
|
|
|
|
//if (!config_suppressstatus) api->core_setCustomMsg(0, StringPrintf("[Connecting] %s",url));
|
|
}
|
|
|
|
HttpReader::~HttpReader()
|
|
{
|
|
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid( httpreceiverGUID );
|
|
if ( sf )
|
|
sf->releaseInterface( httpGetter );
|
|
}
|
|
|
|
// TODO: BOOL CALLBACK HttpReader::httpDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
|
|
|
|
int HttpReader::connect()
|
|
{
|
|
try
|
|
{
|
|
while ( killswitch >= 0 && httpGetter->run() == 0 && httpGetter->get_status() == 0 )
|
|
{
|
|
#ifdef _WIN32
|
|
//Sleep( 50 );
|
|
#else
|
|
usleep( 50000 );
|
|
#endif
|
|
}
|
|
if ( killswitch )
|
|
return 0;
|
|
|
|
if ( httpGetter->get_status() == -1 )
|
|
{
|
|
int code = httpGetter->getreplycode();
|
|
if ( code == 401 )
|
|
{
|
|
/* TODO:
|
|
// authorization required
|
|
JNL_Connection *m_connection=httpGetter->get_con();
|
|
char str[4096];
|
|
while (m_connection->recv_lines_available() > 0) {
|
|
char *wwwa="WWW-Authenticate:";
|
|
m_connection->recv_line(str,4096);
|
|
if (!str[0]) break;
|
|
if (!_strnicmp(str,wwwa,strlen(wwwa))) {
|
|
char *s2="Basic realm=\"";
|
|
char *p=str+strlen(wwwa); while (p && *p== ' ') p++;
|
|
if (!_strnicmp(p,s2,strlen(s2))) {
|
|
p+=strlen(s2);
|
|
if (strstr(p,"\"")) {
|
|
strstr(p,"\"")[0]=0;
|
|
if (*p) {
|
|
if(force_lpinfo[0]) {
|
|
force_lpinfo[0]=0; // invalid l/p
|
|
} else WASABI_API_CONFIG->getStringPrivate(StringPrintf("HTTP-AUTH/%s",p),force_lpinfo,sizeof(force_lpinfo),"");
|
|
if (!force_lpinfo[0] || lpinfo[0]) {
|
|
dlg_realm = p;
|
|
api->pushModalWnd();
|
|
RootWnd *pr=api->main_getRootWnd();
|
|
while(pr->getParent()) pr=pr->getParent();
|
|
if (!DialogBoxParam(the->gethInstance(),MAKEINTRESOURCE(IDD_HTTPAUTH),pr->gethWnd(),httpDlgProc,(long)this)) {
|
|
force_lpinfo[0]=0;
|
|
} else {
|
|
WASABI_API_CONFIG->setStringPrivate(StringPrintf("HTTP-AUTH/%s",p),force_lpinfo);
|
|
}
|
|
api->popModalWnd();
|
|
}
|
|
if (force_lpinfo[0]) {
|
|
const char *p=STRSTR(m_url,"http://");
|
|
if(p) {
|
|
p+=7;
|
|
StringPrintf tmp("http://%s@%s",force_lpinfo,p);
|
|
httpGetter->connect((char *)tmp.getValue());
|
|
return connect(); // recursive city
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}*/
|
|
}
|
|
// TODO: api->core_setCustomMsg(0, StringPrintf("HTTP: can't connect (%i)",code));
|
|
return 0;
|
|
}
|
|
|
|
if ( httpGetter->getreplycode() < 200 || httpGetter->getreplycode() > 299 )
|
|
{
|
|
// TODO: api->core_setCustomMsg(0, StringPrintf("HTTP: returned %i",httpGetter->getreplycode()));
|
|
return 0;
|
|
}
|
|
|
|
need_prebuffer = 1;
|
|
}
|
|
catch ( const std::exception &e )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
return 1;
|
|
}
|
|
|
|
int HttpReader::bytesAvailable()
|
|
{
|
|
int code = httpGetter->run();
|
|
int ba = httpGetter->bytes_available();
|
|
|
|
if ( !ba && code )
|
|
return -1;
|
|
|
|
return ba;
|
|
}
|
|
|
|
int HttpReader::read(int8_t *buffer, int length)
|
|
{
|
|
if (!httpGetter->GetConnection())
|
|
return 0;
|
|
|
|
if ( httpGetter->GetConnection()->get_state() == CONNECTION_STATE_CONNECTED && httpGetter->bytes_available() < prebuffer_min )
|
|
need_prebuffer = 1;
|
|
|
|
if (need_prebuffer)
|
|
{
|
|
need_prebuffer = 0;
|
|
// TODO: if (!config_suppressstatus) api->core_setCustomMsg(0, "Prebuffering ...");
|
|
|
|
if (!guessed_prebuffer_size)
|
|
{
|
|
// wait for headers
|
|
int s;
|
|
do
|
|
{
|
|
s = httpGetter->run();
|
|
}
|
|
while (s == 0 && httpGetter->get_status() != 2);
|
|
|
|
// calculate the needed prebuffer size if it's a shoutcast stream
|
|
const char *icybr;
|
|
if (icybr = httpGetter->getheader("icy-br"))
|
|
{
|
|
prebuffer_size = (atoi(icybr) / 8) * 4096;
|
|
prebuffer_min = (atoi(icybr) / 8) * 1024;
|
|
|
|
if (prebuffer_size > buffer_size)
|
|
prebuffer_size = buffer_size;
|
|
}
|
|
|
|
guessed_prebuffer_size = 1;
|
|
}
|
|
|
|
int last_pre = -1;
|
|
while (httpGetter->bytes_available() < prebuffer_size && !killswitch)
|
|
{
|
|
int s = httpGetter->run();
|
|
// JNL_Connection::state s = getter->get_state();
|
|
// if (s == JNL_Connection::STATE_ERROR || s == JNL_Connection::STATE_CLOSED) break;
|
|
if (s == -1 || s == 1) break;
|
|
#ifdef _WIN32
|
|
Sleep(50);
|
|
#else
|
|
usleep(50000);
|
|
#endif
|
|
if (last_pre != httpGetter->bytes_available() && !killswitch)
|
|
{
|
|
// TODO: if (!config_suppressstatus) api->core_setCustomMsg(0, StringPrintf(0, "Prebuffering : %i/%i bytes",httpGetter->bytes_available(),prebuffer_size));
|
|
}
|
|
}
|
|
|
|
// if (!killswitch)
|
|
// {
|
|
//// TODO: if (!config_suppressstatus) api->core_setCustomMsg(0, "Prebuffering done.");
|
|
// }
|
|
}
|
|
|
|
if (killswitch) return 0;
|
|
|
|
// metadata filtering
|
|
if ( !m_meta_init )
|
|
{
|
|
const char *v;
|
|
if ( v = httpGetter->getheader( "icy-metaint:" ) )
|
|
m_meta_interval = atoi( v );
|
|
|
|
if ( !m_contentlength )
|
|
{
|
|
if ( v = httpGetter->getheader( "content-length:" ) )
|
|
m_contentlength = _strtoui64( v, NULL, 10 );//atoi(v);
|
|
}
|
|
|
|
v = httpGetter->getheader( "accept-ranges:" );
|
|
if ( v && strcasestr( v, "bytes" ) )
|
|
m_accept_ranges = 1;
|
|
|
|
m_meta_init = 1;
|
|
}
|
|
|
|
int error = 0, recvBytes = 0;
|
|
while (length && !error && !killswitch)
|
|
{
|
|
int code = httpGetter->run();
|
|
|
|
if (code != 0)
|
|
error = 1;
|
|
|
|
// old metadata parsing
|
|
/*if (httpGetter->bytes_available()>0) {
|
|
int l=httpGetter->get_bytes(buffer,length);
|
|
|
|
// metadata stuff
|
|
if (m_meta_interval) {
|
|
int x=l;
|
|
unsigned char *buf=(unsigned char *)buffer;
|
|
if (m_meta_size)// already in meta block
|
|
{
|
|
int len=MIN(x,m_meta_size-m_meta_buf_pos);
|
|
|
|
MEMCPY(m_meta_buf+m_meta_buf_pos,buf,len);
|
|
m_meta_buf_pos+=len;
|
|
|
|
if (m_meta_buf_pos==m_meta_size)
|
|
{
|
|
if(metacb) metacb->metaDataReader_onData(m_meta_buf,m_meta_size);
|
|
m_meta_buf_pos=0;
|
|
m_meta_size=0;
|
|
m_meta_pos=0;
|
|
}
|
|
|
|
x-=len;
|
|
if (x) MEMCPY(buf,buf+len,x);
|
|
}
|
|
else if (m_meta_pos+x > m_meta_interval) // block contains meta data somewhere in it, and we're not alreayd reading a block
|
|
{
|
|
int start_offs=m_meta_interval-m_meta_pos;
|
|
int len;
|
|
m_meta_size=((unsigned char *)buf)[start_offs]*16;
|
|
|
|
len=MIN(x-start_offs-1,m_meta_size);
|
|
|
|
if (len) MEMCPY(m_meta_buf,buf+start_offs+1,len);
|
|
m_meta_buf_pos=len;
|
|
|
|
if (m_meta_buf_pos==m_meta_size) // full read of metadata successful
|
|
{
|
|
x-=m_meta_size+1;
|
|
if (x > start_offs) MEMCPY(buf+start_offs,buf+start_offs+1+m_meta_size,x-start_offs);
|
|
if(metacb) metacb->metaDataReader_onData(m_meta_buf,m_meta_size);
|
|
m_meta_buf_pos=0;
|
|
m_meta_pos=-start_offs;
|
|
m_meta_size=0;
|
|
}
|
|
else
|
|
{
|
|
x=start_offs; // otherwise, there's only the first block of data
|
|
}
|
|
}
|
|
if (x > 0)
|
|
{
|
|
m_meta_pos+=x;
|
|
}
|
|
l=x;
|
|
}
|
|
|
|
length-=l;
|
|
buffer+=l;
|
|
recvBytes+=l;
|
|
} else Sleep(50);*/
|
|
|
|
while (1)
|
|
{
|
|
int len = httpGetter->bytes_available();
|
|
if (m_meta_interval && m_meta_pos >= m_meta_interval)
|
|
{
|
|
unsigned char b;
|
|
if (len > 0 && httpGetter->peek_bytes((char*)&b, 1) && len > (b << 4))
|
|
{
|
|
char metabuf[4096];
|
|
httpGetter->get_bytes(metabuf, 1);
|
|
httpGetter->get_bytes(metabuf, b << 4);
|
|
if (metacb) metacb->metaDataReader_onData(metabuf, b << 4);
|
|
//stream_metabytes_read+=(b<<4)+1;
|
|
m_meta_pos = 0;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
len = MIN(length, len);
|
|
if (m_meta_interval)
|
|
len = MIN(m_meta_interval - m_meta_pos, len);
|
|
|
|
if (len > 0)
|
|
{
|
|
len = httpGetter->get_bytes((char*)buffer, len);
|
|
m_meta_pos += len;
|
|
//stream_bytes_read+=len;
|
|
length -= len;
|
|
buffer += len;
|
|
recvBytes += len;
|
|
}
|
|
else
|
|
{
|
|
#ifdef _WIN32
|
|
Sleep(50);
|
|
#else
|
|
usleep(50000);
|
|
#endif
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* int s=httpGetter->get_con()->get_state();
|
|
if(code==0) {*/
|
|
/* char tmp[512];
|
|
wsprintf(tmp,"[Connected] Retrieving list (%i bytes)", recvBytes);
|
|
api->status_setText(tmp);*/
|
|
// } else error=1;
|
|
}
|
|
|
|
m_contentpos += recvBytes;
|
|
|
|
return recvBytes;
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
int HTTPReader::isMine(const wchar_t *filename, int mode)
|
|
{
|
|
if (!_wcsnicmp(filename, L"http://", 7) ||
|
|
!_wcsnicmp(filename, L"https://", 8) ||
|
|
!_wcsnicmp(filename, L"icy://", 6) ||
|
|
!_wcsnicmp(filename, L"sc://", 5) ||
|
|
!_wcsnicmp(filename, L"uvox://", 7)) return 1;
|
|
return 0;
|
|
}
|
|
|
|
int HTTPReader::open( const wchar_t *filename, int mode )
|
|
{
|
|
if ( !isMine( filename, mode ) )
|
|
return 0;
|
|
|
|
m_filename = _strdup( AutoChar( filename ) );
|
|
reader = new HttpReader( m_filename );
|
|
|
|
return 1;
|
|
}
|
|
|
|
uint64_t HTTPReader::bytesAvailable( uint64_t requested )
|
|
{
|
|
int v = reader ? reader->bytesAvailable() : 0;
|
|
if ( v > requested )
|
|
return requested;
|
|
|
|
return v;
|
|
}
|
|
|
|
size_t HTTPReader::read( int8_t *buffer, size_t length )
|
|
{
|
|
if ( !reader )
|
|
return 0;
|
|
|
|
if ( !hasConnected )
|
|
{
|
|
int res = reader->connect();
|
|
if ( !res )
|
|
return 0;
|
|
|
|
hasConnected = 1;
|
|
}
|
|
|
|
return reader->read( buffer, (int)length );
|
|
}
|
|
|
|
void HTTPReader::close()
|
|
{
|
|
delete reader;
|
|
reader = NULL;
|
|
}
|
|
|
|
void HTTPReader::abort()
|
|
{
|
|
if ( reader )
|
|
reader->abort();
|
|
}
|
|
|
|
uint64_t HTTPReader::getLength()
|
|
{
|
|
return reader ? reader->getContentLength() : -1;
|
|
}
|
|
|
|
uint64_t HTTPReader::getPos()
|
|
{
|
|
return reader ? reader->getPos() : 0;
|
|
}
|
|
|
|
int HTTPReader::canSeek()
|
|
{
|
|
return ( config_allowseek && reader && reader->canSeek() ) ? ( config_fullseek ? 1 : -1 ) : 0;
|
|
}
|
|
|
|
int HTTPReader::seek( uint64_t position )
|
|
{
|
|
if ( reader && reader->canSeek() && config_allowseek )
|
|
{
|
|
if ( position == getPos() ) return 0;
|
|
hasConnected = 0;
|
|
uint64_t cl = reader->getContentLength();
|
|
delete( (HttpReader *)reader );
|
|
reader = new HttpReader( m_filename, position, cl, 1 );
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int HTTPReader::hasHeaders()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
const char *HTTPReader::getHeader( const char *header )
|
|
{
|
|
return reader ? reader->getHeader( header ) : NULL;
|
|
}
|
|
|
|
void HTTPReader::setMetaDataCallback( api_readercallback *cb )
|
|
{
|
|
if ( reader )
|
|
reader->setMetaCB( cb );
|
|
}
|
|
|
|
#define CBCLASS HTTPReader
|
|
START_DISPATCH;
|
|
CB(ISMINE, isMine);
|
|
CB(OPEN, open);
|
|
CB(READ, read);
|
|
CB(WRITE, write);
|
|
VCB(CLOSE, close);
|
|
VCB(ABORT, abort);
|
|
CB(GETLENGTH, getLength);
|
|
CB(GETPOS, getPos);
|
|
CB(CANSEEK, canSeek);
|
|
CB(SEEK, seek);
|
|
CB(HASHEADERS, hasHeaders);
|
|
CB(GETHEADER, getHeader);
|
|
CB(EXISTS, exists);
|
|
// CB(REMOVE,remove);
|
|
// CB(REMOVEUNDOABLE,removeUndoable);
|
|
// CB(MOVE,move);
|
|
CB(BYTESAVAILABLE, bytesAvailable);
|
|
VCB(SETMETADATACALLBACK, setMetaDataCallback);
|
|
CB(CANPREFETCH, canPrefetch);
|
|
// CB(CANSETEOF, canSetEOF);
|
|
// CB(SETEOF, setEOF);
|
|
END_DISPATCH;
|
|
#undef CBCLASS
|
|
|