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

846 lines
18 KiB
C++
Raw Blame History

/*
** JNetLib
** Copyright (C) 2000-2007 Nullsoft, Inc.
** Author: Justin Frankel
** File: httpget.cpp - JNL HTTP GET implementation
** License: see jnetlib.h
*/
#include "netinc.h"
#include "util.h"
#include "httpget.h"
#include "foundation/error.h"
#ifdef USE_SSL
#include "sslconnection.h"
#endif
#include <stdio.h>
#define STRSAFE_NO_DEPRECATE
#include "nu/strsafe.h"
#include "nu/AutoLock.h"
char *JNL_HTTPGet::g_proxy = 0;
static nu::LockGuard proxy_guard;
char *JNL_HTTPGet::get_proxy()
{
nu::AutoLock auto_lock( proxy_guard );
if ( g_proxy )
return _strdup( g_proxy );
else
return 0;
}
void JNL_HTTPGet::set_proxy( const char *proxy )
{
nu::AutoLock auto_lock( proxy_guard );
free( g_proxy );
if ( proxy )
g_proxy = _strdup( proxy );
else
g_proxy = 0;
}
JNL_HTTPGet::JNL_HTTPGet( size_t recvbufsize, size_t sendbufsize )
{
persistent = false;
accept_all_reply_codes = false;
zlibStream = 0;
allowCompression = false;
m_dns = JNL_AUTODNS;
m_con = NULL;
m_http_proxylpinfo = 0;
m_http_proxyhost = 0;
m_http_proxyport = 0;
m_sendbufsize = sendbufsize;
m_sendheaders = NULL;
reinit();
m_recvbufsize = recvbufsize;
char *p = get_proxy();
if ( p )
{
char *r = NULL;
do_parse_url( p, &m_http_proxyhost, &m_http_proxyport, &r, &m_http_proxylpinfo );
free( r );
free( p );
}
}
JNL_HTTPGet::~JNL_HTTPGet()
{
deinit();
free( m_sendheaders );
free( m_http_proxylpinfo );
free( m_http_proxyhost );
}
void JNL_HTTPGet::reinit()
{
m_errstr = 0;
m_recvheaders = NULL;
m_recvheaders_size = 0;
m_http_state = 0;
m_http_port = 0;
m_http_url = 0;
m_reply = 0;
m_http_host = m_http_lpinfo = m_http_request = NULL;
}
void JNL_HTTPGet::deinit( bool full )
{
if ( !persistent || full || ( m_con && m_con->get_state() == JNL_Connection::STATE_ERROR ) )
{
delete m_con;
m_con = NULL;
}
free( m_recvheaders );
free( m_http_url );
free( m_http_host );
free( m_http_lpinfo );
free( m_http_request );
free( m_errstr );
free( m_reply );
if ( zlibStream )
inflateEnd( zlibStream );
free( zlibStream );
zlibStream = 0;
reinit();
}
void JNL_HTTPGet::set_sendbufsize(size_t sendbufsize)
{
m_sendbufsize = sendbufsize;
}
int JNL_HTTPGet::set_recv_buffer_size( size_t new_buffer_size )
{
if ( m_con )
{
int ret = m_con->set_recv_buffer_size( new_buffer_size );
if ( ret == NErr_NoAction )// this will get returned if new_buffer_size is smaller than existing.
return NErr_Success;
else if ( ret != NErr_Success )
return ret;
}
m_recvbufsize = new_buffer_size;
return NErr_Success;
}
void JNL_HTTPGet::addheader( const char *header )
{
if ( strstr( header, "\r" ) || strstr( header, "\n" ) )
return;
if ( !m_sendheaders )
{
size_t len = strlen( header ) + 3;
m_sendheaders = (char *)malloc( len );
if ( m_sendheaders )
{
char *itr = m_sendheaders;
StringCchCopyExA( itr, len, header, &itr, &len, 0 );
StringCchCatExA( itr, len, "\r\n", &itr, &len, 0 );
}
}
else
{
size_t len = strlen( header ) + strlen( m_sendheaders ) + 1 + 2;
char *t = (char *)malloc( len );
if ( t )
{
char *newHeaders = t;
StringCchCopyExA( t, len, m_sendheaders, &t, &len, 0 );
StringCchCatExA( t, len, header, &t, &len, 0 );
StringCchCatExA( t, len, "\r\n", &t, &len, 0 );
free( m_sendheaders );
m_sendheaders = newHeaders;
}
}
}
void JNL_HTTPGet::addheadervalue( const char *header, const char *value )
{
size_t additional = strlen( header ) + 2 + strlen( value ) + 2 + 1;
if ( !m_sendheaders )
{
m_sendheaders = (char *)malloc( additional );
if ( m_sendheaders )
{
char *p = m_sendheaders;
StringCchCopyExA( p, additional, header, &p, &additional, 0 );
StringCchCatExA( p, additional, ": ", &p, &additional, 0 );
StringCchCatExA( p, additional, value, &p, &additional, 0 );
StringCchCatExA( p, additional, "\r\n", &p, &additional, 0 );
}
}
else
{
size_t alloc_len = strlen( m_sendheaders ) + additional;
char *t = (char *)malloc( alloc_len );
if ( t )
{
char *p = t;
StringCchCopyExA( p, alloc_len, m_sendheaders, &p, &alloc_len, 0 );
StringCchCatExA( p, alloc_len, header, &p, &alloc_len, 0 );
StringCchCatExA( p, alloc_len, ": ", &p, &alloc_len, 0 );
StringCchCatExA( p, alloc_len, value, &p, &alloc_len, 0 );
StringCchCatExA( p, alloc_len, "\r\n", &p, &alloc_len, 0 );
free( m_sendheaders );
m_sendheaders = t;
}
}
}
void JNL_HTTPGet::do_encode_mimestr( char *in, char *out )
{
char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int shift = 0;
int accum = 0;
while ( in && *in )
{
if ( *in )
{
accum <<= 8;
shift += 8;
accum |= *in++;
}
while ( shift >= 6 )
{
shift -= 6;
*out++ = alphabet[ ( accum >> shift ) & 0x3F ];
}
}
if ( shift == 4 )
{
*out++ = alphabet[ ( accum & 0xF ) << 2 ];
*out++ = '=';
}
else if ( shift == 2 )
{
*out++ = alphabet[ ( accum & 0x3 ) << 4 ];
*out++ = '=';
*out++ = '=';
}
*out++ = 0;
}
void JNL_HTTPGet::connect( const char *url, int ver, const char *requestmethod )
{
deinit( false );
m_http_url = _strdup( url );
do_parse_url( m_http_url, &m_http_host, &m_http_port, &m_http_request, &m_http_lpinfo );
if ( !m_http_host || !m_http_host[ 0 ] || !m_http_port )
{
m_http_state = -1;
seterrstr( "invalid URL" );
return;
}
size_t sendbufferlen = 0;
if ( !m_http_proxyhost || !m_http_proxyhost[ 0 ] )
sendbufferlen += strlen( requestmethod ) + 1 /* GET */ + strlen( m_http_request ) + 9 /* HTTP/1.0 */ + 2;
else
{
sendbufferlen += strlen( requestmethod ) + 1 /* GET */ + strlen( m_http_url ) + 9 /* HTTP/1.0 */ + 2;
if ( m_http_proxylpinfo && m_http_proxylpinfo[ 0 ] )
sendbufferlen += 58 + strlen( m_http_proxylpinfo ) * 2; // being safe here
}
sendbufferlen += 5 /* Host: */ + strlen( m_http_host ) + 2;
if ( m_http_port != 80 )
sendbufferlen += 6;
if ( m_http_lpinfo && m_http_lpinfo[ 0 ] )
sendbufferlen += 46 + strlen( m_http_lpinfo ) * 2; // being safe here
if ( m_sendheaders )
sendbufferlen += strlen( m_sendheaders );
size_t strLen = sendbufferlen + 1024;
char *str = (char *)calloc( strLen, sizeof( char ) );
char *connectString = str;
if ( !str )
{
seterrstr( "error allocating memory" );
m_http_state = -1;
}
if ( !m_http_proxyhost || !m_http_proxyhost[ 0 ] )
{
StringCchPrintfExA( str, strLen, &str, &strLen, 0, "%s %s HTTP/1.%d\r\n", requestmethod, m_http_request, ver % 10 );
}
else
{
char *myp = NULL;
if ( strncasecmp( m_http_url, "uvox://", 7 ) == 0 )
{
myp = m_http_url + 7;
StringCchPrintfExA( str, strLen, &str, &strLen, 0, "%s http://%s HTTP/1.%d\r\n", requestmethod, myp, ver % 10 );
}
else if ( strncasecmp( m_http_url, "unsv://", 7 ) == 0 )
{
myp = m_http_url + 7;
StringCchPrintfExA( str, strLen, &str, &strLen, 0, "%s http://%s HTTP/1.%d\r\n", requestmethod, myp, ver % 10 );
}
else if ( strncasecmp( m_http_url, "uasf://", 7 ) == 0 )
{
myp = m_http_url + 7;
StringCchPrintfExA( str, strLen, &str, &strLen, 0, "%s http://%s HTTP/1.%d\r\n", requestmethod, myp, ver % 10 );
}
else
StringCchPrintfExA( str, strLen, &str, &strLen, 0, "%s %s HTTP/1.%d\r\n", requestmethod, m_http_url, ver % 10 );
}
if ( m_http_port == 80 )
StringCchPrintfExA( str, strLen, &str, &strLen, 0, "Host: %s\r\n", m_http_host );
else
StringCchPrintfExA( str, strLen, &str, &strLen, 0, "Host: %s:%d\r\n", m_http_host, m_http_port );
if ( m_http_lpinfo && m_http_lpinfo[ 0 ] )
{
StringCchCatExA( str, strLen, "Authorization: Basic ", &str, &strLen, 0 );
do_encode_mimestr( m_http_lpinfo, str );
StringCchCatExA( str, strLen, "\r\n", &str, &strLen, 0 );
}
if ( m_http_proxylpinfo && m_http_proxylpinfo[ 0 ] )
{
StringCchCatExA( str, strLen, "Proxy-Authorization: Basic ", &str, &strLen, 0 );
do_encode_mimestr( m_http_proxylpinfo, str );
StringCchCatExA( str, strLen, "\r\n", &str, &strLen, 0 );
}
if ( allowCompression )
StringCchCatExA( str, strLen, "Accept-Encoding: gzip\r\n", &str, &strLen, 0 );
if ( m_sendheaders )
StringCchCatExA( str, strLen, m_sendheaders, &str, &strLen, 0 );
StringCchCatExA( str, strLen, "\r\n", &str, &strLen, 0 );
int a = (int)m_recvbufsize;
if ( a < 4096 )
a = 4096;
if ( !m_con )
{
//m_con=new JNL_Connection(m_dns,strlen(str)+4,a);
/*
** Joshua Teitelbaum delta 1/15/2006
*/
#ifdef USE_SSL
/*
** Joshua Teitelbaum 1/27/2006
** Check for secure
*/
if ( !_strnicmp( m_http_url, "https:", strlen( "https:" ) ) )
{
size_t send_buffer_size = strlen( connectString ) + 4;
if ( send_buffer_size < 8192 )
send_buffer_size = 8192;
send_buffer_size += m_sendbufsize;
if ( m_sendbufsize == 0 && !strcmp( requestmethod, "POST" ) )
send_buffer_size += 8192; // some extra room for posting data if it wasn't explicitly defined
m_con = new JNL_SSL_Connection( NULL, m_dns, send_buffer_size, a );
}
else
{
#endif
size_t send_buffer_size = strlen( connectString ) + 4 + m_sendbufsize;
if ( m_sendbufsize == 0 && !strcmp( requestmethod, "POST" ) )
send_buffer_size += 8192; // some extra room for posting data if it wasn't explicitly defined
m_con = new JNL_Connection( m_dns, send_buffer_size, a );
#ifdef USE_SSL
}
#endif
if ( m_con )
{
if ( !m_http_proxyhost || !m_http_proxyhost[ 0 ] )
m_con->connect( m_http_host, m_http_port );
else
m_con->connect( m_http_proxyhost, m_http_proxyport );
m_con->send_string( connectString );
}
else
{
m_http_state = -1;
seterrstr( "could not create connection object" );
}
}
else
{
m_con->reuse();
m_con->send_string( connectString );
}
free(connectString);
}
void JNL_HTTPGet::do_parse_url( const char *url, char **host, unsigned short *port, char **req, char **lp )
{
char *l_port = 0;
JNL::parse_url( url, &l_port, host, port, req, lp );
if ( !*port )
{
if ( l_port )
{
addrinfo *res;
addrinfo hints;
memset( &hints, 0, sizeof( hints ) );
hints.ai_family = PF_UNSPEC;
hints.ai_flags = 0;
hints.ai_socktype = SOCK_STREAM;
if ( getaddrinfo( 0, l_port, &hints, &res ) == 0 )
{
if ( res->ai_family == AF_INET )
*port = htons( ( (sockaddr_in *)res->ai_addr )->sin_port );
else if ( res->ai_family == AF_INET6 )
*port = htons( ( (sockaddr_in6 *)res->ai_addr )->sin6_port );
else // wtf?
*port = 80;
}
else
*port = 80;
}
else
*port = 80;
}
if ( l_port )
free( l_port );
if ( !*req )
*req = _strdup( "/" );
}
const char *JNL_HTTPGet::getallheaders()
{
// double null terminated, null delimited list
if (m_recvheaders)
return m_recvheaders;
else
return "\0\0";
}
const char *JNL_HTTPGet::getheader( const char *headername )
{
char *ret = NULL;
if ( headername[ 0 ] == 0 || !m_recvheaders )
return NULL;
size_t headername_size = strlen( headername );
char *buf = (char *)malloc( headername_size + 2 );
#ifdef _WIN32
StringCchCopyA( buf, headername_size + 2, headername );
#elif defined(__APPLE__)
strlcpy( buf, headername, headername_size + 2 );
#else
strncpy( buf, headername, headername_size + 1 );
buf[ headername_size + 1 ] = 0;
#endif
if ( buf[ headername_size - 1 ] != ':' )
{
buf[ headername_size++ ] = ':';
buf[ headername_size ] = 0;
}
char *p = m_recvheaders;
while ( p && *p )
{
if ( !strncasecmp( buf, p, headername_size ) )
{
ret = p + headername_size;
while ( ret && *ret && *ret == ' ' )
ret++;
break;
}
p += strlen( p ) + 1;
}
free( buf );
return ret;
}
int JNL_HTTPGet::run()
{
int cnt = 0;
if ( m_http_state == -1 || !m_con )
return HTTPGET_RUN_ERROR; // error
run_again:
m_con->run();
if ( m_con->get_state() == JNL_Connection::STATE_ERROR )
{
seterrstr( m_con->get_errstr() );
return HTTPGET_RUN_ERROR;
}
if ( m_con->get_state() == JNL_Connection::STATE_CLOSED )
return HTTPGET_RUN_CONNECTION_CLOSED;
if ( m_http_state == 0 ) // connected, waiting for reply
{
if ( m_con->recv_lines_available() > 0 )
{
char buf[ 4096 ] = { 0 };
m_con->recv_line( buf, 4096 );
buf[ 4095 ] = 0;
if ( m_reply && getreplycode() == 100 )
{
free( m_reply );
m_reply = 0;
goto run_again;
}
m_reply = _strdup( buf );
int code = getreplycode();
if ( code >= 200 && code <= 206 )
m_http_state = 2; // proceed to read headers normally
else if ( code == 301 || code == 302 || code == 303 || code == 307 )
{
m_http_state = 1; // redirect city
}
else if ( code != 100 ) // in case of HTTP 100 Continue code, we'll keep looping
{
if ( accept_all_reply_codes )
{
m_http_state = 2; // proceed to read headers normally
}
else
{
seterrstr( buf );
m_http_state = -1;
return HTTPGET_RUN_ERROR;
}
}
cnt = 0;
}
else if ( !cnt++ )
goto run_again;
}
if ( m_http_state == 1 ) // redirect
{
char *loc = 0;
while ( m_con->recv_lines_available() > 0 )
{
char buf[ 4096 ] = { 0 };
m_con->recv_line( buf, 4096 );
buf[ 4095 ] = 0;
if ( !buf[ 0 ] )
{
if ( !loc )
{
m_http_state = -1;
return HTTPGET_RUN_ERROR;
}
else
break;
}
if ( !strncasecmp( buf, "Location:", 9 ) )
{
char *p = buf + 9;
while ( p && *p && *p == ' ' ) p++;
if ( p && *p )
{
// TODO need to make this match the request type
loc = _strdup( p );
}
}
}
if ( loc )
{
connect( loc );
free( loc );
return HTTPGET_RUN_OK;
}
}
/* ----- read headers ----- */
if ( m_http_state == 2 )
{
if ( !cnt++ && m_con->recv_lines_available() < 1 )
goto run_again;
while ( m_con->recv_lines_available() > 0 )
{
char buf[ 8192 ] = { 0 };
m_con->recv_line( buf, 8192 );
buf[ 8191 ] = 0;
if ( !buf[ 0 ] )
{
const char *compression = getheader( "Content-Encoding" );
if ( compression && !strcmp( compression, "gzip" ) )
{
zlibStream = (z_stream *)malloc( sizeof( z_stream ) );
zlibStream->next_in = Z_NULL;
zlibStream->avail_in = Z_NULL;
zlibStream->next_out = Z_NULL;
zlibStream->avail_out = Z_NULL;
zlibStream->zalloc = (alloc_func)0;
zlibStream->zfree = (free_func)0;
zlibStream->opaque = 0;
int z_err = inflateInit2( zlibStream, 15 + 16 /* +16 for gzip */ );
if ( z_err != Z_OK )
{
free( zlibStream );
zlibStream = 0;
}
}
else
{
if ( zlibStream )
{
free( zlibStream );
zlibStream = 0;
}
}
m_http_state = 3;
break;
}
if ( !m_recvheaders )
{
m_recvheaders_size = strlen( buf ) + 1;
if ( m_recvheaders_size == 0 || m_recvheaders_size == (size_t)-1 ) // check for overflow
{
m_http_state = -1;
return HTTPGET_RUN_ERROR;
}
m_recvheaders = (char *)malloc( m_recvheaders_size + 1 );
if ( m_recvheaders )
{
strcpy( m_recvheaders, buf ); // safe because we malloc'd specifically above
m_recvheaders[ m_recvheaders_size ] = 0;
}
else
{
m_http_state = -1;
return HTTPGET_RUN_ERROR;
}
}
else
{
size_t oldsize = m_recvheaders_size;
m_recvheaders_size += strlen( buf ) + 1;
if ( m_recvheaders_size + 1 < oldsize ) // check for overflow
{
m_http_state = -1;
return HTTPGET_RUN_ERROR;
}
char *n = (char *)realloc( m_recvheaders, m_recvheaders_size + 1 );
if ( !n )
{
m_http_state = -1;
return HTTPGET_RUN_ERROR;
}
strcpy( n + oldsize, buf ); // safe because we malloc specifially for the size
n[ m_recvheaders_size ] = 0; // double null terminate
m_recvheaders = n;
}
}
}
return HTTPGET_RUN_OK;
}
int JNL_HTTPGet::get_status() // returns 0 if connecting, 1 if reading headers, 2 if reading content, -1 if error.
{
if ( m_http_state < 0 )
return HTTPGET_STATUS_ERROR;
if ( m_http_state < 2 )
return HTTPGET_STATUS_CONNECTING;
if ( m_http_state == 2 )
return HTTPGET_STATUS_READING_HEADERS;
if ( m_http_state == 3 )
return HTTPGET_STATUS_READING_CONTENT;
return HTTPGET_STATUS_ERROR;
}
int JNL_HTTPGet::getreplycode() // returns 0 if none yet, otherwise returns http reply code.
{
if ( !m_reply )
return 0;
char *p = m_reply;
while ( p && *p && *p != ' ' )
p++; // skip over HTTP/x.x
if ( !p || !*p )
return 0;
return atoi( ++p );
}
size_t JNL_HTTPGet::bytes_available()
{
if ( m_con && m_http_state == 3 )
return m_con->recv_bytes_available();
return 0;
}
size_t JNL_HTTPGet::get_bytes( char *buf, size_t len )
{
if ( m_con && m_http_state == 3 )
{
if ( zlibStream )
{
// TODO: benski> we need to pick a better buffer size
// either alloca() and use the passed in length
// or malloc a buffer based on the constructor-initted buffer size
char temp[ 8192 ] = { 0 };
int size = (int)m_con->peek_bytes( temp, 8192 );
if ( size )
{
zlibStream->next_in = reinterpret_cast<Bytef *>( temp );
zlibStream->avail_in = (uInt)size;
zlibStream->next_out = reinterpret_cast<Bytef *>( buf );
zlibStream->avail_out = (uInt)len;
int zlib_err = inflate( zlibStream, Z_SYNC_FLUSH );
if ( zlib_err == Z_OK || zlib_err == Z_STREAM_END )
{
m_con->recv_bytes( 0, size - zlibStream->avail_in ); // since we only peeked above
return len - zlibStream->avail_out;
}
else
return 0; // TODO: should we do something else here?
}
}
else
return m_con->recv_bytes( buf, len );
}
return 0;
}
size_t JNL_HTTPGet::peek_bytes( char *buf, size_t len )
{
if ( m_con && m_http_state == 3 )
{
if ( zlibStream )
return 0; // TODO: benski> how are we going to do peek_bytes, since the inflater saves state?
else
return m_con->peek_bytes( buf, len );
}
return 0;
}
uint64_t JNL_HTTPGet::content_length()
{
const char *p = getheader( "content-length" );
if ( p && *p )
return strtoull( p, 0, 10 );
else
{
// TODO need to check this further for reliability!
// Helps to handle responses without content-length
if ( m_recvheaders_size > 0 && bytes_available() > 0 )
return bytes_available() - m_recvheaders_size;
}
return 0;
}
void JNL_HTTPGet::seterrstr( const char *str )
{
if ( m_errstr )
free( m_errstr );
m_errstr = _strdup( str );
}
void JNL_HTTPGet::AllowCompression()
{
allowCompression = true;
}
void JNL_HTTPGet::reset_headers()
{
if ( m_sendheaders )
{
free( m_sendheaders );
m_sendheaders = 0;
}
}
void JNL_HTTPGet::set_accept_all_reply_codes()
{
accept_all_reply_codes = true;
}
void JNL_HTTPGet::set_persistent()
{
persistent = true;
}
Reference in New Issue View Git Blame Copy Permalink