/******************************************************************************
* FILE:	RtspClientSession.cpp
* Description:
*	Implement for CRtspClientSession class.
*
* Modified Code History
* Mark  Date        By          Modification Reason
*******************************************************************************
* 01    2013/5/28   songxw Initial creation.
******************************************************************************/

#include "RtspClientSession.h"
#include "rtppacket.h"

#define A_SESSION_OCCUPY_MEDIA_PORT     2

CRtspClientSession::CRtspClientSession()
{
	//Channel = Chan;
	bAudio = false;
	
	SendKeepAliveTime = GetClockTime();

	// ÓÃʱ¼äºÍpid×÷ΪËæ»úÊýÖÖ×Ó, ±ÜÃâ¶à½ø³ÌͬʱִÐлòµ¥½ø³Ì¶à´ÎÖ´ÐÐʱËæ»úÊýÏàͬµÄÎÊÌâ¡£
	srand( (UINT32)time(NULL) + (UINT32)getpid() );
	int RandSeed = rand() % ( (RtspEndPort - RtspBeginPort) / A_SESSION_OCCUPY_MEDIA_PORT - 1);
	RtspCurrentPort = RtspBeginPort + RandSeed * A_SESSION_OCCUPY_MEDIA_PORT;

	pTcpTransport = NULL;

	pRtspProt = new CRtspProtocol( (CRtspProtocolResponse*)this);
	if (NULL == pRtspProt)
	{
		printf("pRtspProt is null pointer at %s:%d!", __FILE__, __LINE__);
		exit(1);	
	}

	m_bSupportsGetParam = false;
	m_pTcpStreamTrans = NULL;
	m_pUdpStreamTrans = NULL;
	m_bExitFlag = false;
}

CRtspClientSession::~CRtspClientSession(void)
{
	SAFE_DELETE(m_pUdpStreamTrans);
	SAFE_DELETE(m_pTcpStreamTrans);
	SAFE_DELETE(pTcpTransport);
	SAFE_DELETE(pRtspProt);
}

/* Initialization static variables */
UINT16 CRtspClientSession::RtspBeginPort = RTSP_CLIENT_SESSION_BEGIN_PORT;
UINT16 CRtspClientSession::RtspEndPort = RTSP_CLIENT_SESSION_END_PORT;
UINT16 CRtspClientSession::RtspCurrentPort = RtspBeginPort;
	
/*******************************************************************************
* Function:
*   Find a idle port and allocate to occupy.
*******************************************************************************/
bool CRtspClientSession::AllocatePortID(UINT16 &PId)
{
	if(RtspBeginPort > RtspEndPort)
	{
		RtspEndPort = 65535;
	}
	for (int i=RtspBeginPort; i<RtspEndPort; i+=A_SESSION_OCCUPY_MEDIA_PORT)
	{
		PId = RtspCurrentPort;
		RtspCurrentPort += A_SESSION_OCCUPY_MEDIA_PORT;
		if (RtspCurrentPort >= RtspEndPort)
			RtspCurrentPort = RtspBeginPort;

		//ÅжÏÊÓƵºÍÒôƵ¶Ë¿ÚÊÇ·ñÕ¼Óã¬Ã»ÓÐÅжÏRTCP¶Ë¿Ú¡£
		if ( !PortIsOccupied(PId) && !PortIsOccupied(PId+2) )
		{
		//	DBGPrint(M_RtspClientLib, BREAK_LEVEL, "%s: port<%d> success.", __FUNCTION__, PId);
			return true;
		}
	}

	printf("Allocate port fail!BeginPort<%d> - EndPort<%d> !", RtspBeginPort, RtspEndPort);
	return false;
}

/*******************************************************************************
* Function:
*   »ñÈ¡±¾µØipµØÖ·
*******************************************************************************/
int CRtspClientSession::GetLocalIP(char *address, int size)
{
	unsigned int len;
	int sock_rt, on = 1;

	struct sockaddr_in iface_out;

	struct sockaddr_in remote;

	memset(&remote, 0, sizeof(struct sockaddr_in));

	remote.sin_family = AF_INET;
	remote.sin_addr.s_addr = inet_addr("217.12.3.11");
	remote.sin_port = htons(11111);

	memset(&iface_out, 0, sizeof(iface_out));
	sock_rt = socket(AF_INET, SOCK_DGRAM, 0);

	if (setsockopt(sock_rt, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) == -1) {
		perror("DEBUG: [get_output_if] setsockopt(SOL_SOCKET, SO_BROADCAST");
		close(sock_rt);
		snprintf(address, size, "127.0.0.1");
		return -10;
	}

	if (connect
		(sock_rt, (struct sockaddr *) &remote, sizeof(struct sockaddr_in)) == -1) {
		perror("DEBUG: [get_output_if] connect");
		close(sock_rt);
		snprintf(address, size, "127.0.0.1");
		return -10;
	}

	len = sizeof(iface_out);
	if (getsockname(sock_rt, (struct sockaddr *) &iface_out, &len) == -1) {
		perror("DEBUG: [get_output_if] getsockname");
		close(sock_rt);
		snprintf(address, size, "127.0.0.1");
		return -10;
	}

	close(sock_rt);
	if (iface_out.sin_addr.s_addr == 0) {	/* what is this case?? */
		snprintf(address, size, "127.0.0.1");
		return -10;
	}
	strncpy(address, inet_ntoa(iface_out.sin_addr), size - 1);
	return 0;
}

/*******************************************************************************
* Function:
*   Check the port busy or no.
*******************************************************************************/
bool CRtspClientSession::PortIsOccupied(const UINT16 PId)
{
	char pIpStr[24] = {0};
	GetLocalIP(pIpStr, 24);
	
	//Create the UDP socket
	int SockFd = socket(AF_INET, SOCK_DGRAM, 0/*IPPROTO_UDP*/);
	if (SockFd < 0)
	{
		DBGPrint(M_RtspClientLib, ERROR_LEVEL, "%s:PortIsOccupied create socket failed!", __FUNCTION__);
		perror("RtspSessMgr socket");
		return true;
	}

	struct sockaddr_in addr;
	
	//Init bind address
	bzero(&addr, sizeof(struct sockaddr_in) );
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = inet_addr(pIpStr);
	addr.sin_port = htons(PId);
	
	//Bind the socket to special port
	if (bind(SockFd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in) ) == -1)
	{
		DBGPrint(M_RtspClientLib, ERROR_LEVEL, "%s:PortIsOccupied bind socket failed!", __FUNCTION__);
		close(SockFd);  //BugFix at 2008-7-16
		perror("Rtsp Client Session bind");
		return true;
	}
	
	close(SockFd);
	
	return false;
}

/*******************************************************************************
* Function: 
*	Digest MD5 authorization validate process.
RTSP¿Í»§¶ËÓ¦¸ÃʹÓÃusername + password²¢¼ÆËãresponseÈçÏÂ:

(1)µ±passwordΪMD5±àÂë,Ôò
   response = md5(password:nonce:md5(public_method:url));
(2)µ±passwordΪANSI×Ö·û´®,Ôò
    response= md5(md5(username:realm:password):nonce:md5(public_method:url));
¿Í»§¶ËÔÚÿ´Î·¢Æð²»Í¬µÄÇëÇó·½·¨Ê±¶¼ÐèÒª¼ÆËãresponse×ֶΣ¬
ͬÑùÔÚ·þÎñÆ÷¶ËУÑéʱҲĬÈϲÉȡͬÑùµÄ¼ÆËã·½·¨¡£
*******************************************************************************/
char* CRtspClientSession::createAuthenticatorString(char *cmd, char *url) 
{
	if (m_Authenticator.realm() != NULL && m_Authenticator.username() != NULL && m_Authenticator.password() != NULL) 
	{
		// We have a filled-in authenticator, so use it:
		char* authenticatorStr;
		if (m_Authenticator.nonce() != NULL) 
		{ // Digest authentication
			char const* const authFmt =
			"Digest username=\"%s\", realm=\"%s\", "
			"nonce=\"%s\", uri=\"%s\", response=\"%s\"";
			char const* response = m_Authenticator.computeDigestResponse(cmd, url);
			unsigned authBufSize = strlen(authFmt) + strlen(m_Authenticator.username()) + strlen(m_Authenticator.realm()) + strlen(m_Authenticator.nonce()) + strlen(url) + strlen(response);
			authenticatorStr = new char[authBufSize];
			sprintf(authenticatorStr, authFmt,
			      m_Authenticator.username(), m_Authenticator.realm(),
			      m_Authenticator.nonce(), url, response);
			m_Authenticator.reclaimDigestResponse(response);
		}
		else 
		{ // Basic authentication
			  char const* const authFmt = "Basic %s";
			  unsigned usernamePasswordLength = strlen(m_Authenticator.username()) + 1 + strlen(m_Authenticator.password());
			  char* usernamePassword = new char[usernamePasswordLength+1];
			  sprintf(usernamePassword, "%s:%s", m_Authenticator.username(), m_Authenticator.password());

			  char* response = base64MyEncode(usernamePassword, usernamePasswordLength);
			  unsigned const authBufSize = strlen(authFmt) + strlen(response) + 1;
			  authenticatorStr = new char[authBufSize];
			  sprintf(authenticatorStr, authFmt, response);
			  delete[] response; delete[] usernamePassword;
		}

		return authenticatorStr;
	}

	// We don't have a (filled-in) authenticator.
	return NULL;
}

#if 0
void* CRtspClientSession::Thread()
{
	ThreadStarted();
	
	while(!m_bExitFlag) 
	{	
		int now  = GetClockTime();
		//½ÓÊÕµ½ÂëÁ÷ºó £¬Ã¿¸ô60s ·¢Ëͱ¥ºÍ°ü
		if(now - SendKeepAliveTime >= RTSP_KEEPALIVE_TIME) 
		{
			KeepAliveSession();
			SendKeepAliveTime = now;
		}
		usleep(1000*1000);
	}

	printf("%s: Stream Thread Exit %p, Jstream::ThreadQuit Sucess!!!", __FUNCTION__, this);
	return NULL;
}

void  CRtspClientSession::ThreadQuit(void)
{
	m_bExitFlag = true;
	int times = 5;
	while ( JThread::IsRunning() && times-- > 0 )
	{
		usleep(100000);
	}

	if (times < 0)
	{
	    printf("Jstream::ThreadQuit Fail.\n");
	}
}
#endif


/*******************************************************************************
* Function:
*	Do OPTIONS request and Driver context.
*******************************************************************************/
bool CRtspClientSession::KeepAliveSession(void)
{
	int nRet = -1;
	if (m_bSupportsGetParam == true)
	{
		nRet = GetParam(SessionID);
		if (nRet < 0)
		{
			printf("KeepAliveSession GetParam failed! url<%s> <%s>", (char*)(CPCHAR)CnxData.StrUrl, m_RtspUrl);
			return false;
		}
	}
	else
	{
		nRet = Options(m_RtspUrl);
		if (nRet < 0)
		{
			printf("KeepAliveSession  Options failed! url<%s> <%s>", (char*)(CPCHAR)CnxData.StrUrl, m_RtspUrl);
			return false;
		}
	}
	return true;
}

/*******************************************************************************
* Function:
*	Do OPTIONS request and Driver context.
*******************************************************************************/
int CRtspClientSession::Options(const char* pUrl)
{
	//Check input parameters exception
	if (NULL == pUrl)
	{
		DBGPrint(M_RtspClientLib, ERROR_LEVEL, "%s: pUrl is null pointer!", __FUNCTION__);
		return -1;
	}
	CnxData.StrUrl = pUrl;
	
	CRtspRequestMsg ReqMsg;
	
	ReqMsg.SetVerb(VERB_OPTIONS);
	ReqMsg.SetUrl(CnxData.StrUrl);
	ReqMsg.SetHdr("User-Agent", RTSP_USER_AGENT);
	
	if (m_bSetAuth == true)
	{
		char* authenticatorStr = createAuthenticatorString((char *)ReqMsg.GetVerbStr(), m_RtspUrl);
		if (authenticatorStr != NULL)
		{
			ReqMsg.SetHdr("Authorization", authenticatorStr);
			delete[] authenticatorStr;
		}
	}
	
	return DoWork(ReqMsg);
}


/*******************************************************************************
* Function:
*   Do DESCRIBE request and Driver context.
*******************************************************************************/
int CRtspClientSession::Describe(const char* pUrl, bool bAuth)
{
	//Check input parameters exception
	if (NULL == pUrl)
	{
		DBGPrint(M_RtspClientLib, ERROR_LEVEL, "%s: pUrl is null pointer!", __FUNCTION__);
		return -1;
	}
	CnxData.StrUrl = pUrl;
	
	CRtspRequestMsg ReqMsg;
	
	ReqMsg.SetVerb(VERB_DESCRIBE);
	ReqMsg.SetUrl(CnxData.StrUrl);
	
	if (bAuth == true)
	{
		char* authenticatorStr = createAuthenticatorString((char *)ReqMsg.GetVerbStr(), m_RtspUrl);
		if (authenticatorStr != NULL)
		{
			ReqMsg.SetHdr("Authorization", authenticatorStr);
			delete[] authenticatorStr;
		}
	}
	ReqMsg.SetHdr("User-Agent", RTSP_USER_AGENT);
	ReqMsg.SetHdr("Accept", "application/sdp");
	
	return DoWork(ReqMsg);
}

/*******************************************************************************
* Function:
*   Do SETUP request and Driver context.
*******************************************************************************/
int CRtspClientSession::Setup(const CString& SessionID, const CString StreamId, bool bCreateTcpSvr)
{
	char ClipBuf[HTTP_URL_MAX_LEN+1] = {0};
	CRtspRequestMsg ReqMsg;
	
	ReqMsg.SetVerb(VERB_SETUP);
	
	//Set stream id
	if ( !StreamId.IsEmpty() ) 
	{
		static CString RtspHeader("rtsp://");
		if(StreamId.CompareNumNoCase(RtspHeader, RtspHeader.GetLength()) == 0)
		{
			ReqMsg.SetUrl(StreamId);
		}
		else
		{
			/* rtsp://192.168.1.10:554/h264/streamid=0 */
			snprintf(ClipBuf, sizeof(ClipBuf), "%s/%s", (char*)(CPCHAR)CnxData.StrUrl, (char*)(CPCHAR)StreamId);
			//snprintf(ClipBuf, sizeof(ClipBuf), "rtsp://192.168.12.16/MediaInput/h264/trackID=1");
			CString NewStrUrl(ClipBuf);
			ReqMsg.SetUrl(NewStrUrl);
		}
	}
	else
	{
		ReqMsg.SetUrl(CnxData.StrUrl);	
	}
	if (m_bSetAuth == true)
	{
		char* authenticatorStr = createAuthenticatorString((char *)ReqMsg.GetVerbStr(), m_RtspUrl);
		if (authenticatorStr != NULL)
		{
			ReqMsg.SetHdr("Authorization", authenticatorStr);
			delete[] authenticatorStr;
		}
	}
	
	printf("#########Setup##########Rtsp Session Url<%s> \n", (char*)ReqMsg.GetUrl());
	//Set Session header
	if ( !SessionID.IsEmpty() )
	{
		ReqMsg.SetHdr("Session", SessionID);
	}
	
	//Set Transport header
	if (CRtspClientSession::AllocatePortID(CnxData.ClientPort) )
	{
		snprintf(ClipBuf, sizeof(ClipBuf), "RTP/AVP;unicast;client_port=%d-%d", CnxData.ClientPort, CnxData.ClientPort + 1);
		ReqMsg.SetHdr("Transport", ClipBuf);

		//ÌáÇ°´´½¨tcpserver
		if (bCreateTcpSvr == true && m_pTcpStreamTrans != NULL)	
		{
			m_pTcpStreamTrans->CreateTcpServer(CnxData.ClientPort);
			if (m_pTcpStreamTrans->IsRunning() == false)
			{
				m_pTcpStreamTrans->Start();
			}
		}
		else if (m_pUdpStreamTrans != NULL)
		{
			printf("\n\n>>>>>>>>>>>>>>>>>>>>>>>>>>m_pUdpStreamTrans create rtp port:%d sucess!!!\n\n", CnxData.ClientPort);
			//ÉèÖòÎÊý
			m_pUdpStreamTrans->SetStreamTransParam(E_STREAM_TRANS_UDP, CnxData.strServerIp.c_str(), CnxData.ServerPort, CnxData.strClientIp.c_str(), CnxData.ClientPort);
			if (m_pUdpStreamTrans->InitRtp() < 0)
			{
				return -1;
			}
		}
	}
	else
	{
		return -1;	
	}
	
	ReqMsg.SetHdr("User-Agent", RTSP_USER_AGENT);
	
	int iRet = DoWork(ReqMsg);
	if ( (-1 == iRet) || CnxData.SessionID.IsEmpty() || (0 == CnxData.ServerPort) || (0 == CnxData.ClientPort) )
		return -1;
		
	return 0;
}

/*******************************************************************************
* Function:
*   Do PLAY request and Driver context.
*******************************************************************************/
int CRtspClientSession::Play(const CString& SessionID, int ctrltype, double ctrlparam)
{
	CRtspRequestMsg ReqMsg;
	
	ReqMsg.SetVerb(VERB_PLAY);
	ReqMsg.SetUrl(CnxData.StrUrl);
	
	if (m_bSetAuth == true)
	{
		char* authenticatorStr = createAuthenticatorString((char *)ReqMsg.GetVerbStr(), m_RtspUrl);
		if (authenticatorStr != NULL)
		{
			ReqMsg.SetHdr("Authorization", authenticatorStr);
			delete[] authenticatorStr;
		}
	}
	
	if ( !SessionID.IsEmpty() )
	{
		ReqMsg.SetHdr("Session", SessionID);
	}

	char param[64] = {0};
	switch(ctrltype)
	{
		case HIS_VIDEO_CTRL_PLAY:
			{
				ReqMsg.SetHdr("Range", "npt=0-");
			}
			break;
		case HIS_VIDEO_CTRL_FAST:
			{
				double dSpeed = 1.0;
				if (ctrlparam <= 0)
				{
					dSpeed = 1.0;
				}
				else if (ctrlparam >= 32)
				{
					dSpeed = 32.0;
				}
				else
				{
					dSpeed = (double)ctrlparam;
				}
				sprintf(param, "%lf", dSpeed);
				ReqMsg.SetHdr("Scale", param);
			}
			break;
		case HIS_VIDEO_CTRL_SLOW:
			{
				double dSpeed = 1.0;
				if (ctrlparam <= 0)
				{
					dSpeed = 1.0;
				}
				else if (ctrlparam >= 32)
				{
					dSpeed = 1/32.0;
				}
				else
				{
					dSpeed = 1/(double)ctrlparam;
				}
				sprintf(param, "%lf", dSpeed);
				ReqMsg.SetHdr("Scale", param);
			}
			break;
		case HIS_VIDEO_CTRL_JUMP:
			{
				sprintf(param, "npt=%.3f-", ctrlparam);
				ReqMsg.SetHdr("Range", param);
			}
			break;	
		default:
			break;
	}
	
	return DoWork(ReqMsg);
}

/*******************************************************************************
* Function:
*   Do PAUSE request and Driver context.
*******************************************************************************/
int CRtspClientSession::Pause(const CString& SessionID)
{
	CRtspRequestMsg ReqMsg;
	
	ReqMsg.SetVerb(VERB_PAUSE);
	ReqMsg.SetUrl(CnxData.StrUrl);
	
	if (m_bSetAuth == true)
	{
		char* authenticatorStr = createAuthenticatorString((char *)ReqMsg.GetVerbStr(), m_RtspUrl);
		if (authenticatorStr != NULL)
		{
			ReqMsg.SetHdr("Authorization", authenticatorStr);
			delete[] authenticatorStr;
		}
	}
	
	if ( !SessionID.IsEmpty() )
	{
		ReqMsg.SetHdr("Session", SessionID);
	}

	return DoWork(ReqMsg);
}

/*******************************************************************************
* Function:
*   Do TEARDOWN request and Driver context.
*******************************************************************************/
int CRtspClientSession::Teardown(const CString& SessionID, const CString StreamId)
{
	if (SessionID.IsEmpty())
	{
		printf("%s:seesion id  is null!\n", __FUNCTION__);
		return -1;
	}
	char ClipBuf[128+1] = {0};
	CRtspRequestMsg ReqMsg;
	
	ReqMsg.SetVerb(VERB_TEARDOWN);
	
	//Set stream id
	if ( !StreamId.IsEmpty() )
	{
		/* rtsp://192.168.1.10:554/h264/streamid=0 */
		snprintf(ClipBuf, sizeof(ClipBuf), "%s/%s", (char*)(CPCHAR)CnxData.StrUrl, (char*)(CPCHAR)StreamId);
		CString NewStrUrl(ClipBuf);
		ReqMsg.SetUrl(NewStrUrl);
	}
	else
	{
		ReqMsg.SetUrl(CnxData.StrUrl);	
	}
	
	if (m_bSetAuth == true)
	{
		char* authenticatorStr = createAuthenticatorString((char *)ReqMsg.GetVerbStr(), m_RtspUrl);
		if (authenticatorStr != NULL)
		{
			ReqMsg.SetHdr("Authorization", authenticatorStr);
			delete[] authenticatorStr;
		}
	}
	
	if ( !SessionID.IsEmpty() )
	{
		ReqMsg.SetHdr("Session", SessionID);
	}
	
	return DoWork(ReqMsg);
}

/*******************************************************************************
* Function:
*   Do GET_PARAMETER request and Driver context.
*******************************************************************************/
int CRtspClientSession::GetParam(const CString& SessionID)
{
	CRtspRequestMsg ReqMsg;
	
	ReqMsg.SetVerb(VERB_GETPARAM);
	ReqMsg.SetUrl(CnxData.StrUrl);

	if (m_bSetAuth == true)
	{
		char* authenticatorStr = createAuthenticatorString((char *)ReqMsg.GetVerbStr(), m_RtspUrl);
		if (authenticatorStr != NULL)
		{
			ReqMsg.SetHdr("Authorization", authenticatorStr);
			delete[] authenticatorStr;
		}
	}
	if ( !SessionID.IsEmpty() )
	{
		ReqMsg.SetHdr("Session", SessionID);
	}
	
	return DoWork(ReqMsg);
}

////////////////////////////////////////////////////    Response    ////////////////////////////////////////////////////////

/*******************************************************************************
* Function:
*   ´¦ÀíOPTIONSÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnOptionsResponse(CRtspResponseMsg* pMsg)
{
	if (strstr((CPCHAR)pMsg->GetHdr("Public"), "GET_PARAMETER") != NULL)
	{
		m_bSupportsGetParam = true;	
	}
}

/*******************************************************************************
* Function:
*   ´¦ÀíDESCRIBEÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnDescribeResponse(CRtspResponseMsg* pMsg)
{
	//Check input parameters exception
	if (NULL == pMsg)
	{
		printf("%s: pMsg is null pointer!\n", __FUNCTION__);
		return;
	}
	
	//ÈÏÖ¤
	if (pMsg->GetStatusCode() == 401)
	{
		m_Authenticator.setRealmAndNonce(pMsg->mUserData.AuthRealm, pMsg->mUserData.AuthNonce);
		printf("%s:set auth realm:%s nonce:%s \n", __FUNCTION__, pMsg->mUserData.AuthRealm, pMsg->mUserData.AuthNonce);
		return;
	}

	
	char *pSdpStr = (char*)pMsg->GetBuf();
	if (NULL == pSdpStr)
	{
		printf("%s: pSdpStr is null pointer!\n", __FUNCTION__);
		return;	
	}
	
	pSdpStr[pMsg->GetBufLen()] = 0;

				//½âÎöÓîÊÓSDPÐÅÏ¢
				//ÔÝʱδ×öÈÏ֤ģ¿é£¬ºóÐøÌí¼Ó
//--------------------------------------------
	char *pVideoStr = strstr(pSdpStr, "m=video");
	if (pVideoStr != NULL)
	{
		char *pSdpStr2 = NULL;
		char *pSdpStr1 = strstr(pVideoStr, "a=control:");
		if(pSdpStr1 != NULL)
		{
			pSdpStr1 += 10;
			pSdpStr2 = strstr(pSdpStr1,"\r\n");
			if(pSdpStr2 == NULL)
				pSdpStr2 = strstr(pSdpStr1,"\n");
			if(pSdpStr2 != NULL)
			{
				char pVTmp[128 + 1] = {0};
				memcpy(pVTmp,pSdpStr1,pSdpStr2-pSdpStr1);
				pVTmp[pSdpStr2-pSdpStr1] = 0;
			//	if(strstr(pVTmp, "rtsp://") != NULL)
				{
					CnxData.StrVStream = pVTmp;
					printf("Get  Rtsp Step StrVStream URL<%s>!\n", pVTmp);
				}
			}
			else
			{
				printf("%s: Parse video control StrVStream  Failure!\n%s", __FUNCTION__, pSdpStr);
			}
		}
		else
		{
			printf("%s: Parse sdp video control Failure!\n%s", __FUNCTION__, pSdpStr);
		}

		char *pSdpStr3 = NULL;
		char *pSdpStr4 = NULL;
		char *pAudioStr = strstr(pSdpStr2, "m=audio");
		if(pAudioStr != NULL)
		{
			pSdpStr3 = strstr(pAudioStr, "a=control:");
			if(pSdpStr3 != NULL)
			{
				pSdpStr3 += 10;
				pSdpStr4 = strstr(pSdpStr3,"\r\n");
				if(pSdpStr4 == NULL)
					pSdpStr4 = strstr(pSdpStr3,"\n");
				if(pSdpStr4 != NULL)
				{
					char pATmp[128 + 1] = {0};
					memcpy(pATmp,pSdpStr3,pSdpStr4-pSdpStr3);
					pATmp[pSdpStr4-pSdpStr3] = 0;
				//	if(strstr(pATmp, "rtsp://") != NULL)
					{
						CnxData.StrAStream = pATmp;
						printf("Get  Rtsp Step StrAStream URL<%s>!\n", pATmp);
					}
				}
				else
				{
					//printf("%s: Parse audio control StrVStream  Failure!\n%s", __FUNCTION__, pSdpStr);
				}
			}
			else
			{
				printf("%s: Parse sdp audio control Failure!\n%s", __FUNCTION__, pSdpStr);
			}
		}
		else
		{
			printf("%s: Parse sdp audio  Failure!\n%s", __FUNCTION__, pSdpStr);
		}
	}
	else
	{
		printf("%s: Parse sdp video  Failure!\n%s", __FUNCTION__, pSdpStr);
	}
	return;
}

/*******************************************************************************
* Function:
*   ´¦ÀíANNOUNCEÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnAnnounceResponse(CRtspResponseMsg* pMsg)
{
	
}

/*******************************************************************************
* Function:
*   ´¦ÀíGetParamÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnGetParamResponse(CRtspResponseMsg* pMsg)
{
	
}

/*******************************************************************************
* Function:
*   ´¦ÀíSetParamÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnSetParamResponse(CRtspResponseMsg* pMsg)
{
	
}

/*******************************************************************************
* Function:
*   ´¦ÀíSETUPÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnSetupResponse(CRtspResponseMsg* pMsg)
{
	//Check input parameters exception
	if (NULL == pMsg)
	{
		DBGPrint(M_RtspClientLib, ERROR_LEVEL, "%s: pMsg is null pointer!", __FUNCTION__);
		return;
	}
	//»ñÈ¡»á»°ID
	CnxData.SessionID = pMsg->GetHdr("Session");
	if ( CnxData.SessionID.IsEmpty() )
	{
		DBGPrint(M_RtspClientLib, ERROR_LEVEL, "%s: no Session header for url<%s>!", __FUNCTION__, (char*)(CPCHAR)CnxData.StrUrl);
	}
	
	//»ñȡýÌå¶Ë¿Ú
	CString StrTransport = pMsg->GetHdr("Transport");
#if 0	
	char needle1[] = "server_port=";
	char* pPortStr1 = strstr( (char*)(CPCHAR)StrTransport, needle1);
	if (pPortStr1 != NULL)
		CnxData.ServerPort = atoi(pPortStr1 + strlen(needle1) );
	else
		printf("%s: Not found server port for url<%s>!", __FUNCTION__, (char*)(CPCHAR)CnxData.StrUrl);
	
	
	char needle2[] = "client_port=";
	char* pPortStr2 = strstr( (char*)(CPCHAR)StrTransport, needle2);
	if (pPortStr2 != NULL)
		CnxData.ClientPort = atoi(pPortStr2 + strlen(needle2) );
	else
		printf("%s: Not found client port for url<%s>!", __FUNCTION__, (char*)(CPCHAR)CnxData.StrUrl);
#endif
	unsigned char rtpChannelId;
	unsigned char rtcpChannelId;
	char* foundServerAddressStr = NULL;
	bool foundServerPortNum = false;
	unsigned short clientPortNum = 0;
	unsigned short serverPortNum = 0;
	bool foundClientPortNum = false;
	bool foundChannelIds = false;
	unsigned rtpCid, rtcpCid;
	bool isMulticast = true; // by default
	char* foundDestinationStr = NULL;
	unsigned short multicastPortNumRTP, multicastPortNumRTCP;
	bool foundMulticastPortNum = false;

 	char const* fields = (CPCHAR)StrTransport;	
	char* field = strMyDupSize(fields);
	while (sscanf(fields, "%[^;]", field) == 1) 
	{
		if (sscanf(field, "server_port=%hu", &serverPortNum) == 1) 
		{
		  	foundServerPortNum = true;
		} 
		else if (sscanf(field, "client_port=%hu", &clientPortNum) == 1) 
		{
		  	foundClientPortNum = true;
		} 
		else if (strncasecmp(field, "source=", 7) == 0) 
		{
		  	delete[] foundServerAddressStr;
		  	foundServerAddressStr = strMyDup(field+7);
		} 
		else if (sscanf(field, "interleaved=%u-%u", &rtpCid, &rtcpCid) == 2) 
		{
			rtpChannelId = (unsigned char)rtpCid;
			rtcpChannelId = (unsigned char)rtcpCid;
			foundChannelIds = true;
		} 
		else if (strcmp(field, "unicast") == 0) 
		{
		  	isMulticast = false;
		} 
		else if (strncasecmp(field, "destination=", 12) == 0) 
		{
		  	delete[] foundDestinationStr;
		  	foundDestinationStr = strMyDup(field+12);
		} 
		else if (sscanf(field, "port=%hu-%hu", &multicastPortNumRTP, &multicastPortNumRTCP) == 2 ||
		       sscanf(field, "port=%hu", &multicastPortNumRTP) == 1) 
		{
		  	foundMulticastPortNum = true;
		}

		fields += strlen(field);
		while (fields[0] == ';') 
			++fields; // skip over all leading ';' chars
		if (fields[0] == '\0') 
			break;
	}
	delete[] field;

	CnxData.ServerPort = serverPortNum;
	CnxData.ClientPort = clientPortNum;
	if (foundServerAddressStr != NULL)
		CnxData.strServerIp = foundServerAddressStr;
	else
		CnxData.strServerIp = pTcpTransport->sIpAddr;
	delete[] foundDestinationStr;
	delete[] foundServerAddressStr;

	char pMyIpStr[24] = {0};
	GetLocalIP(pMyIpStr, 24);
	CnxData.strClientIp = pMyIpStr;
	
	printf("%s:%d ServerPort:%u, ClientPort:%u, strServerIp:%s, strClientIp:%s\n", __FUNCTION__, __LINE__, CnxData.ServerPort, CnxData.ClientPort, CnxData.strServerIp.c_str(), CnxData.strClientIp.c_str());
}

/*******************************************************************************
* Function:
*   ´¦ÀíPLAYÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnPlayResponse(CRtspResponseMsg* pMsg)
{
	//Check input parameters exception
	if (NULL == pMsg)
	{
		printf("%s: pMsg is null pointer!", __FUNCTION__);
		return;
	}
}

/*******************************************************************************
* Function:
*   ´¦ÀíPAUSEÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnPauseResponse(CRtspResponseMsg* pMsg)
{
	
}

/*******************************************************************************
* Function:
*   ´¦ÀíRECORDÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnRecordResponse(CRtspResponseMsg* pMsg)
{
	
}

/*******************************************************************************
* Function:
*   ´¦ÀíREDIRECTÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnRedirectResponse(CRtspResponseMsg* pMsg)
{
	
}

/*******************************************************************************
* Function:
*   ´¦ÀíTEARDOWNÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnTeardownResponse(CRtspResponseMsg* pMsg)
{
	//Check input parameters exception
	if (NULL == pMsg)
	{
		DBGPrint(M_RtspClientLib, ERROR_LEVEL, "%s: pMsg is null pointer!", __FUNCTION__);
		return;
	}
}

/*******************************************************************************
* Function:
*   ´¦ÀíEXTENSIONÏûÏ¢µÄ»ØÓ¦¡£
*******************************************************************************/
void CRtspClientSession::OnExtensionResponse(CRtspResponseMsg* pMsg)
{
	
}

/*******************************************************************************
* Function:
*   RTSP¿Í»§¶Ë·¢ËÍÏûÏ¢½»»¥Ö÷Òª²Ù×÷¹ý³Ì£¬Íê³ÉÏûÏ¢±àÂë¡¢·¢ËÍ¡¢½ÓÊÕ¡¢½âÎöºÍÁ÷³ÌÇý¶¯¡£
*******************************************************************************/
int CRtspClientSession::DoWork(CRtspRequestMsg& ReqMsg)
{
	char* pNewBuf = NULL;
	int BufLen = 0;
	int iRet = pRtspProt->Encoder(&ReqMsg, pNewBuf, BufLen);
	if (0 == iRet)
	{
	 //   printf("-------------------------Send-----------------------------\n");
	//	printf("%s\n",pNewBuf);
		iRet = SendData(pNewBuf, BufLen);
		//Note: pNewBuf is dynamic memory alloc pointer! so free it.
		delete [] pNewBuf;
		if (iRet > 0)
		{
			BufLen = RTSP_MESSAGE_MAX_LEN;
			memset(DataBuf, 0, sizeof(DataBuf));
			int DataLen = ReadData(DataBuf, BufLen, 5); //wait 2 seconds    //waite 1 senconds
			if (DataLen > 0)
			{
				CRtspProtocol::CRtspRequestTag* pRequestTag = new CRtspProtocol::CRtspRequestTag(atoi(ReqMsg.GetHdr("CSeq") ), ReqMsg.GetVerb() );
				if (pRequestTag != NULL)
				{
					if (pRtspProt->RequestTagListQueue.insert(pRequestTag) != -1)
					{
						CRtspMsg* pRtspMsg = NULL;
						int code = 0;
						int iRet2 = pRtspProt->DecoderAndDrvie(DataBuf, DataLen, pRtspMsg, code);
						
						if (0 == iRet2)
						{
							if (pRtspMsg != NULL)
							{
							    CnxData.StatusCode = ( (CRtspResponseMsg*)pRtspMsg)->GetStatusCode();
							
								SAFE_DELETE(pRtspMsg); //ÊÍ·ÅÄÚ´æ
							}
							if (CnxData.StatusCode != 200 && CnxData.StatusCode != 401)
							{
								printf("%s:%d Recv a error message from Url<%s>!\n%s", __FUNCTION__, __LINE__, (char*)(CPCHAR)CnxData.StrUrl, DataBuf);
								return -1;
							}
							return 0;
						}
						else
						{
							if (pRtspMsg != NULL)
							{
							    CnxData.StatusCode = ( (CRtspResponseMsg*)pRtspMsg)->GetStatusCode();
								SAFE_DELETE(pRtspMsg); //ÊÍ·ÅÄÚ´æ
							}
							printf("%s:%d Recv a error message from Url<%s>!\n%s", __FUNCTION__, __LINE__, (char*)(CPCHAR)CnxData.StrUrl, DataBuf);
						
							/* ±±¾©¹«½»BTÏîÄ¿ÎÄ°²É豸ÔÚGET_PARAMETERʱ£¬»ØÓ¦ÏÂÁаü£¬°ü½áβûÓÐ/r/n£¬µ¼Ö½âÎö³ö´í£¬ÏµÍ³±ÀÀ£¡£ --yinxiaogui 2014/3/7 13:59:24
							 * "RTSP/1.0 200 OK\r\nCSeq: 6\r\nDate: Fri, Mar 07 2014 12:04:00 GMT\r\nContent-Base: rtsp://" */
							if ( (200 == CnxData.StatusCode) && (412 == code) )
								return 0;
							
							return -1;
						}
					}
					else
					{
						printf("Rtsp request tag insert: fatal error!\n");
						delete pRequestTag;
						return -1;	
					}
				}
				else
				{
					printf("%s: new CRtspRequestTag fail!\n", __FUNCTION__);
					return -1;
				}
			}
			else
			{
				printf("%s: Read data error, len: %d, Url<%s>!\n", __FUNCTION__, DataLen, (char*)(CPCHAR)CnxData.StrUrl);
				return -1;
			}
		}
		else
		{
			printf("%s: Send data error: Url<%s>!\n", __FUNCTION__, (char*)(CPCHAR)CnxData.StrUrl);
			return -1;
		}
	}
	else
	{
		if (RTSP_TYPE_REQUEST == ReqMsg.GetType() )
		{
			printf("%s: Translate rtsp request<%s> message into str failed!\n", __FUNCTION__, ReqMsg.GetVerbStr() );	
		}
		else
		{
			printf("%s: no request message!\n", __FUNCTION__);
		}
		
		return -1;	
	}
	
	return 0;
}




/*******************************************************************************
* Function:
*   ͨ¹ý´«Êä²ã·¢ËÍÐÅÁ·¢ËÍÊý¾ÝΪ×èÈûģʽ¡£
*******************************************************************************/
int CRtspClientSession::SendData(const char* pBuf, int Len, const int WaitForTimeout)
{
	struct pollfd FdSet[1] = { {0, 0} };
	
	FdSet[0].fd = pTcpTransport->SockFd;
	//FdSet[0].events = POLLOUT | POLLRDHUP;
	FdSet[0].events = POLLOUT;
	
	//ÂÖѯÍøÂçFD£¬¿ÉÒÔд»òÕßÒì³£Á¢¼´·µ»Ø£¬²»ÄÜдµÈ´ý³¬Ê±¡£
	if ( (poll(FdSet, 1, WaitForTimeout * 1000) < 0) && (errno != EINTR) )
	{
		printf("%s poll error: SockFd<%d>, Url<%s>!", __FUNCTION__, pTcpTransport->SockFd, (char*)(CPCHAR)CnxData.StrUrl);
		return -1;
	}
	
	return pTcpTransport->Send( (UINT8*)pBuf, Len);
}

/*******************************************************************************
* Function:
*   ͨ¹ý´«Êä²ã½ÓÊÕÐÅÁî¡£
*******************************************************************************/
int CRtspClientSession::ReadData(const char* pBuf, int BufLen, const int WaitForTimeout)
{
	struct pollfd FdSet[1] = { {0, 0} };
	
	FdSet[0].fd = pTcpTransport->SockFd;
	FdSet[0].events = POLLIN | POLLPRI;
	
	//ÂÖѯÍøÂçFD£¬ÓÐÊý¾Ý»òÕßÒì³£Á¢¼´·µ»Ø£¬ÎÞÊý¾ÝµÈ´ý³¬Ê±¡£
	int ret = poll(FdSet, 1, WaitForTimeout * 1000);
	if ( (ret < 0) && (errno != EINTR) )
	{
		printf("%s poll error: SockFd<%d>, Url<%s>!\n", __FUNCTION__, pTcpTransport->SockFd, (char*)(CPCHAR)CnxData.StrUrl);
		return -1;
	}

	printf("poll return %d\n", ret);
	
	//ÅжÏÊý¾Ý¿É¿¿ÐÔ£¿
	if ( ( (FdSet[0].revents & POLLIN) == POLLIN) || ( (FdSet[0].revents & POLLPRI) == POLLPRI) )
	{
		//return pTcpTransport->Read( (UINT8*)pBuf, BufLen);
		return ReadRtspData( (UINT8*)pBuf, BufLen);
	}
	else 
	{
		printf("revents error: 0x%x\n",FdSet[0].revents);
	}
	
	return 0;
}


int CRtspClientSession::ReadRtspData(UINT8 *pBuf, int BufLen)
{
	printf("ReadRtspData!\n");
   
	int DataLen =  pTcpTransport->Read( (UINT8*)pBuf, BufLen, MSG_PEEK);
	if (DataLen <= 0)
	{
		return DataLen;
	}

	printf("Begin to parse RTSP!\n");
	//1. Begin to parse RTSP, HTTP format data
	char* p2CRLF = strstr( (char*)pBuf, "\r\n\r\n");
	if (p2CRLF != NULL)
	{
		int TheMsgLen = (long)p2CRLF - (long)pBuf + 4;
		
		pBuf[TheMsgLen] = 0;
		char* pContentLength = strstr( (char*)pBuf, "Content-Length");
		if (pContentLength != NULL)
		{
			pContentLength += sizeof("Content-length");

			while ( (*pContentLength == ':') || (*pContentLength == ' ') ) pContentLength++;
			TheMsgLen += atoi(pContentLength);
		}
		
		DataLen = pTcpTransport->Read( (UINT8*)pBuf, BufLen, 0);
		if (DataLen == TheMsgLen)
		{
			return DataLen;
		}
		else
		{
		    int dataLen1 = 0;
		    if (DataLen > 0)
		    {
		        dataLen1 = pTcpTransport->Read( (UINT8*)&pBuf[DataLen], BufLen, 0);
				if (dataLen1 + DataLen >= TheMsgLen)
				{
				    return dataLen1 + DataLen;
				}
		    }
			
			printf("TCP Recv <%d, %d> bytes but no match <%d> bytes!\n%s\n", DataLen, dataLen1, TheMsgLen, (char *)pBuf);
		}
	}
	else
	{
	    //panasonic dev : teardown ret is:    RTSP/1.0 200 OK\r\nCSeq: 4\r\n    ȱÉÙ\r\n
	    char* p2CRLF = strstr( (char*)pBuf, "RTSP/1.0 200 OK\r\nCSeq:");
		if (p2CRLF != NULL)
		{
		    
			int TheMsgLen = DataLen;
			DataLen = pTcpTransport->Read( (UINT8*)pBuf, BufLen, 0);
			if (DataLen == TheMsgLen)
			{
			    strcat((char*)pBuf, "\r\n");
				return DataLen + 2;
			}
			else
			{
			    int dataLen1 = 0;
			    if (DataLen > 0)
			    {
			        dataLen1 = pTcpTransport->Read( (UINT8*)&pBuf[DataLen], BufLen, 0);
					if (dataLen1 + DataLen >= TheMsgLen)
					{
					    return dataLen1 + DataLen;
					}
			    }
				
				printf("TCP Recv <%d> bytes but no match <%d> bytes!!!\n%s\n", DataLen, TheMsgLen, (char *)pBuf);
			}
		}

		printf("%s: parse rtsp data error, datalen(%d)\n%s!\n", __FUNCTION__, DataLen, pBuf);
		usleep(1000);
	}

	pTcpTransport->Read( (UINT8*)pBuf, BufLen, 0);
	pBuf[0] = 0;
	
	return 0;
}