http.cpp

//====== Copyright © 1996-2010, Valve Corporation, All rights reserved. =======
//
// Purpose: HTTP related enums and objects, stuff that both clients and server use should go here
//
//=============================================================================

#include "stdafx.h"
#include <time.h>

#include "msgprotobuf.h"
#include "rtime.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

using namespace GCSDK;

//-----------------------------------------------------------------------------
// Purpose: Check if the given status code is one that by spec allows a body, or is
//          one that "MUST NOT" include an entity body
//-----------------------------------------------------------------------------
bool CHTTPUtil::BStatusCodeAllowsBody( EHTTPStatusCode eHTTPStatus )
{
	switch( eHTTPStatus )
	{
	case k_EHTTPStatusCode100Continue:
	case k_EHTTPStatusCode101SwitchingProtocols:
	case k_EHTTPStatusCode204NoContent:
	case k_EHTTPStatusCode205ResetContent:
	case k_EHTTPStatusCode304NotModified:
		return false;

	default:
		break;
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Wrapper to ease use of Steam Web APIs
//-----------------------------------------------------------------------------
CSteamAPIRequest::CSteamAPIRequest( EHTTPMethod eMethod, const char *pchInterface, const char *pchMethod, int nVersion ) :
	CHTTPRequest( eMethod, "api.steampowered.com", CFmtStr( "/%s/%s/v%04d/", pchInterface, pchMethod, nVersion ) )
{
	if ( k_EHTTPMethodPOST == eMethod )
	{
		SetPOSTParamString( "format", "vdf" );
		SetPOSTParamString( "key", GGCBase()->GetSteamAPIKey() );
	}
	else
	{
		SetGETParamString( "format", "vdf" );
		SetGETParamString( "key", GGCBase()->GetSteamAPIKey() );
	}

	EUniverse universe = GGCHost()->GetUniverse();
	if ( universe == k_EUniverseBeta )
	{
		SetHostname( "api-beta.steampowered.com" );
	}
	else if ( universe == k_EUniverseDev )
	{
		// Set this to your dev universe API endpoint if not local
		SetHostname( "localhost:8282" );
	}
}

CHTTPRequest::CHTTPRequest( CMsgHttpRequest* pProto )
{
	Init( pProto );
}

//-----------------------------------------------------------------------------
// Purpose: Construct a request object, it's invalid until data is setup
//-----------------------------------------------------------------------------
CHTTPRequest::CHTTPRequest()
{
	Init( NULL );
}


//-----------------------------------------------------------------------------
// Purpose: Common init code
//-----------------------------------------------------------------------------
void CHTTPRequest::Init( CMsgHttpRequest* pProto )
{
	//see if we are wrapping a proto that already exists
	if( pProto )
	{
		m_pProto = pProto;
		m_bOwnProto = false;
	}
	else
	{
		m_pProto = new CMsgHttpRequest;
		m_bOwnProto = true;

		SetEHTTPMethod( k_EHTTPMethodInvalid );
		// Default URL
		SetURL( "/" );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CHTTPRequest::CHTTPRequest( EHTTPMethod eMethod, const char *pchHost, const char *pchRelativeURL )
{
	Init( NULL );

	SetEHTTPMethod( eMethod );
	SetHostname( pchHost );
	SetURL( pchRelativeURL );
}


//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CHTTPRequest::CHTTPRequest( EHTTPMethod eMethod, const char *pchAbsoluteURL )
{
	Init( NULL );

	SetEHTTPMethod( eMethod );

	// We need to break the URL down into host + relativeURL
	const char *pchHost = Q_strstr( pchAbsoluteURL, "://" );
	if ( pchHost )
	{
		// Skip past protocol
		pchHost += 3;

		// Find the next /, that is the beginning of the actual URL
		const char *pchURL = Q_strstr( pchHost, "/");
		if ( !pchURL )
		{
			// No URL specified after host? just default to / then.
			SetURL( "/" );
		}
		else
		{
			// Ok, now we must remove the query string
			const char *pchQueryString = Q_strstr( pchURL, "?" );
			if ( !pchQueryString )
			{
				// No query string, full thing is the URL
				SetURL( pchURL );
			}
			else
			{
				// URL is everything before query string
				SetURLDirect( pchURL, pchQueryString - pchURL );

				Assert( *pchQueryString == '?' );
				pchQueryString++;
				if( *pchQueryString )
				{
					m_pProto->mutable_get_params()->Clear();
					CUtlVector<CMsgHttpRequest_QueryParam> vecParams;
					RetrieveURLEncodedData( pchQueryString, Q_strlen( pchQueryString ), vecParams );
					FOR_EACH_VEC( vecParams, i )
					{
						*m_pProto->add_get_params() = vecParams[i];
					}
				}
			}
		}

		// Is there a userinfo separator in the hostname portion? We don't support
		// username/password authentication in the URL, but we must still skip it.
		const char *pchUserinfoSep = strchr( pchHost, '@' );
		if ( pchUserinfoSep &&  ( !pchURL || pchUserinfoSep < pchURL ) )
		{
			pchHost = pchUserinfoSep + 1;
		}

		// If we found a URL only set upto that, otherwise set everything as host
		if ( pchURL )
			SetHostnameDirect( pchHost, pchURL-pchHost );
		else
			SetHostname( pchHost );
	}
	else
	{
		AssertMsg( false, "Bad absolute URL to CHTTPRequest constructor, must start with protocol://" );
		EmitError( SPEW_GC, "Bad absolute URL to CHTTPRequest constructor, must start with protocol://" );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CHTTPRequest::~CHTTPRequest()
{
	if( m_bOwnProto )
		delete m_pProto;
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a GET parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
const CMsgHttpRequest_QueryParam *CHTTPRequest::GetGETParam( const char *pchGetParamName, bool bMatchCase ) const
{
	const uint32 nNumParams = m_pProto->get_params_size(); 
	for( uint32 nParam = 0; nParam < nNumParams; nParam++ )
	{
		const CMsgHttpRequest_QueryParam& param = m_pProto->get_params( nParam );
		if ( bMatchCase )
		{
			if ( Q_strcmp( param.name().c_str(), pchGetParamName ) == 0 )
				return &param;
		}
		else
		{
			if ( Q_stricmp( param.name().c_str(), pchGetParamName ) == 0 )
				return &param;
		}
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a GET parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
const char *CHTTPRequest::GetGETParamString( const char *pchGetParamName, const char *pchDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetGETParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return pchDefault;

	return pParam->value().c_str();
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a GET parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
bool CHTTPRequest::GetGETParamBool( const char *pchGetParamName, bool bDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetGETParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return bDefault;

	return ( Q_atoi( pParam->value().c_str() ) != 0);
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a GET parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
int32 CHTTPRequest::GetGETParamInt32( const char *pchGetParamName, int32 nDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetGETParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return nDefault;

	return Q_atoi( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a GET parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
uint32 CHTTPRequest::GetGETParamUInt32( const char *pchGetParamName, uint32 unDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetGETParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return unDefault;

	return (uint32)V_atoui64( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a GET parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
int64 CHTTPRequest::GetGETParamInt64( const char *pchGetParamName, int64 nDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetGETParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return nDefault;

	return V_atoi64( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a GET parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
uint64 CHTTPRequest::GetGETParamUInt64( const char *pchGetParamName, uint64 unDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetGETParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return unDefault;

	return V_atoui64( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a GET parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
float CHTTPRequest::GetGETParamFloat( const char *pchGetParamName, float fDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetGETParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return fDefault;

	return Q_atof( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a POST parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
const CMsgHttpRequest_QueryParam *CHTTPRequest::GetPOSTParam( const char *pchPostParamName, bool bMatchCase ) const
{
	const uint32 nNumParams = m_pProto->post_params_size(); 
	for( uint32 nParam = 0; nParam < nNumParams; nParam++ )
	{
		const CMsgHttpRequest_QueryParam& param = m_pProto->post_params( nParam );
		if ( bMatchCase )
		{
			if ( Q_strcmp( param.name().c_str(), pchPostParamName ) == 0 )
				return &param;
		}
		else
		{
			if ( Q_stricmp( param.name().c_str(), pchPostParamName ) == 0 )
				return &param;
		}
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a POST parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
const char *CHTTPRequest::GetPOSTParamString( const char *pchGetParamName, const char *pchDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetPOSTParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return pchDefault;

	return pParam->value().c_str();
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a POST parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
bool CHTTPRequest::GetPOSTParamBool( const char *pchGetParamName, bool bDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetPOSTParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return bDefault;

	return ( Q_atoi( pParam->value().c_str() ) != 0);
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a POST parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
int32 CHTTPRequest::GetPOSTParamInt32( const char *pchGetParamName, int32 nDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetPOSTParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return nDefault;

	return Q_atoi( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a POST parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
uint32 CHTTPRequest::GetPOSTParamUInt32( const char *pchGetParamName, uint32 unDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetPOSTParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return unDefault;

	return (uint32)V_atoui64( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a POST parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
int64 CHTTPRequest::GetPOSTParamInt64( const char *pchGetParamName, int64 nDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetPOSTParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return nDefault;

	return V_atoi64( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a POST parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
uint64 CHTTPRequest::GetPOSTParamUInt64( const char *pchGetParamName, uint64 unDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetPOSTParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return unDefault;

	return V_atoui64( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Get the value of a POST parameter, this is case-insensitive by default.
//-----------------------------------------------------------------------------
float CHTTPRequest::GetPOSTParamFloat( const char *pchGetParamName, float fDefault, bool bMatchCase ) const
{
	const CMsgHttpRequest_QueryParam *pParam = GetPOSTParam( pchGetParamName, bMatchCase );
	if ( !pParam )
		return fDefault;

	return Q_atof( pParam->value().c_str() );
}


//-----------------------------------------------------------------------------
// Purpose: Add a GET param to the request
//-----------------------------------------------------------------------------
void CHTTPRequest::SetGETParamRaw( const char *pchGetParamName, uint8 *pData, uint32 cubDataLen )
{
	// See if it already exists, and overwrite then (case sensitive!)
	CMsgHttpRequest_QueryParam *pParam = const_cast< CMsgHttpRequest_QueryParam* >( GetGETParam( pchGetParamName, true ) );
	if ( !pParam )
	{
		// Add a new one then
		pParam = m_pProto->add_get_params();
		pParam->set_name( pchGetParamName );
	}

	pParam->set_value( pData, cubDataLen );
}


//-----------------------------------------------------------------------------
// Purpose: Add a POST param to the request given a string for the name and value
//-----------------------------------------------------------------------------
void CHTTPRequest::SetPOSTParamRaw( const char *pchPostParamName, uint8 *pData, uint32 cubDataLen )
{
	// See if it already exists, and overwrite then (case sensitive!)
	CMsgHttpRequest_QueryParam *pParam = const_cast< CMsgHttpRequest_QueryParam* >( GetPOSTParam( pchPostParamName, true ) );
	if ( !pParam )
	{
		// Add a new one then
		pParam = m_pProto->add_post_params();
		pParam->set_name( pchPostParamName );
	}

	pParam->set_value( pData, cubDataLen );
}


//-----------------------------------------------------------------------------
// Fetch a request headers value by header name
//-----------------------------------------------------------------------------
const char * CHTTPRequest::GetRequestHeaderValue( const char *pchRequestHeaderName, const char *pchDefault ) const
{
	const uint32 nNumHeaders = m_pProto->headers_size();
	for( uint32 nHeader = 0; nHeader < nNumHeaders; nHeader++ )
	{
		const CMsgHttpRequest_RequestHeader& header = m_pProto->headers( nHeader );
		if( Q_stricmp( header.name().c_str(), pchRequestHeaderName ) == 0 )
		{
			return header.value().c_str();
		}
	}

	return pchDefault;	
}

//-----------------------------------------------------------------------------
// Set a header field for the request
//-----------------------------------------------------------------------------
void CHTTPRequest::SetRequestHeaderValue( const char *pchHeaderName, const char *pchHeaderString ) 
{
	const uint32 nNumHeaders = m_pProto->headers_size();
	for( uint32 nHeader = 0; nHeader < nNumHeaders; nHeader++ )
	{
		CMsgHttpRequest_RequestHeader* pHeader = m_pProto->mutable_headers( nHeader );
		if( Q_stricmp( pHeader->name().c_str(), pchHeaderName ) == 0 )
		{
			pHeader->set_value( pchHeaderString );
			return;
		}
	}

	CMsgHttpRequest_RequestHeader* pHeader = m_pProto->add_headers();
	pHeader->set_name( pchHeaderName );
	pHeader->set_value( pchHeaderString );
}

//-----------------------------------------------------------------------------
// Purpose: Fetch a request header by header name and convert it to a time value
// This is just a helpful wrapper of GetRequestHeaderValue that deals with
// parsing the time value
//-----------------------------------------------------------------------------
RTime32 CHTTPRequest::GetRequestHeaderTimeValue( const char *pchRequestHeaderName, RTime32 rtDefault ) const
{
	const char *pchValue = GetRequestHeaderValue( pchRequestHeaderName );
	if( !pchValue )
		return rtDefault;

	return CRTime::RTime32FromHTTPDateString( pchValue );
}


//-----------------------------------------------------------------------------
// Purpose: Set the body data for the request
//-----------------------------------------------------------------------------
void CHTTPRequest::SetBodyData( const void *pubData, uint32 cubData ) 
{ 
	m_pProto->set_body( pubData, cubData );
}


//-----------------------------------------------------------------------------
// Purpose: Get data out of a query string
//-----------------------------------------------------------------------------
void CHTTPRequest::RetrieveURLEncodedData( const char *pchQueryString, int nQueryStrLen, CUtlVector<CMsgHttpRequest_QueryParam> &vecParams )
{
	CUtlBuffer bufParamName( 0, 64 );
	CUtlBuffer bufParamValue( 0, 128 );

	// We shouldn't get passed the ? from a query string, but if we do just skip it and parse ok anyway
	if ( nQueryStrLen && pchQueryString[0] == '?' )
	{
		++pchQueryString;
		--nQueryStrLen;
	}

	bool bInParamValue = false;
	int iTokenStart = 0;
	for( int i=0; i < nQueryStrLen; ++i )
	{
		if ( pchQueryString[i] == '=' && !bInParamValue )
		{
			// = switches to value from name, starts a new value token
			bufParamName.Put( &pchQueryString[iTokenStart], i - iTokenStart );
			bInParamValue = true;
			iTokenStart = i + 1;
		}
		else if ( pchQueryString[i] == '&' )
		{
			// & terminates a value and starts a new name token
			if ( bInParamValue )
			{
				bufParamValue.Put( &pchQueryString[iTokenStart], i - iTokenStart );

				int iIndex = vecParams.AddToTail();
				CMsgHttpRequest_QueryParam *pParam = &vecParams[iIndex];

				uint32 unNameLen = Q_URLDecode( (char*)bufParamName.Base(), bufParamName.TellPut(), (const char*)bufParamName.Base(), bufParamName.TellPut() );
				pParam->set_name( (const char*)bufParamName.Base(), unNameLen );

				uint32 unDataLen = (uint32)Q_URLDecode( (char*)bufParamValue.Base(), bufParamValue.TellPut(), (const char*)bufParamValue.Base(), bufParamValue.TellPut() );
				pParam->set_value( (const uint8*)bufParamValue.Base(), unDataLen );
			}
			bufParamName.Clear();
			bufParamValue.Clear();
			bInParamValue = false;
			iTokenStart = i+1;
		}
	}

	// Use any left over value from the end of the query string
	if ( bInParamValue )
	{
		bufParamValue.Put( &pchQueryString[iTokenStart], nQueryStrLen - iTokenStart );

		int iIndex = vecParams.AddToTail();
		CMsgHttpRequest_QueryParam *pParam = &vecParams[iIndex];

		uint32 unNameLen = Q_URLDecode( (char*)bufParamName.Base(), bufParamName.TellPut(), (const char*)bufParamName.Base(), bufParamName.TellPut() );
		pParam->set_name( (const char*)bufParamName.Base(), unNameLen );

		uint32 unDataLen = (uint32)Q_URLDecode( (char*)bufParamValue.Base(), bufParamValue.TellPut(), (const char*)bufParamValue.Base(), bufParamValue.TellPut() );
		pParam->set_value( (const uint8*)bufParamValue.Base(), unDataLen );
	}
}


//----------------------------------------------------------------------------
// Purpose: Gets a singleton buffer pool for HTTP responses 
//----------------------------------------------------------------------------
static GCConVar http_response_max_pool_size_mb( "http_response_max_pool_size_mb", "10", "Maximum size in bytes of the HTTP Response buffer pool" );
static GCConVar http_response_init_buffer_size( "http_response_init_buffer_size", "65536", "Initial buffer size for buffers in the HTTP Response buffer pool" );
/*static*/ CBufferPool &CHTTPResponse::GetBufferPool()
{
	static CBufferPool s_bufferPool( "HTTP Response", http_response_max_pool_size_mb, http_response_init_buffer_size, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::CONTAINS_CRLF );
	return s_bufferPool;
}


//-----------------------------------------------------------------------------
// Purpose: Construct a response object, it defaults to being a 500 internal server error response
//-----------------------------------------------------------------------------
CHTTPResponse::CHTTPResponse() : 
m_pbufBody( GetBufferPool().GetBuffer() ),
m_eStatusCode( k_EHTTPStatusCode500InternalServerError )
{
	m_pkvResponseHeaders = new KeyValues( "ResponseHeaders" );
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CHTTPResponse::~CHTTPResponse() 
{
	GetBufferPool().ReturnBuffer( m_pbufBody );
	m_pbufBody = NULL;

	if ( m_pkvResponseHeaders )
		m_pkvResponseHeaders->deleteThis();

	m_pkvResponseHeaders = NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Sets the "expiration" response header to a given number of seconds 
// ahead or behind the current time.  You can set the Expires header directly as well,
// this is just a helper so you don't have to deal with time formatting.
//-----------------------------------------------------------------------------
void CHTTPResponse::SetExpirationHeaderDeltaFromNow( int32 nSecondsFromNow )
{
	time_t rawtime;
	time( &rawtime );
	rawtime += nSecondsFromNow;
	SetHeaderTimeValue( "expires", rawtime );
}


//-----------------------------------------------------------------------------
// Purpose: Formats a time value and sets it as a header. This is a helper so
// you don't have to deal with time formatting
//-----------------------------------------------------------------------------
void CHTTPResponse::SetHeaderTimeValue( const char *pchHeaderName, RTime32 rtTimestamp )
{
	char rgchDate[128];
	struct tm tmStruct;
	time_t rawtime = rtTimestamp;
	Plat_gmtime( &rawtime, &tmStruct );
	DbgVerify( strftime( rgchDate, 128, "%a, %d %b %Y %H:%M:%S GMT", &tmStruct ) );
	SetResponseHeaderValue( pchHeaderName, rgchDate );
}


//-----------------------------------------------------------------------------
// Purpose: Serializes the response into a message object (for proxying between
// back-end Steam servers).
//-----------------------------------------------------------------------------
void CHTTPResponse::SerializeIntoProtoBuf( CMsgHttpResponse & response ) const
{
	MEM_ALLOC_CREDIT();
	response.set_status_code( m_eStatusCode );

	FOR_EACH_VALUE( m_pkvResponseHeaders, pkvRequestHeader )
	{
		const char *pchName = pkvRequestHeader->GetName();
		const char *pchValue = pkvRequestHeader->GetString();

		if ( pchName && pchValue )
		{
			CMsgHttpResponse_ResponseHeader *pHeader = response.add_headers();
			pHeader->set_name( pchName );
			pHeader->set_value( pchValue );
		}
	}

	if( m_pbufBody->TellPut() > 0 )
		response.set_body( m_pbufBody->Base(), m_pbufBody->TellPut() );
}


//-----------------------------------------------------------------------------
// Purpose: Deserializes the response from a message object (for proxying between
// back-end Steam servers).
//-----------------------------------------------------------------------------
void CHTTPResponse::DeserializeFromProtoBuf( const CMsgHttpResponse & response )
{
	m_eStatusCode = (EHTTPStatusCode)response.status_code();

	for( int i=0; i<response.headers_size(); i++ )
	{
		m_pkvResponseHeaders->SetString( response.headers(i).name().c_str(), response.headers(i).value().c_str() );
	}

	if( response.has_body() )
		m_pbufBody->Put( response.body().data(), response.body().size() );
}