random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/filereader/HTTPReader.cpp

631 lines
14 KiB
C++
Raw Permalink Blame History

#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
Reference in New Issue View Git Blame Copy Permalink