/****************************************************************************
 *
 *  Copyright (C) 2000-2001 RealNetworks, Inc. All rights reserved.
 *
 *  This program is free software.  It may be distributed under the terms
 *  in the file LICENSE, found in the top level of the source distribution.
 *
 */

#include "RtspMsg.h"

#include <string.h> /* memset */

CAuthenticator::CAuthenticator()
{
	fRealm = NULL; 
	fNonce = NULL;
	fUsername = NULL; 
	fPassword = NULL;
	fPasswordIsMD5 = false;
}

CAuthenticator::~CAuthenticator()
{
	reset();
}
void CAuthenticator::reset() 
{
	resetRealmAndNonce();
  	resetUsernameAndPassword();
}

void CAuthenticator::setRealmAndNonce(char const* realm, char const* nonce) 
{
  	resetRealmAndNonce();
  	assignRealmAndNonce(realm, nonce);
}

void CAuthenticator::setUsernameAndPassword(char const* username, char const* password, bool passwordIsMD5) 
{
  	resetUsernameAndPassword();
  	assignUsernameAndPassword(username, password, passwordIsMD5);
}

void CAuthenticator::reclaimDigestResponse(char const* responseStr) 
{
	if (responseStr != NULL)
	{
  		delete[](char*)responseStr;
		responseStr = NULL;
	}
}

void CAuthenticator::resetRealmAndNonce() 
{
	if (fRealm != NULL)
	{
  		delete[] fRealm; 
		fRealm = NULL;
	}
	if (fNonce != NULL)
	{
  		delete[] fNonce; 
		fNonce = NULL;
	}
}

void CAuthenticator::resetUsernameAndPassword() 
{
	if (fUsername != NULL)
	{
 		delete[] fUsername; 
		fUsername = NULL;
	}
	if (fPassword != NULL)
	{
  		delete[] fPassword; 
		fPassword = NULL;
	}
  	fPasswordIsMD5 = false;
}

void CAuthenticator::assignRealmAndNonce(char const* realm, char const* nonce) 
{
	if (realm != NULL && strlen(realm) > 0)
	{
		fRealm = strMyDup(realm);
	}
	if (nonce != NULL && strlen(nonce) > 0)
	{
		fNonce = strMyDup(nonce);
	}
}

void CAuthenticator::assignUsernameAndPassword(char const* username, char const* password, bool passwordIsMD5) 
{
	if (username == NULL) 
		username = "";
	if (password == NULL) 
		password = "";

	fUsername = strMyDup(username);
	fPassword = strMyDup(password);
	fPasswordIsMD5 = passwordIsMD5;
}

char const* CAuthenticator::computeDigestResponse(char* cmd, char *url)  
{
	// The "response" field is computed as:
	//    md5(md5(<username>:<realm>:<password>):<nonce>:md5(<cmd>:<url>))
	// or, if "fPasswordIsMD5" is True:
	//    md5(<password>:<nonce>:md5(<cmd>:<url>))
	char *pAlgorithm  = NULL;
	char *pUsername   = NULL;
	char *pRealm      = NULL;
	char *pPasswd     = NULL;
	char *pNonce      = NULL;
	char *pNonceCount = NULL;
	char *pCNonce     = NULL;
	char *pQop        = NULL;
	char *pMethod     = NULL;
	char *pUri        = NULL;
	char sNullAlg[]   = "";  //"MD5";
	char sNullQop[]   = "";  //"auth";	
	//char SessionKey[MD5_SESSION_KEY_LEN+1] = {0};
	char Response[MD5_RESPONSE_LEN] = {0};
	
	char SessionKey[33] = {0};
	if (fPasswordIsMD5) 
	{
		strncpy(SessionKey, fPassword, 32);
		SessionKey[32] = '\0'; // just in case
	} 
	else 
	{
		pUsername  = unquote(fUsername);
		pRealm	   = unquote(fRealm);
		pPasswd    = unquote(fPassword);
		pNonce	   = unquote(fNonce);
		pCNonce    = unquote(sNullAlg);
		pAlgorithm = unquote(sNullAlg);
		//calculate session key
		DigestCalcHA1(pAlgorithm, pUsername, pRealm, pPasswd, pNonce, pCNonce, SessionKey);
	}
	pQop = unquote(sNullQop);
	pMethod = cmd;
	pUri    = url;

	DigestCalcResponse(SessionKey, pNonce, pNonceCount, pCNonce, pQop, pMethod, pUri, (char*)"", Response);

	char const* result = strMyDup(unquote(Response));
	return result;
}


/**************************************
 *
 * CRtspHdr
 *
 **************************************/

CRtspHdr::CRtspHdr(const CString& strKey) : m_strKey(strKey)
{
	//Empty
}

CRtspHdr::CRtspHdr(const CString& strKey, const CString& strVal) : m_strKey(strKey), m_strVal(strVal)
{
	//Empty
}

const CString& CRtspHdr::GetKey(void) const
{
	return m_strKey;
}

const CString& CRtspHdr::GetVal(void) const
{
	return m_strVal;
}

void CRtspHdr::SetVal(const CString& strVal)
{
	m_strVal = strVal;
}

/**************************************
 *
 * CRtspMsg
 *
 **************************************/
CRtspMsg::CRtspMsg(void) : m_nRtspVer(0), m_nSeq(0), m_nBufLen(0), m_pbuf(NULL)
{
	//Empty
}

CRtspMsg::CRtspMsg(const CRtspMsg& other)
{
	CRtspHdrList::ConstIterator itr(other.m_listHdrs.Begin() );
	while (itr)
	{
		CRtspHdr* pHdr = *itr;
		m_listHdrs.InsertTail(new CRtspHdr(*pHdr) );
		itr++;
	}
	
	m_nBufLen = other.m_nBufLen;
	m_pbuf = NULL;
	if (m_nBufLen)
	{
		m_pbuf = new Byte[m_nBufLen+1];
		memcpy(m_pbuf, other.m_pbuf, m_nBufLen);
	}
}

CRtspMsg::~CRtspMsg(void)
{
	while (!m_listHdrs.IsEmpty() )
	{
		CRtspHdr* pHdr = m_listHdrs.RemoveHead();
		delete pHdr;
	}
	
	delete[] m_pbuf; m_pbuf = NULL;
}

const CRtspMsg& CRtspMsg::operator=(const CRtspMsg& other)
{
	m_nRtspVer = other.m_nRtspVer;
	m_nSeq = other.m_nSeq;
	
	while (!m_listHdrs.IsEmpty() )
	{
		CRtspHdr* pHdr = m_listHdrs.RemoveHead();
		delete pHdr;
	}
	CRtspHdrList::ConstIterator itr(other.m_listHdrs.Begin() );
	while (itr)
	{
		CRtspHdr* pHdr = *itr;
		m_listHdrs.InsertTail(new CRtspHdr(*pHdr) );
		itr++;
	}
	
	m_nBufLen = other.m_nBufLen;
	delete[] m_pbuf; m_pbuf = NULL;
	if (m_nBufLen)
	{
		m_pbuf = new Byte[m_nBufLen+1];
		memcpy(m_pbuf, other.m_pbuf, m_nBufLen);
	}
	
	return *this;
}

CRtspMsg::operator CPByte(void) const
{
	return m_pbuf;
}

Byte CRtspMsg::operator[](UINT32 nPos) const
{
	return GetAt(nPos);
}

RtspMsgType CRtspMsg::GetType(void) const
{
	return RTSP_TYPE_NONE;
}

size_t CRtspMsg::GetHdrLen(void) const
{
	size_t nLen = 0;
	CRtspHdrList::ConstIterator itr(m_listHdrs.Begin() );
	while (itr)
	{
		CRtspHdr* pHdr = *itr;
		nLen += (pHdr->GetKey().GetLength() + 2 + pHdr->GetVal().GetLength() + 2);
		itr++;
	}
	
	return nLen;
}



size_t CRtspMsg::GetBufLen(void) const
{
	return m_nBufLen;
}

Byte CRtspMsg::GetAt(UINT32 nPos) const
{
	return m_pbuf[nPos];
}

void CRtspMsg::SetAt(UINT32 nPos, Byte by)
{
	m_pbuf[nPos] = by;
}

void CRtspMsg::GetRtspVer(UINT32* puMajor, UINT32* puMinor) const
{
	assert(puMajor && puMinor);
	
	*puMajor = HIWORD(m_nRtspVer);
	*puMinor = LOWORD(m_nRtspVer);
}

void CRtspMsg::SetRtspVer(UINT32 uMajor, UINT32 uMinor)
{
	assert(uMajor < 10 && uMinor < 10);
	
	m_nRtspVer = MAKEDWORD(uMajor,uMinor);
}

size_t CRtspMsg::GetHdrCount(void) const
{
	return m_listHdrs.GetCount();
}

CString CRtspMsg::GetHdr(const CString& strKey) const
{
	CString strVal;
	
	CRtspHdrList::ConstIterator itr(m_listHdrs.Begin() );
	while (itr)
	{
		CRtspHdr* pHdr = *itr;
		if (0 == strcasecmp(strKey, pHdr->GetKey() ) )
		{
			strVal = pHdr->GetVal();
			break;
		}
		itr++;
	}
	
	return strVal;
}

CRtspHdr* CRtspMsg::GetHdr(UINT32 nIndex) const
{
	CRtspHdrList::ConstIterator itr(m_listHdrs.Begin() );
	for (UINT32 n = 0; n < nIndex; n++)
	{
		itr++;
	}
	return *itr;
}

void CRtspMsg::SetHdr(const CString& strKey, const CString& strVal)
{
	CRtspHdrList::Iterator itr(m_listHdrs.Begin() );
	while (itr)
	{
		CRtspHdr* pHdr = *itr;
		if (0 == strcasecmp(strKey, pHdr->GetKey() ) )
		{
		    pHdr->SetVal(strVal);
		    return;
		}
		itr++;
	}
	m_listHdrs.InsertTail(new CRtspHdr(strKey, strVal) );
}

void CRtspMsg::SetHdr(const CRtspHdr& hdrNew)
{
	CRtspHdrList::Iterator itr(m_listHdrs.Begin() );
	while (itr)
	{
		CRtspHdr* pHdr = *itr;
		if (hdrNew.GetKey() == pHdr->GetKey() )
		{
		    pHdr->SetVal(hdrNew.GetVal() );
		    return;
		}
		itr++;
	}
	m_listHdrs.InsertTail(new CRtspHdr(hdrNew) );
}

PByte CRtspMsg::GetBuf(void) const
{
	return m_pbuf;
}

void CRtspMsg::SetBuf(CPByte buf, size_t nLen)
{
	delete[] m_pbuf; m_pbuf = NULL;
	m_nBufLen = nLen;
	if (m_nBufLen)
	{
		m_pbuf = new Byte[m_nBufLen+1];
		memcpy(m_pbuf, buf, m_nBufLen);
	}
}

/**************************************
 *
 * CRtspRequestMsg
 *
 **************************************/

// These correspond with enum RtspVerb and must be sorted
static CPCHAR s_pVerbs[] = {
	"-NONE-",
	"ANNOUNCE",
	"DESCRIBE",
	"GET_PARAMETER",
	"OPTIONS",
	"PAUSE",
	"PLAY",
	"RECORD",
	"REDIRECT",
	"SETUP",
	"SET_PARAMETER",
	"TEARDOWN",
	NULL
};
static const UINT32 s_nVerbs = sizeof(s_pVerbs)/sizeof(CPCHAR) - 1;

CRtspRequestMsg::CRtspRequestMsg(void) : CRtspMsg()
{
	m_verb = VERB_NONE;
	
	//Empty
}

CRtspRequestMsg::CRtspRequestMsg(const CRtspRequestMsg& other) : CRtspMsg(other)
{
	m_verb = other.m_verb;
	m_strUrl = other.m_strUrl;
	
	UrlParam = other.UrlParam;
}

CRtspRequestMsg::~CRtspRequestMsg( void )
{
	//Empty
}

const CRtspRequestMsg& CRtspRequestMsg::operator=(const CRtspRequestMsg& other)
{
	m_verb = other.m_verb;
	UrlParam = other.UrlParam;
	m_strUrl = other.m_strUrl;
	
	m_nRtspVer = other.m_nRtspVer;
	m_nSeq = other.m_nSeq;
	
	while (!m_listHdrs.IsEmpty() )
	{
		CRtspHdr* pHdr = m_listHdrs.RemoveHead();
		delete pHdr;
	}
	CRtspHdrList::ConstIterator itr(other.m_listHdrs.Begin() );
	while (itr)
	{
		CRtspHdr* pHdr = *itr;
		m_listHdrs.InsertTail(new CRtspHdr(*pHdr) );
		itr++;
	}
	
	m_nBufLen = other.m_nBufLen;
	delete[] m_pbuf; m_pbuf = NULL;
	if (m_nBufLen)
	{
		m_pbuf = new Byte[m_nBufLen+1];
		memcpy(m_pbuf, other.m_pbuf, m_nBufLen);
	}
	
	return *this;
}

RtspMsgType CRtspRequestMsg::GetType( void ) const
{
	return RTSP_TYPE_REQUEST;
}

RtspVerb CRtspRequestMsg::GetVerb( void ) const
{
	return m_verb;
}

CPCHAR CRtspRequestMsg::GetVerbStr( void ) const
{
	return s_pVerbs[m_verb];
}

void CRtspRequestMsg::SetVerb( RtspVerb verb )
{
	assert( verb > VERB_NONE && verb < VERB_LAST );
	
	m_verb = verb;
}
void CRtspRequestMsg::GetFileName(char filename[64])
{
	char* url = (char*)(CPCHAR)m_strUrl;
	char* temp;

	filename[0] = 0;

	temp = rindex(url,'/');
	if(temp == NULL)
	{
		return;
	}
	if(strlen(temp) <= 1)
	{
		*temp = 0;
		temp = rindex(url,'/');
		if(temp == NULL)
		{
			return;
		}
	}
	temp ++;
	snprintf(filename,64,"%s",temp);
}

void CRtspRequestMsg::SetVerb( CPCHAR szVerb )
{
	m_verb = VERB_NONE;
	
	int hi = s_nVerbs;
	int lo = -1;
	int mid;
	while( hi-lo > 1 )
	{
		mid = (hi+lo)/2;
		if( strcmp( szVerb, s_pVerbs[mid] ) <= 0 )
			hi = mid;
		else
			lo = mid;
	}
	if( 0 == strcmp( szVerb, s_pVerbs[hi] ) )
	{
		m_verb = (RtspVerb)hi;
	}
	
	//assert(VERB_NONE == m_verb);
}

CPCHAR CRtspRequestMsg::GetUrl( void ) const
{
	return (CPCHAR)m_strUrl;
}

void CRtspRequestMsg::SetUrl( const CString& strUrl )
{
	m_strUrl = strUrl;
}

void CRtspRequestMsg::ParserUri(void)
{
	//For example: URL=rtsp://192.168.1.245:554/DevAor=100@192.168.1.245/Type=1/BeginTime=2011-3-16.13:06:12/EndTime=2011-3-16.13:06:23/StreamID=1
	//URL=rtsp://172.30.12.93:8554/DevAor=44011188001310000001/StreamID=1
	char* p = (char*)(CPCHAR)m_strUrl;
	if ( ('\0' == *p) || (strcmp(p, "rtsp://") <= 0) )
	{
		printf("%s: url=<%s>, no \"rtsp://\" protocol header!\n", __FUNCTION__, p);
		return;	
	}
	
	p += 7;  //7 = strlen("rtsp://");
	while (*p != '\0')
	{
		if (*p == '/')
		{
			p++;
			
			char buf1[64+1] = {0}, buf2[64+1] = {0}, buf3[64+1] = {0}, buf4[64+1] = {0}, buf5[64+1] = {0}, buf6[64+1] = {0}, buf7[64+1] = {0}, buf8[64+1] = {0};
			sscanf(p, "%64[^/]/%64[^/]/%64[^/]/%64[^/]/%64[^/]/%64[^/]/%64[^/]/%64[^/]/", buf1, buf2, buf3, buf4, buf5, buf6, buf7, buf8);
			if (strlen(buf1) > 0)  //The URL is right if 4th parameter is no empty.
			{
				UrlParam.LineTo(buf1);
				UrlParam.LineTo(buf2);
				UrlParam.LineTo(buf3);
				UrlParam.LineTo(buf4);
				UrlParam.LineTo(buf5);
				UrlParam.LineTo(buf6);
				UrlParam.LineTo(buf7);
				UrlParam.LineTo(buf8);
			}
			else
			{
				printf("%s: url=<%s>, some errors!\n", __FUNCTION__, (char*)(CPCHAR)m_strUrl);
			}
			
			break;
		}
		p++;
	}
}

//Transfer protocol
SOCKETTYPE_E CRtspRequestMsg::ParserClientStreamTransType(void)
{
	CString Transport = GetHdr("Transport");
	char* p = strstr( (char *)(CPCHAR)Transport, "RTP/AVP/TCP");
	if(p != NULL)
	{
		return SOCKETTYPE_TCPSERVER;
	}
	//UDP
	return SOCKETTYPE_UDP;
}

bool CRtspRequestMsg::ParserClientAddr(char * ClientAddr)
{
	if(ClientAddr == NULL)
	{
		return false;
	}
	CString Transport = GetHdr("Transport");

	char* p = strstr( (char *)(CPCHAR)Transport, "destination=");
	if(p == NULL)
	{
		return false;
	}
	p += strlen("destination=");
	char * temp = strchr(p,';');
	if(temp == NULL)
	{
		return false;
	}
	if(temp - p < 7 || temp - p > 15)//"1.1.1.1 255.255.255.255"
	{
		return false;
	}
	memcpy(ClientAddr,p,temp - p);
	ClientAddr[temp - p] = 0;

	return true;
}

UINT16 CRtspRequestMsg::ParserClientPort(void)
{
	CString Transport = GetHdr("Transport");
	UINT16 port = 0;
	
	char* p = strstr( (char*)(CPCHAR)Transport, "client_port");
	if (p != NULL)
	{
		p += 11;  //11 = strlen(client_port=)
	
		while ( (*p != '\0') && ( (*p == ' ') || (*p == '=') ) ) p++;
		
		port = (*p != '\0') ? atoi(p) : 0;
	}
	
	return port;
}

bool CRtspRequestMsg::ParserClientMulticast(void)
{
	CString Transport = GetHdr("Transport");
	char* p = strstr( (char *)(CPCHAR)Transport, "multicast");
	if(p != NULL)
	{
		return true;
	}

	return false;
}

UINT16 CRtspRequestMsg::ParserClientMulticastPort(void)
{
	CString Transport = GetHdr("Transport");
	UINT16 port = 0;
	
	char* p = strstr( (char*)(CPCHAR)Transport, "port");
	if (p != NULL)
	{
		p += 11;  //11 = strlen(client_port=)
	
		while ( (*p != '\0') && ( (*p == ' ') || (*p == '=') ) ) p++;
		
		port = (*p != '\0') ? atoi(p) : 0;
	}
	
	return port;
}

/**************************************
 *
 * CRtspResponseMsg
 *
 **************************************/

struct StatusMapEntry {UINT32 nCode; CPCHAR szName;};

// These must be sorted
static StatusMapEntry s_mapStatus[] =
{
	{ 100, "Continue" },
	
	{ 200, "OK" },
	{ 201, "Created" },
	{ 250, "Low on Storage Space" },
	
	{ 300, "Multiple Choices" },
	{ 301, "Moved Permanently" },
	{ 302, "Moved Temporarily" },
	{ 303, "See Other" },
	{ 304, "Not Modified" },
	{ 305, "Use Proxy" },
	
	{ 400, "Bad Request" },
	{ 401, "Unauthorized" },
	{ 402, "Payment Required" },
	{ 403, "Forbidden" },
	{ 404, "Not Found" },
	{ 405, "Method Not Allowed" },
	{ 406, "Not Acceptable" },
	{ 407, "Proxy Authentication Required" },
	{ 408, "Request Time-out" },
	{ 410, "Gone" },
	{ 411, "Length Required" },
	{ 412, "Precondition Failed" },
	{ 413, "Request Entity Too Large" },
	{ 414, "Request-URI Too Large" },
	{ 415, "Unsupported Media Type" },
	{ 451, "Parameter Not Understood" },
	{ 452, "Conference Not Found" },
	{ 453, "Not Enough Bandwidth" },
	{ 454, "Session Not Found" },
	{ 455, "Method Not Valid in This State" },
	{ 456, "Header Field Not Valid for Resource" },
	{ 457, "Invalid Range" },
	{ 458, "Parameter Is Read-Only" },
	{ 459, "Aggregate operation not allowed" },
	{ 460, "Only aggregate operation allowed" },
	{ 461, "Unsupported transport" },
	{ 462, "Destination unreachable" },
	
	{ 500, "Internal Server Error" },
	{ 501, "Not Implemented" },
	{ 502, "Bad Gateway" },
	{ 503, "Service Unavailable" },
	{ 504, "Gateway Time-out" },
	{ 505, "RTSP Version not supported" },
	{ 551, "Option not supported" },
	{   0, NULL }
};
static const UINT32 s_nStatusEntries = sizeof(s_mapStatus)/sizeof(StatusMapEntry) - 1;

CRtspResponseMsg::CRtspResponseMsg(void) : CRtspMsg(), m_nCode(0)
{
	//Empty
}

CRtspResponseMsg::CRtspResponseMsg(const CRtspResponseMsg& other) : CRtspMsg(other)
{
	m_nCode = other.m_nCode;
	m_strStatusMsg = other.m_strStatusMsg;
}

CRtspResponseMsg::~CRtspResponseMsg( void )
{
	//Empty
}

const CRtspResponseMsg& CRtspResponseMsg::operator=(const CRtspResponseMsg& other)
{
	m_nCode = other.m_nCode;
	m_strStatusMsg = other.m_strStatusMsg;
	
	return *this;
}

RtspMsgType CRtspResponseMsg::GetType(void) const
{
	return RTSP_TYPE_RESPONSE;
}

UINT32 CRtspResponseMsg::GetStatusCode(void) const
{
	return m_nCode;
}

const CString& CRtspResponseMsg::GetStatusMsg(void) const
{
	return m_strStatusMsg;
}

void CRtspResponseMsg::SetStatus( UINT32 nCode, CPCHAR szMsg /* = NULL */ )
{
	assert( nCode >= 100 && nCode <= 999 );
	
	m_nCode = nCode;
	if( !szMsg )
	{
		szMsg = "Unknown";
		
		int hi = s_nStatusEntries;
		int lo = -1;
		int mid;
		while( hi-lo > 1 )
		{
			mid = (hi+lo)/2;
			if( nCode <= s_mapStatus[mid].nCode )
			    hi = mid;
			else
			    lo = mid;
		}
		if( nCode == s_mapStatus[hi].nCode )
		{
			szMsg = s_mapStatus[hi].szName;
		}
	}
	m_strStatusMsg = szMsg;
}