windows-server-2003/enduser/netmeeting/av/rrcm/rtp/rtprecv.cpp

/*----------------------------------------------------------------------------
 * File:        RTPRECV.C
 * Product:     RTP/RTCP implementation
 * Description: Provides Receive Data Functionality.
 *
 * This listing is supplied under the terms 
 * of a license agreement with Intel Corporation and
 * many not be copied nor disclosed except in accordance
 * with the terms of that agreement.
 * Copyright (c) 1995 Intel Corporation. 
 *--------------------------------------------------------------------------*/


#include "rrcm.h"


/*---------------------------------------------------------------------------
/							Global Variables
/--------------------------------------------------------------------------*/            



/*---------------------------------------------------------------------------
/							External Variables
/--------------------------------------------------------------------------*/
extern PRTP_CONTEXT		pRTPContext;
extern RRCM_WS			RRCMws;

#if (defined(_DEBUG) || defined(PCS_COMPLIANCE))
//INTEROP
extern LPInteropLogger RTPLogger;
#endif

/*----------------------------------------------------------------------------
 * Function   : RTPReceiveCheck
 * Description: Called when a packet is received. Handles any statistical
 *				processing required for RTCP.  
 * 
 * Input :		hRTPSession: handle returned by CreateRTPSession
 				RTPsocket: socket on which the packet was received
 				char *pPacket: pointer to packet buffer
 *				cbTransferred:	Number of bytes in packet
 *				pFrom:			sender address
 *				fromlen:		sender address length
 *
 * !!! IMPORTANT NOTE !!!
 *   Currently assumes CSRC = 0
 * !!! IMPORTANT NOTE !!!
 *
 * Return: Status indicating if the packet is OK or has a problem
 ---------------------------------------------------------------------------*/
DWORD  RTPReceiveCheck (
						HANDLE hRTPSession,
						SOCKET RTPsocket,
						char *pPacket,
           				DWORD cbTransferred,
           				PSOCKADDR pFrom,
           				UINT fromlen
           				 )
	{
	PRTP_SESSION		pRTPSession = (PRTP_SESSION) hRTPSession;
	RTP_HDR_T 			*pRTPHeader = (RTP_HDR_T *)pPacket;
	PSSRC_ENTRY			pSSRC = NULL;
	DWORD				dwSSRC;
	DWORD				oldSSRC;
	PSSRC_ENTRY			pMySSRC;
	DWORD				dwStatus = 0;
	struct sockaddr_in	*pSSRCadr;

	IN_OUT_STR ("RTP : Enter RTPReceiveCheck()\n");


	ASSERT (pRTPSession);

	// If Winsock error or runt packet(used to cancel recvs), signal completion to application 
	// and do not repost.
	if (cbTransferred < RTP_HDR_MIN_LEN)
		{
		// don't report closeSocket() as an error when the application
		//  have some pending buffers remaining

		// notify the user if an error occured, so he can free up 
		// its receive resources. The byte count is set to 0

		return RTP_RUNT_PACKET;
		}

	// Perform validity checking
	ASSERT (pRTPHeader);

#if (defined(_DEBUG) || defined(PCS_COMPLIANCE))
	if (RTPLogger)
		{
		//INTEROP
		InteropOutput (RTPLogger,
					   (BYTE FAR*)(pRTPHeader),
					   (int)cbTransferred,
					   RTPLOG_RECEIVED_PDU | RTP_PDU);
		}
#endif

	// Check RTP Headers for validity.  If not valid, then repost buffers 
	// to the network layer for a new receive.
	if (validateRTPHeader (pRTPHeader) ) 
		{
		// Get pointer to SSRC entry table for this session
		// If SSRC in packet is > 1/2 MAX_RANGE of DWORD, start search from
		//	tail of SSRC list, otherwise, start from front
		RRCMws.ntohl (RTPsocket, pRTPHeader->ssrc, &dwSSRC);
					    
		if (dwSSRC > MAX_DWORD/2) 
			{
			pSSRC = searchforSSRCatTail (
				(PSSRC_ENTRY)pRTPSession->pRTCPSession->RcvSSRCList.prev,
				dwSSRC);
			}
		else 
			{
			pSSRC = searchforSSRCatHead (
				(PSSRC_ENTRY)pRTPSession->pRTCPSession->RcvSSRCList.next,
				dwSSRC);
			}

		// get my own SSRC used for this stream
		pMySSRC = searchForMySSRC (
			(PSSRC_ENTRY)pRTPSession->pRTCPSession->XmtSSRCList.prev,
			RTPsocket);
		ASSERT (pMySSRC);
		
		// is this SSRC already known on the receive list ?
		if (pSSRC == NULL) 
			{
			// don't create an entry for my own packet looping back on 
			// a mcast group where loopback has not been turned off
			if (pMySSRC->SSRC != dwSSRC)
				{
				// new party heard from. Create an entry for it
				pSSRC = createSSRCEntry (dwSSRC,
										 pRTPSession->pRTCPSession,
										 pFrom,
										 fromlen,
										 FALSE);

				// notify application if interested
				RRCMnotification (RRCM_NEW_SOURCE_EVENT, pSSRC, dwSSRC, 
								  pRTPHeader->pt);
				}
			else
				{
				// my own SSRC received back

				// A collision occurs if the SSRC in the rcvd packet is 
				// equal to mine, and the network transport address is
				// different from mine.
				// A loop occurs if after a collision has been resolved the
				// SSRC collides again from the same source transport address
				pSSRCadr = (PSOCKADDR_IN)&pMySSRC->from;
				if (((PSOCKADDR_IN)pFrom)->sin_addr.S_un.S_addr !=
					  pSSRCadr->sin_addr.S_un.S_addr)
					{
					// check if the source address is already in the 
					// conflicting table. This identifes that somebody out 
					// there is looping pckts back to me
					if (RRCMChkCollisionTable (pFrom, fromlen, pMySSRC))
						{
						RRCM_DBG_MSG ("RTP : Loop Detected ...", 0, NULL, 0,
										DBG_NOTIFY);

						// loop already known
						dwStatus |= SSRC_LOOP_DETECTED;
						}
					else
						{
						RRCM_DBG_MSG ("RTP : Collision Detected ...", 0, NULL, 0,
										DBG_NOTIFY);

						// create new entry in conflicting address table 
						RRCMAddEntryToCollisionTable (pFrom, fromlen, pMySSRC);

						// send RTCP BYE packet w/ old SSRC 
						RTCPsendBYE (pMySSRC, "Loop/collision detected");

						// select new SSRC
						oldSSRC = pMySSRC->SSRC;
						dwSSRC  = getSSRC (pMySSRC->pRTCPses->RcvSSRCList, 
										   pMySSRC->pRTCPses->XmtSSRCList);

					 	EnterCriticalSection (&pMySSRC->critSect);
						pMySSRC->SSRC = dwSSRC;
					 	LeaveCriticalSection (&pMySSRC->critSect);

						// create new entry w/ old SSRC plus actual source
						// transport address in our receive list side, so the 
						// packet actually en-route will be dealt with
						createSSRCEntry (oldSSRC,
										 pRTPSession->pRTCPSession,
										 pFrom,
										 fromlen,
										 FALSE);

						// notify application if interested
						RRCMnotification (RRCM_LOCAL_COLLISION_EVENT, 
										  pMySSRC, oldSSRC, 0);

						// loop already known
						dwStatus |= SSRC_COLLISION_DETECTED;
						}
					}
				else
					{
					// own packet looped back because the sender joined the
					// multicast group and loopback is not turned off
					dwStatus |= MCAST_LOOPBACK_NOT_OFF;
					}
				}
			}
		else if (pSSRC->dwSSRCStatus & THIRD_PARTY_COLLISION)
			{
			// this SSRC is marked as colliding. Reject the data
			dwStatus = THIRD_PARTY_COLLISION;
			}

		if (dwStatus == 0)
			{
			// do all the statistical updating stuff
			updateRTPStats (pRTPHeader, pSSRC, cbTransferred);

			// update the payload type for this SSRC
			pSSRC->PayLoadType = pRTPHeader->pt;

			}	// SSRCList != NULL
		}		// valid RTP Header
	else 
		{
		dwStatus |= INVALID_RTP_HEADER;
		}


	IN_OUT_STR ("RTP : Exit RTPReceiveCallback()\n");
	return dwStatus;
	}

/*----------------------------------------------------------------------------
 * Function   : validateRTPHeader
 * Description: Performs basic checking of RTP Header (e.g., version number 
 *				and	payload type range).
 * 
 * Input : pRTPHeader:	-> to an RTP header
 *
 * Return: TRUE, RTP Packet Header is valid
 *		   FALSE: Header is invalid
 ---------------------------------------------------------------------------*/
 BOOL validateRTPHeader(RTP_HDR_T *pRTPHeader)
	{   
	BOOL	bStatus = TRUE;

	IN_OUT_STR ("RTP : Enter validateRTPHeader()\n");

	if (! pRTPHeader)
		return FALSE;

	// Check version number is correct
	if (pRTPHeader->type != RTP_TYPE) 
		bStatus = FALSE;
	                                  
	// Next check that the Packet types look somewhat reasonable, 
	// at least out of the RTCP range
	if (pRTPHeader->pt >= RTCP_SR)
		bStatus = FALSE;

	IN_OUT_STR ("RTP : Exit validateRTPHeader()\n");
	
	return bStatus;
	}


#if 0
/*----------------------------------------------------------------------------
 * Function   : RTPRecvFrom
 * Description: Intercepts receive requests from app.  Handles any statistical
 *				processing required for RTCP.  Copies completion routine 
 *				from app and substitutes its own.  Apps completion routine
 *				will be called after RTP's completion routine gets called.
 * 
 * Input :	RTPsocket:			RTP socket descriptor
 *			pBuffers:			-> to WSAbuf structure
 *		  	dwBufferCount:		Buffer count in WSAbuf structure
 *			pNumBytesRecvd:		-> to number of bytes received
 *			pFlags:				-> to flags
 *			pFrom:				-> to the source address
 *			pFromLen:			-> to source address length
 *			pOverlapped:		-> to overlapped I/O structure
 *			pCompletionRoutine:	-> to completion routine
 *
 * Return: RRCM_NoError		= OK.
 *         Otherwise(!=0)	= Check RRCM.h file for references.
 ---------------------------------------------------------------------------*/
 DWORD WINAPI RTPRecvFrom (SOCKET RTPsocket,
					        LPWSABUF pBuffers,
						    DWORD  dwBufferCount,
						    LPDWORD pNumBytesRecvd, 
						    LPDWORD pFlags,
						    PSOCKADDR pFrom,
						    LPINT pFromlen,
						    LPWSAOVERLAPPED pOverlapped, 
						    LPWSAOVERLAPPED_COMPLETION_ROUTINE pCompletionRoutine)
	{
	int					dwStatus = RRCM_NoError;
	int					dwError;
	PRTP_SESSION		pRTPSession;
	PRTP_BFR_LIST		pRCVStruct;

	IN_OUT_STR ("RTP : Enter RTPRecvFrom()\n");

	// If RTP context doesn't exist, report error and return.
	if (pRTPContext == NULL) 
		{
		RRCM_DBG_MSG ("RTP : ERROR - No RTP Instance", 0, 
						__FILE__, __LINE__, DBG_CRITICAL);
		IN_OUT_STR ("RTP : Exit RTPRecvFrom()\n");

		return (MAKE_RRCM_ERROR(RRCMError_RTPInvalid));
		}

	// Search for the proper session based on incoming socket
	pRTPSession = findSessionID(RTPsocket);
	if (pRTPSession == NULL)
		{
		RRCM_DBG_MSG ("RTP : ERROR - Invalid RTP session", 0, 
					  __FILE__, __LINE__, DBG_CRITICAL);
		IN_OUT_STR ("RTP : Exit RTPRecvFrom()\n");

		return (MAKE_RRCM_ERROR(RRCMError_RTPInvalidSession));
		}

	// We need to associate a completionRoutine's lpOverlapped with a 
	// session. We look at each buffer and associate a socket so when 
	// the completion routine is called, we can pull out the socket.
	if (dwStatus = saveRCVWinsockContext(pOverlapped,
										  pBuffers,
					   					  pCompletionRoutine,
					   					  pRTPSession,
					   					  dwBufferCount,
			  		   					  pNumBytesRecvd, 
					   					  pFlags,
					   					  pFrom,
					   					  pFromlen,
					   					  RTPsocket) != RRCM_NoError)
		{
		RRCM_DBG_MSG ("RTP : ERROR - Out of resources...", 0, 
					  __FILE__, __LINE__, DBG_NOTIFY);
		IN_OUT_STR ("RTP : Exit RTPRecvFrom()\n");

		return (MAKE_RRCM_ERROR(dwStatus));
		}

	// Forward to winsock, substituting our completion routine for the
	//	one handed to us.
	dwStatus = RRCMws.recvFrom (RTPsocket,
			   		  			pBuffers,
			              		dwBufferCount,
		   				  		pNumBytesRecvd, 
		   				  		pFlags,
		   				  		pFrom,
		    		  			pFromlen,
			   			  		pOverlapped,
			   			  		RTPReceiveCallback); 

	// Check if Winsock Call succeeded
	if (dwStatus != 0) 
		{
		// If serious error, the receive request won't proceed so
		//	we must undo all our work
		dwError = GetLastError();
		if ((dwError != WSA_IO_PENDING) && (dwError != WSAEMSGSIZE)) 
			{
			// Reinstate the Apps WSAEVENT
			pRCVStruct = (PRTP_BFR_LIST)pOverlapped->hEvent;
			pOverlapped->hEvent =  pRCVStruct->hEvent;

			RRCM_DBG_MSG ("RTP : ERROR - WSARecvFrom()", dwError, 
						  __FILE__, __LINE__, DBG_NOTIFY);

			// Return the struct to the free queue
			addToHeadOfList (&pRTPSession->pRTPFreeList,
					 	  	 (PLINK_LIST)pRCVStruct,
							 &pRTPSession->critSect);
			}
		}
	
	IN_OUT_STR ("RTP : Exit RTPRecvFrom()\n");

	return (dwStatus);
	}
	
/*----------------------------------------------------------------------------
 * Function   : RTPReceiveCallback
 * Description: Callback routine from Winsock2  Handles any statistical
 *				processing required for RTCP.  Copies completion routine 
 *				from app and substitutes its own.  Apps completion routine
 *				will be called after RTP's completion routine gets called.
 * 
 * Input :		dwError:		I/O completion error code
 *				cbTransferred:	Number of bytes transferred
 *				pOverlapped:	-> to overlapped I/O structure
 *				dwFlags:		Flags
 *
 * !!! IMPORTANT NOTE !!!
 *   Currently assumes CSRC = 0
 * !!! IMPORTANT NOTE !!!
 *
 * Return: None
 ---------------------------------------------------------------------------*/
void CALLBACK RTPReceiveCallback (DWORD dwError,
           				  		  DWORD cbTransferred,
           				  		  LPWSAOVERLAPPED pOverlapped,
           				  		  DWORD dwFlags)
	{
	PRTP_SESSION		pRTPSession;
	RTP_HDR_T 			*pRTPHeader;
	PRTP_BFR_LIST		pRCVStruct;
	PSSRC_ENTRY			pSSRC = NULL;
	DWORD				dwSSRC;
	DWORD				oldSSRC;
	PSSRC_ENTRY			pMySSRC;
	DWORD				dwRequeue = 0;
	struct sockaddr_in	*pSSRCadr;

	IN_OUT_STR ("RTP : Enter RTPReceiveCallback()\n");

	// GEORGEJ: catch Winsock 2 bug (94903) where I get a bogus callback
	// after WSARecv returns WSAEMSGSIZE.
	if (!dwError && ((int) cbTransferred < 0)) {
		RRCM_DBG_MSG ("RTP : RCV Callback : bad cbTransferred", cbTransferred, 
						  __FILE__, __LINE__, DBG_ERROR);
		return;
	}
	// The returning hEvent in the LPWSAOVERLAPPED struct contains the 
	// information mapping the session and the buffer.
	pRCVStruct = (PRTP_BFR_LIST)pOverlapped->hEvent;

	// Search for the proper session based on incoming socket
	pRTPSession = (PRTP_SESSION)pRCVStruct->pSession;
	ASSERT (pRTPSession);

	// If Winsock error or runt packet(used to cancel recvs), signal completion to application 
	// and do not repost.
	if (dwError || cbTransferred < RTP_HDR_MIN_LEN)
		{
		// don't report closeSocket() as an error when the application
		//  have some pending buffers remaining
		if ((dwError != 65534) && (dwError == WSA_OPERATION_ABORTED))
			{
			RRCM_DBG_MSG ("RTP : RCV Callback", dwError, 
						  __FILE__, __LINE__, DBG_ERROR);
			}

		// notify the user if an error occured, so he can free up 
		// its receive resources. The byte count is set to 0

		// Reinstate the AppSs WSAEVENT
		pOverlapped->hEvent = pRCVStruct->hEvent;
			
		// And call the apps completion routine
		pRCVStruct->pfnCompletionNotification (dwError,
					       					   cbTransferred,
						       				   pOverlapped,
						       				   dwFlags);

		// Return the struct to the free queue
		addToHeadOfList (&pRTPSession->pRTPFreeList,
				 	  	 (PLINK_LIST)pRCVStruct,
						 &pRTPSession->critSect);

		IN_OUT_STR ("RTP : Exit RTPReceiveCallback()\n");
		return;
		}

	// Perform validity checking
    pRTPHeader = (RTP_HDR_T *)pRCVStruct->pBuffer->buf;
	ASSERT (pRTPHeader);

#if (defined(_DEBUG) || defined(PCS_COMPLIANCE))
	if (RTPLogger)
		{
		//INTEROP
		InteropOutput (RTPLogger,
					   (BYTE FAR*)(pRCVStruct->pBuffer->buf),
					   (int)cbTransferred,
					   RTPLOG_RECEIVED_PDU | RTP_PDU);
		}
#endif

	// Check RTP Headers for validity.  If not valid, then repost buffers 
	// to the network layer for a new receive.
	if (validateRTPHeader (pRTPHeader) && (dwError == 0)) 
		{
		// Get pointer to SSRC entry table for this session
		// If SSRC in packet is > 1/2 MAX_RANGE of DWORD, start search from
		//	tail of SSRC list, otherwise, start from front
		RRCMws.ntohl (pRCVStruct->RTPsocket, pRTPHeader->ssrc, &dwSSRC);
					    
		if (dwSSRC > MAX_DWORD/2) 
			{
			pSSRC = searchforSSRCatTail (
				(PSSRC_ENTRY)pRTPSession->pRTCPSession->RcvSSRCList.prev,
				dwSSRC);
			}
		else 
			{
			pSSRC = searchforSSRCatHead (
				(PSSRC_ENTRY)pRTPSession->pRTCPSession->RcvSSRCList.next,
				dwSSRC);
			}

		// get my own SSRC used for this stream
		pMySSRC = searchForMySSRC (
			(PSSRC_ENTRY)pRTPSession->pRTCPSession->XmtSSRCList.prev,
			pRCVStruct->RTPsocket);
		ASSERT (pMySSRC);
		
		// is this SSRC already known on the receive list ?
		if (pSSRC == NULL) 
			{
			// don't create an entry for my own packet looping back on 
			// a mcast group where loopback has not been turned off
			if (pMySSRC->SSRC != dwSSRC)
				{
				// new party heard from. Create an entry for it
				pSSRC = createSSRCEntry (dwSSRC,
										 pRTPSession->pRTCPSession,
										 (PSOCKADDR)pRCVStruct->pFrom,
										 (DWORD)*pRCVStruct->pFromlen,
										 FALSE);

				// notify application if interested
				RRCMnotification (RRCM_NEW_SOURCE_EVENT, pSSRC, dwSSRC, 
								  pRTPHeader->pt);
				}
			else
				{
				// my own SSRC received back

				// A collision occurs if the SSRC in the rcvd packet is 
				// equal to mine, and the network transport address is
				// different from mine.
				// A loop occurs if after a collision has been resolved the
				// SSRC collides again from the same source transport address
				pSSRCadr = (PSOCKADDR_IN)&pMySSRC->from;
				if (((PSOCKADDR_IN)pRCVStruct->pFrom)->sin_addr.S_un.S_addr !=
					  pSSRCadr->sin_addr.S_un.S_addr)
					{
					// check if the source address is already in the 
					// conflicting table. This identifes that somebody out 
					// there is looping pckts back to me
					if (RRCMChkCollisionTable ((PSOCKADDR)pRCVStruct->pFrom,*pRCVStruct->pFromlen, pMySSRC))
						{
						RRCM_DBG_MSG ("RTP : Loop Detected ...", 0, NULL, 0,
										DBG_NOTIFY);

						// loop already known
						dwRequeue |= SSRC_LOOP_DETECTED;
						}
					else
						{
						RRCM_DBG_MSG ("RTP : Collision Detected ...", 0, NULL, 0,
										DBG_NOTIFY);

						// create new entry in conflicting address table 
						RRCMAddEntryToCollisionTable ((PSOCKADDR)pRCVStruct->pFrom,*pRCVStruct->pFromlen, pMySSRC);

						// send RTCP BYE packet w/ old SSRC 
						RTCPsendBYE (pMySSRC, "Loop/collision detected");

						// select new SSRC
						oldSSRC = pMySSRC->SSRC;
						dwSSRC  = getSSRC (pMySSRC->pRTCPses->RcvSSRCList, 
										   pMySSRC->pRTCPses->XmtSSRCList);

					 	EnterCriticalSection (&pMySSRC->critSect);
						pMySSRC->SSRC = dwSSRC;
					 	LeaveCriticalSection (&pMySSRC->critSect);

						// create new entry w/ old SSRC plus actual source
						// transport address in our receive list side, so the 
						// packet actually en-route will be dealt with
						createSSRCEntry (oldSSRC,
										 pRTPSession->pRTCPSession,
										 (PSOCKADDR)pRCVStruct->pFrom,
										 (DWORD)*pRCVStruct->pFromlen,
										 FALSE);

						// notify application if interested
						RRCMnotification (RRCM_LOCAL_COLLISION_EVENT, 
										  pMySSRC, oldSSRC, 0);

						// loop already known
						dwRequeue |= SSRC_COLLISION_DETECTED;
						}
					}
				else
					{
					// own packet looped back because the sender joined the
					// multicast group and loopback is not turned off
					dwRequeue |= MCAST_LOOPBACK_NOT_OFF;
					}
				}
			}
		else if (pSSRC->dwSSRCStatus & THIRD_PARTY_COLLISION)
			{
			// this SSRC is marked as colliding. Reject the data
			dwRequeue = THIRD_PARTY_COLLISION;
			}

		if ((pSSRC != NULL)  && (dwRequeue == 0))
			{
			// do all the statistical updating stuff
			updateRTPStats (pRTPHeader, pSSRC, cbTransferred);

			// update the payload type for this SSRC
			pSSRC->PayLoadType = pRTPHeader->pt;

			// Reinstate the AppSs WSAEVENT
			pOverlapped->hEvent = pRCVStruct->hEvent;
			
			// And call the apps completion routine
			pRCVStruct->pfnCompletionNotification (dwError,
						       					   cbTransferred,
							       				   pOverlapped,
							       				   dwFlags);

			// Return the struct to the free queue
			addToHeadOfList (&pRTPSession->pRTPFreeList,
					 	  	 (PLINK_LIST)pRCVStruct,
							 &pRTPSession->critSect);
			}	// SSRCList != NULL
		}		// valid RTP Header
	else 
		{
		dwRequeue |= INVALID_RTP_HEADER;
		}

	if (dwRequeue) 
		{
		// The RTP packet was invalid for some reason
		RTPpostRecvBfr (dwError, cbTransferred, pOverlapped, dwFlags);
		} 

	IN_OUT_STR ("RTP : Exit RTPReceiveCallback()\n");
	}


/*----------------------------------------------------------------------------
 * Function   : saveRCVWinsockContext
 * Description: Saves context for this buffer so that when a completion 
 *				routine	returns with a handle, we know exactly what 
 *				buffer/stream this refers to.
 * 
 * Input :		pOverlapped		:	-> to overlapped structure
 *				pBuffers		:	-> to WSA buffers
 *				pFunc			:	-> to completion routine 
 *				pSession		:	-> to the RTP session
 *				dwBufferCount	:	Number of WSA buffers
 *				pNumBytesRecvd	:	-> to number of bytes received 
 *				pFlags			:	-> to flags
 *				pFrom			:	-> to the From address field
 *				pFromlen		:	-> to the from address field length
 *				RTPsocket		:	RTP socket descriptor
 *
 * Return: RRCM_NoError		= OK.
 *         Otherwise(!=0)	= Check RRCM.h file for references.
 ---------------------------------------------------------------------------*/
DWORD CALLBACK saveRCVWinsockContext(LPWSAOVERLAPPED pOverlapped,
				   					 LPWSABUF pBuffers,
				   					 LPWSAOVERLAPPED_COMPLETION_ROUTINE pFunc, 
				   					 PRTP_SESSION pSession,
								   	 DWORD dwBufferCount,
							   		 LPDWORD pNumBytesRecvd, 
									 LPDWORD pFlags,
							      	 LPVOID pFrom,
							      	 LPINT pFromlen,
							      	 SOCKET RTPsocket)
	{
	PRTP_BFR_LIST	pNewCell;
	DWORD			dwStatus = RRCM_NoError;
	DWORD			numCells = NUM_FREE_CONTEXT_CELLS;

	IN_OUT_STR ("RTP : Enter saveRCVWinsockContext()\n");
	
	// Get a PRTP Buffer from the free list
	pNewCell = (PRTP_BFR_LIST)removePcktFromTail (
								(PLINK_LIST)&pSession->pRTPFreeList,
								&pSession->critSect);

	if (pNewCell == NULL)
		{
		// try to reallocate some free cells
		if (pSession->dwNumTimesFreeListAllocated <= MAXNUM_CONTEXT_CELLS_REALLOC)
			{
			// increment the number of reallocated times even if the realloc
			//   fails next. Will avoid trying to realloc of a realloc problem
			pSession->dwNumTimesFreeListAllocated++;

			if (allocateLinkedList (&pSession->pRTPFreeList, 
								    pSession->hHeapFreeList,
		   							&numCells,
	   								sizeof(RTP_BFR_LIST),
									&pSession->critSect) == RRCM_NoError)
				{		 						
				pNewCell = (PRTP_BFR_LIST)removePcktFromTail (
											(PLINK_LIST)&pSession->pRTPFreeList,
											&pSession->critSect);
				}
			}
		}

	if (pNewCell != NULL) 
		{
		// Initialize the params
		pNewCell->hEvent		  = pOverlapped->hEvent;
		pNewCell->pBuffer		  = pBuffers;
		pNewCell->pSession		  = pSession;
		pNewCell->dwFlags		  = *pFlags;
		pNewCell->pFrom			  = pFrom;
		pNewCell->pFromlen		  = pFromlen;
		pNewCell->RTPsocket		  = RTPsocket;
		pNewCell->dwBufferCount   = dwBufferCount;
		pNewCell->pfnCompletionNotification = pFunc;		
		
		// Overwrite the hEvent handed down from app.  
		// Will return the real one when the completion routine is called
		pOverlapped->hEvent = (WSAEVENT)pNewCell;
		}
	else
		dwStatus = RRCMError_RTPResources;

	IN_OUT_STR ("RTP : Exit saveRCVWinsockContext()\n");
	
	return (dwStatus);
	}



/*----------------------------------------------------------------------------
 * Function   : RTPpostRecvBfr
 * Description: RTP post a receive buffer to Winsock
 * 
 * Input :      dwError			: Error code
 *    			cbTransferred	: Bytes transferred
 *				pOverlapped		: -> to overlapped structure
 *				dwFlags			: Flags
 *
 * Return: 		None
 ---------------------------------------------------------------------------*/
 void RTPpostRecvBfr (DWORD dwError,
           			  DWORD cbTransferred,
           			  LPWSAOVERLAPPED pOverlapped,
           			  DWORD dwFlags)
	{
	DWORD			dwStatus;
	PRTP_BFR_LIST  	pRCVStruct;
	PRTP_SESSION	pRTPSession;

	IN_OUT_STR ("RTP : Enter RTPpostRecvBfr\n");

	// Reuse the packet with another receive
	pRCVStruct = (PRTP_BFR_LIST)pOverlapped->hEvent;

	// Corresponding RTP session
	pRTPSession = (PRTP_SESSION)pRCVStruct->pSession;

	dwStatus = RRCMws.recvFrom (pRCVStruct->RTPsocket,
		   			  			pRCVStruct->pBuffer,
			              		pRCVStruct->dwBufferCount,
			   			  		&cbTransferred, 
			   			  		&pRCVStruct->dwFlags,
			   			  		(PSOCKADDR)pRCVStruct->pFrom,
			    		  		pRCVStruct->pFromlen,
			   			  		pOverlapped, 
			   			  		RTPReceiveCallback); 

	// Check if Winsock Call succeeded
	if (dwStatus == SOCKET_ERROR) 
		{
		// If serious error, the receive request won't proceed
		dwStatus = GetLastError();
		if ((dwStatus != WSA_IO_PENDING) && (dwStatus != WSAEMSGSIZE)) 
			{
			RRCM_DBG_MSG ("RTP : ERROR - WSARecvFrom()", dwError, 
						  __FILE__, __LINE__, DBG_ERROR);

			// notify the user if an error occured, so he can free up 
			// its receive resources. The byte count is set to 0

			// Reinstate the AppSs WSAEVENT
			pOverlapped->hEvent = pRCVStruct->hEvent;
			
			// And call the apps completion routine
			pRCVStruct->pfnCompletionNotification (dwStatus,
					       					       0,
								       			   pOverlapped,
								       			   dwFlags);

			// Return the receive structure to the free list
			addToHeadOfList (&pRTPSession->pRTPFreeList,
					 	  	 (PLINK_LIST)pRCVStruct,
							 &pRTPSession->critSect);
			}
		}

	IN_OUT_STR ("RTP : Exit RTPpostRecvBfr\n");
	}
#endif


// [EOF]