/*---------------------------------------------------------------------------- * File: RTCPSESS.C * Product: RTP/RTCP implementation * Description: Provides RTCP session management. * * INTEL Corporation Proprietary Information * This listing is supplied under the terms of a license agreement with * Intel Corporation and may 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 PRTCP_CONTEXT pRTCPContext; extern PRTP_CONTEXT pRTPContext; extern RRCM_WS RRCMws; #ifdef ENABLE_ISDM2 extern ISDM2 Isdm2; #endif #ifdef _DEBUG extern char debug_string[]; #endif #if (defined(_DEBUG) || defined(PCS_COMPLIANCE)) //INTEROP extern LPInteropLogger RTPLogger; #endif /*---------------------------------------------------------------------------- * Function : CreateRTCPSession * Description: Creates an RTCP session. * * Input : RTPsd : RTP socket descriptor * RTCPsd : RTCP socket descriptor * lpTo : To address * toLen : To address length * pSdesInfo : -> to SDES information * dwStreamClock : Stream clocking frequency * pEncryptInfo : -> to encryption information * ssrc : If set, user selected SSRC * pSSRCcallback : Callback for user's selected SSRC * dwCallbackInfo : User callback information * miscInfo : Miscelleanous information: * H.323Conf: 0x00000002 * Encrypt SR/RR: 0x00000004 * RTCPon: 0x00000008 * dwRtpSessionBw : RTP session bandwidth used for RTCP BW * *pRTCPStatus : -> to status information * * Return: NULL : Couldn't create RTCP session * !0 : RTCP session's address ---------------------------------------------------------------------------*/ PRTCP_SESSION CreateRTCPSession (SOCKET RTPsd, SOCKET RTCPsd, LPVOID lpTo, DWORD toLen, PSDES_DATA pSdesInfo, DWORD dwStreamClock, PENCRYPT_INFO pEncryptInfo, DWORD ssrc, PRRCM_EVENT_CALLBACK pRRCMcallback, DWORD_PTR dwCallbackInfo, DWORD miscInfo, DWORD dwRtpSessionBw, DWORD *pRTCPstatus) { PRTCP_SESSION pRTCPses = NULL; PSSRC_ENTRY pSSRCentry = NULL; DWORD dwStatus = RRCM_NoError; DWORD startRtcp = FALSE; char hName[256]; int tmpSize; struct sockaddr_in *pSockAddr; IN_OUT_STR ("RTCP: Enter CreateRTCPSession()\n"); // set status *pRTCPstatus = RRCM_NoError; // allocate all required resources for the RTCP session dwStatus = allocateRTCPsessionResources (&pRTCPses, &pSSRCentry); if (dwStatus != RRCM_NoError) { RRCM_DBG_MSG ("RTCP: ERROR - Resource allocation failed", 0, __FILE__, __LINE__, DBG_CRITICAL); IN_OUT_STR ("RTCP: Exit CreateRTCPSession()\n"); *pRTCPstatus = dwStatus; return (NULL); } // if this is the first session, create the RTCP thread, which // will be killed when no more sessions exist. if (pRTCPContext->RTCPSession.prev == NULL) { startRtcp = TRUE; } // save the parent RTCP session address in the SSRC entry pSSRCentry->pRTCPses = pRTCPses; // network destination address if (toLen) { pRTCPses->dwSessionStatus = RTCP_DEST_LEARNED; pRTCPses->toLen = toLen; memcpy (&pRTCPses->toBfr, lpTo, toLen); } // mark the session as new for the benefit of the RTCP thread pRTCPses->dwSessionStatus |= NEW_RTCP_SESSION; #ifdef ENABLE_ISDM2 // initialize the session key in case ISDM is used pRTCPses->hSessKey = NULL; #endif // number of SSRC for this RTCP session pRTCPses->dwCurNumSSRCperSes = 1; #ifdef MONITOR_STATS pRTCPses->dwHiNumSSRCperSes = 1; #endif // SSRC entry related information pSSRCentry->RTPsd = RTPsd; pSSRCentry->RTCPsd = RTCPsd; // get our own transport address - // will be used for collision resolution when using multicast tmpSize = sizeof (SOCKADDR); dwStatus = RRCMws.getsockname (RTPsd, (PSOCKADDR)pSSRCentry->from, &tmpSize); // only process when no error is reported. If the socket is not bound // it won't cause any problem for unicast or multicast if the sender // has not join the mcast group. If the sender joins the mcast group // it's socket should be bound by now as specified in the EPS if (dwStatus == 0) { // if bound to INADDR_ANY, address will be 0 pSockAddr = (PSOCKADDR_IN)&pSSRCentry->from; if (pSockAddr->sin_addr.s_addr == 0) { // get the host name (to get the local IP address) if ( ! RRCMws.gethostname (hName, sizeof(hName))) { LPHOSTENT lpHEnt; // get the host by name infor if ((lpHEnt = RRCMws.gethostbyname (hName)) != NULL) { // get the local IP address pSockAddr->sin_addr.s_addr = *((u_long *)lpHEnt->h_addr_list[0]); } } } } // build session's SDES information buildSDESinfo (pSSRCentry, pSdesInfo); // link the SSRC to the RTCP session list of Xmt SSRCs entries addToHeadOfList (&(pRTCPses->XmtSSRCList), (PLINK_LIST)pSSRCentry, &pRTCPses->critSect); // initialize the number of stream for this session pRTCPses->dwNumStreamPerSes = 1; // get a unique SSRC for this session if (ssrc) pSSRCentry->SSRC = ssrc; else pSSRCentry->SSRC = getSSRC (pRTCPses->XmtSSRCList, pRTCPses->RcvSSRCList); // RRCM callback notification pRTCPses->pRRCMcallback = pRRCMcallback; pRTCPses->dwCallbackUserInfo = dwCallbackInfo; // set operation flag if (miscInfo & H323_CONFERENCE) pRTCPses->dwSessionStatus |= H323_CONFERENCE; if (miscInfo & ENCRYPT_SR_RR) pRTCPses->dwSessionStatus |= ENCRYPT_SR_RR; // estimate the initial session bandwidth if (dwRtpSessionBw == 0) { pSSRCentry->xmtInfo.dwRtcpStreamMinBW = INITIAL_RTCP_BANDWIDTH; } else { // RTCP bandwidth is 5% of the RTP bandwidth pSSRCentry->xmtInfo.dwRtcpStreamMinBW = (dwRtpSessionBw * 5) / 100; } // the stream clocking frequency pSSRCentry->dwStreamClock = dwStreamClock; // initialize 'dwLastReportRcvdTime' to now pSSRCentry->dwLastReportRcvdTime = timeGetTime(); #ifdef _DEBUG wsprintf(debug_string, "RTCP: Add new RTCP session: Addr:x%lX", pRTCPses); RRCM_DBG_MSG (debug_string, 0, NULL, 0, DBG_TRACE); wsprintf(debug_string, "RTCP: Add SSRC entry (Addr:x%lX, SSRC=x%lX) to session (Addr:x%lX)", pSSRCentry, pSSRCentry->SSRC, pRTCPses); RRCM_DBG_MSG (debug_string, 0, NULL, 0, DBG_TRACE); pSSRCentry->dwPrvTime = timeGetTime(); #endif // turn on RTCP or not if (miscInfo & RTCP_ON) { // this session sends and receives RTCP reports pRTCPses->dwSessionStatus |= RTCP_ON; } // link the RTCP session to the head of the list of RTCP sessions addToHeadOfList (&(pRTCPContext->RTCPSession), (PLINK_LIST)pRTCPses, &pRTCPContext->critSect); #ifdef ENABLE_ISDM2 // register to ISDM only if destination address is known if (Isdm2.hISDMdll && (pRTCPses->dwSessionStatus & RTCP_DEST_LEARNED)) registerSessionToISDM (pSSRCentry, pRTCPses, &Isdm2); #endif // create the RTCP thread if needed if (startRtcp == TRUE) { // No RTCP thread if this fail dwStatus = CreateRTCPthread (); if (dwStatus != RRCM_NoError) { RRCM_DBG_MSG ("RTCP: ERROR - Cannot create RTCP thread", 0, __FILE__, __LINE__, DBG_CRITICAL); IN_OUT_STR ("RTCP: Exit CreateRTCPSession()\n"); *pRTCPstatus = dwStatus; return (NULL); } } IN_OUT_STR ("RTCP: Exit CreateRTCPSession()\n"); return (pRTCPses); } /*---------------------------------------------------------------------------- * Function : allocateRTCPsessionResources * Description: Allocate all required resources for an RTCP session. * * Input : *pRTCPses: ->(->) to the RTCP session's information * *pSSRCentry: ->(->) to the SSRC's entry * * Return: OK: RRCM_NoError * !0: Error code (see RRCM.H) ---------------------------------------------------------------------------*/ DWORD allocateRTCPsessionResources (PRTCP_SESSION *pRTCPses, PSSRC_ENTRY *pSSRCentry) { DWORD dwStatus = RRCM_NoError; IN_OUT_STR ("RTCP: Enter allocateRTCPsessionResources()\n"); // get an RTCP session *pRTCPses = (PRTCP_SESSION)HeapAlloc (pRTCPContext->hHeapRTCPSes, HEAP_ZERO_MEMORY, sizeof(RTCP_SESSION)); if (*pRTCPses == NULL) dwStatus = RRCMError_RTCPResources; // 'defined' RTCP resources if (dwStatus == RRCM_NoError) { (*pRTCPses)->dwInitNumFreeRcvBfr = NUM_FREE_RCV_BFR; (*pRTCPses)->dwRcvBfrSize = pRTPContext->registry.RTCPrcvBfrSize; (*pRTCPses)->dwXmtBfrSize = RRCM_XMT_BFR_SIZE; // allocate the RTCP session's Rcv/Xmt heaps and Rcv/Xmt buffers dwStatus = allocateRTCPSessionHeaps (pRTCPses); } if (dwStatus == RRCM_NoError) { // initialize this session's critical section InitializeCriticalSection (&(*pRTCPses)->critSect); // allocate free list of RTCP receive buffers dwStatus = allocateRTCPBfrList (&(*pRTCPses)->RTCPrcvBfrList, (*pRTCPses)->hHeapRcvBfrList, (*pRTCPses)->hHeapRcvBfr, &(*pRTCPses)->dwInitNumFreeRcvBfr, (*pRTCPses)->dwRcvBfrSize, &(*pRTCPses)->critSect); } if (dwStatus == RRCM_NoError) { (*pRTCPses)->XmtBfr.buf = (char *)LocalAlloc(0,(*pRTCPses)->dwXmtBfrSize); if ((*pRTCPses)->XmtBfr.buf == NULL) dwStatus = RRCMError_RTCPResources; } if (dwStatus == RRCM_NoError) { // get an SSRC entry *pSSRCentry = getOneSSRCentry (&pRTCPContext->RRCMFreeStat, pRTCPContext->hHeapRRCMStat, &pRTCPContext->dwInitNumFreeRRCMStat, &pRTCPContext->critSect); if (*pSSRCentry == NULL) dwStatus = RRCMError_RTCPResources; } if (dwStatus == RRCM_NoError) { // manual-reset event that will be used to signal the end of the // RTCP session to all of the session's stream (*pRTCPses)->hShutdownDone = CreateEvent (NULL, TRUE, FALSE, NULL); if ((*pRTCPses)->hShutdownDone == NULL) { dwStatus = RRCMError_RTCPResources; RRCM_DBG_MSG ("RTCP: ERROR - CreateEvent()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } // any resource allocation problem ? if (dwStatus != RRCM_NoError) { if (*pSSRCentry) addToHeadOfList (&pRTCPContext->RRCMFreeStat, (PLINK_LIST)*pSSRCentry, &pRTCPContext->critSect); if ((*pSSRCentry)->hXmtThread) { if (TerminateThread ((*pSSRCentry)->hXmtThread, (*pSSRCentry)->dwXmtThreadID) == FALSE) { RRCM_DBG_MSG ("RTCP: ERROR - TerminateThread()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } if (*pRTCPses) { if (HeapFree (pRTCPContext->hHeapRTCPSes, 0, *pRTCPses) == FALSE) { RRCM_DBG_MSG ("RTCP: ERROR - HeapFree()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } } IN_OUT_STR ("RTCP: Exit allocateRTCPsessionResources()\n"); return dwStatus; } /*---------------------------------------------------------------------------- * Function : buildSDESinfo * Description: Build the session's SDES information * * Input : pRTCPses: -> to session's * pSdesInfo: -> to SDES information * * Return: OK: RRCM_NoError * !0: Error code (see RRCM.H) ---------------------------------------------------------------------------*/ DWORD buildSDESinfo (PSSRC_ENTRY pSSRCentry, PSDES_DATA pSdesInfo) { PSDES_DATA pTmpSdes; DWORD CnameOK = FALSE; IN_OUT_STR ("RTCP: Enter buildSDESinfo()\n"); pTmpSdes = pSdesInfo; while (pTmpSdes->dwSdesType) { switch (pTmpSdes->dwSdesType) { case RTCP_SDES_CNAME: pSSRCentry->cnameInfo.dwSdesLength = pTmpSdes->dwSdesLength; memcpy (pSSRCentry->cnameInfo.sdesBfr, pTmpSdes->sdesBfr, pTmpSdes->dwSdesLength); pSSRCentry->cnameInfo.dwSdesFrequency = frequencyToPckt (pTmpSdes->dwSdesFrequency); pSSRCentry->cnameInfo.dwSdesEncrypted = pTmpSdes->dwSdesEncrypted; CnameOK = TRUE; break; case RTCP_SDES_NAME: pSSRCentry->nameInfo.dwSdesLength = pTmpSdes->dwSdesLength; memcpy (pSSRCentry->nameInfo.sdesBfr, pTmpSdes->sdesBfr, pTmpSdes->dwSdesLength); pSSRCentry->nameInfo.dwSdesFrequency = frequencyToPckt (pTmpSdes->dwSdesFrequency); pSSRCentry->nameInfo.dwSdesEncrypted = pTmpSdes->dwSdesEncrypted; break; case RTCP_SDES_EMAIL: pSSRCentry->emailInfo.dwSdesLength = pTmpSdes->dwSdesLength; memcpy (pSSRCentry->emailInfo.sdesBfr, pTmpSdes->sdesBfr, pTmpSdes->dwSdesLength); pSSRCentry->emailInfo.dwSdesFrequency = frequencyToPckt (pTmpSdes->dwSdesFrequency); pSSRCentry->emailInfo.dwSdesEncrypted = pTmpSdes->dwSdesEncrypted; break; case RTCP_SDES_PHONE: pSSRCentry->phoneInfo.dwSdesLength = pTmpSdes->dwSdesLength; memcpy (pSSRCentry->phoneInfo.sdesBfr, pTmpSdes->sdesBfr, pTmpSdes->dwSdesLength); pSSRCentry->phoneInfo.dwSdesFrequency = frequencyToPckt (pTmpSdes->dwSdesFrequency); pSSRCentry->phoneInfo.dwSdesEncrypted = pTmpSdes->dwSdesEncrypted; break; case RTCP_SDES_LOC: pSSRCentry->locInfo.dwSdesLength = pTmpSdes->dwSdesLength; memcpy (pSSRCentry->locInfo.sdesBfr, pTmpSdes->sdesBfr, pTmpSdes->dwSdesLength); pSSRCentry->locInfo.dwSdesFrequency = frequencyToPckt (pTmpSdes->dwSdesFrequency); pSSRCentry->locInfo.dwSdesEncrypted = pTmpSdes->dwSdesEncrypted; break; case RTCP_SDES_TOOL: pSSRCentry->toolInfo.dwSdesLength = pTmpSdes->dwSdesLength; memcpy (pSSRCentry->toolInfo.sdesBfr, pTmpSdes->sdesBfr, pTmpSdes->dwSdesLength); pSSRCentry->toolInfo.dwSdesFrequency = frequencyToPckt (pTmpSdes->dwSdesFrequency); pSSRCentry->toolInfo.dwSdesEncrypted = pTmpSdes->dwSdesEncrypted; break; case RTCP_SDES_TXT: pSSRCentry->txtInfo.dwSdesLength = pTmpSdes->dwSdesLength; memcpy (pSSRCentry->txtInfo.sdesBfr, pTmpSdes->sdesBfr, pTmpSdes->dwSdesLength); pSSRCentry->txtInfo.dwSdesFrequency = frequencyToPckt (pTmpSdes->dwSdesFrequency); pSSRCentry->txtInfo.dwSdesEncrypted = pTmpSdes->dwSdesEncrypted; break; case RTCP_SDES_PRIV: pSSRCentry->privInfo.dwSdesLength = pTmpSdes->dwSdesLength; memcpy (pSSRCentry->privInfo.sdesBfr, pTmpSdes->sdesBfr, pTmpSdes->dwSdesLength); pSSRCentry->privInfo.dwSdesFrequency = frequencyToPckt (pTmpSdes->dwSdesFrequency); pSSRCentry->privInfo.dwSdesEncrypted = pTmpSdes->dwSdesEncrypted; break; } pTmpSdes++; } // default CNAME if none provided if (CnameOK == FALSE) { pSSRCentry->cnameInfo.dwSdesLength = sizeof(szDfltCname); memcpy (pSSRCentry->cnameInfo.sdesBfr, szDfltCname, sizeof(szDfltCname)); pSSRCentry->cnameInfo.dwSdesFrequency = 1; pSSRCentry->cnameInfo.dwSdesEncrypted = 0; } IN_OUT_STR ("RTCP: Exit buildSDESinfo()\n"); return (RRCM_NoError); } /*---------------------------------------------------------------------------- * Function : frequencyToPckt * Description: Transform the required frequency to a number of packet. (To * be used by a modulo function) * * Input : freq: Desired frequency from 0 to 100 * * Return: X: Packet to skip, ie, one out of X ---------------------------------------------------------------------------*/ DWORD frequencyToPckt (DWORD freq) { if (freq <= 10) return 9; else if (freq <= 20) return 5; else if (freq <= 25) return 4; else if (freq <= 33) return 3; else if (freq <= 50) return 2; else return 1; } /*---------------------------------------------------------------------------- * Function : deleteRTCPSession * Description: Closes an RTCP session. * * Input : RTCPsd : RTCP socket descriptor * byeReason : -> to the BYE reason * * Return: OK: RRCM_NoError * !0: Error code (see RRCM.H) ---------------------------------------------------------------------------*/ DWORD deleteRTCPSession (SOCKET RTCPsd, PCHAR byeReason) { PLINK_LIST pTmp; PSSRC_ENTRY pSSRC; PRTCP_SESSION pRTCP; DWORD dwStatus = RRCM_NoError; DWORD sessionFound = FALSE; IN_OUT_STR ("RTCP: Enter deleteRTCPSEssion()\n"); // walk through the list from the tail pTmp = pRTCPContext->RTCPSession.prev; #ifdef _DEBUG wsprintf(debug_string, "RTCP: Deleting RTCP session: (Addr:x%lX) ...", pTmp); RRCM_DBG_MSG (debug_string, 0, NULL, 0, DBG_TRACE); #endif while (pTmp) { // get the right session to close by walking the transmit list pSSRC = (PSSRC_ENTRY)((PRTCP_SESSION)pTmp)->XmtSSRCList.prev; if (pSSRC->RTCPsd == RTCPsd) { sessionFound = TRUE; // save a pointer to the RTCP session pRTCP = pSSRC->pRTCPses; // RTCP send BYE packet for this active stream RTCPsendBYE (pSSRC, NULL); // flush out any outstanding I/O RTCPflushIO (pSSRC); // if this is the only RTCP session left, terminate the RTCP // timeout thread, so it doesn't access the session when it expires if ((pRTCPContext->RTCPSession.prev)->next == NULL) terminateRtcpThread (); // lock out access to this RTCP session EnterCriticalSection (&pRTCP->critSect); // free all Rcv & Xmt SSRC entries used by this session deleteSSRClist (pRTCP, &pRTCPContext->RRCMFreeStat, pRTCPContext); #ifdef ENABLE_ISDM2 if (Isdm2.hISDMdll && pRTCP->hSessKey) Isdm2.ISDMEntry.ISD_DeleteKey(pRTCP->hSessKey); #endif // release the RTCP session's heap if (pRTCP->hHeapRcvBfrList) { if (HeapDestroy (pRTCP->hHeapRcvBfrList) == FALSE) { RRCM_DBG_MSG ("RTCP: ERROR - HeapDestroy()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } if (pRTCP->hHeapRcvBfr) { if (HeapDestroy (pRTCP->hHeapRcvBfr) == FALSE) { RRCM_DBG_MSG ("RTCP: ERROR - HeapDestroy()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } if (pRTCP->XmtBfr.buf) LocalFree(pRTCP->XmtBfr.buf); // remove the entry from the list of RTCP session if (pTmp->next == NULL) removePcktFromHead (&pRTCPContext->RTCPSession, &pRTCPContext->critSect); else if (pTmp->prev == NULL) removePcktFromTail (&pRTCPContext->RTCPSession, &pRTCPContext->critSect); else { // in between, relink around (pTmp->prev)->next = pTmp->next; (pTmp->next)->prev = pTmp->prev; } // release the critical section LeaveCriticalSection (&pRTCP->critSect); DeleteCriticalSection (&pRTCP->critSect); // put the RTCP session back on its heap if (HeapFree (pRTCPContext->hHeapRTCPSes, 0, pRTCP) == FALSE) { RRCM_DBG_MSG ("RTCP: ERROR - HeapFree()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } break; } pTmp = pTmp->next; } if (sessionFound != TRUE) dwStatus = RRCMError_RTCPInvalidSession; IN_OUT_STR ("RTCP: Exit deleteRTCPSEssion()\n"); return (dwStatus); } /*---------------------------------------------------------------------------- * Function : CreateRTCPthread * Description: Create the RTCP thread / timeout thread depending on * compilation flag. * * Input : None. * * Return: None ---------------------------------------------------------------------------*/ DWORD CreateRTCPthread (void) { DWORD dwStatus = RRCM_NoError; IN_OUT_STR ("RTCP: Enter CreateRTCPthread()\n"); pRTCPContext->hTerminateRtcpEvent = CreateEvent (NULL, TRUE, FALSE, NULL); if (pRTCPContext->hTerminateRtcpEvent == NULL) { dwStatus = RRCMError_RTCPResources; RRCM_DBG_MSG ("RTCP: ERROR - CreateEvent()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } pRTCPContext->hRtcpRptRequestEvent = CreateEvent (NULL, TRUE, FALSE, NULL); if (pRTCPContext->hRtcpRptRequestEvent == NULL) { dwStatus = RRCMError_RTCPResources; RRCM_DBG_MSG ("RTCP: ERROR - CreateEvent()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } if (pRTCPContext->hTerminateRtcpEvent) { // create RTCP thread pRTCPContext->hRtcpThread = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE)RTCPThread, pRTCPContext, 0, &pRTCPContext->dwRtcpThreadID); if (pRTCPContext->hRtcpThread == FALSE) { dwStatus = RRCMError_RTCPThreadCreation; RRCM_DBG_MSG ("RTCP: ERROR - CreateThread()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } #ifdef _DEBUG else { wsprintf(debug_string, "RTCP: Create RTCP thread. Handle: x%lX - ID: x%lX", pRTCPContext->hRtcpThread, pRTCPContext->dwRtcpThreadID); RRCM_DBG_MSG (debug_string, 0, NULL, 0, DBG_TRACE); } #endif } IN_OUT_STR ("RTCP: Exit CreateRTCPthread()\n"); return dwStatus; } /*---------------------------------------------------------------------------- * Function : terminateRtcpThread * Description: Terminate the RTCP thread. * * Input : None. * * Return: None ---------------------------------------------------------------------------*/ void terminateRtcpThread (void) { DWORD dwStatus; IN_OUT_STR ("RTCP: Enter terminateRtcpThread()\n"); if (pRTCPContext->hRtcpThread) { // make sure the RTCP thread is running RTCPThreadCtrl (RTCP_ON); // signal the thread to terminate SetEvent (pRTCPContext->hTerminateRtcpEvent); // wait for the RTCP thread to be signaled dwStatus = WaitForSingleObject (pRTCPContext->hRtcpThread, 500); if (dwStatus == WAIT_OBJECT_0) ; else if ((dwStatus == WAIT_TIMEOUT) || (dwStatus == WAIT_FAILED)) { if (dwStatus == WAIT_TIMEOUT) { RRCM_DBG_MSG ("RTCP: Wait timed-out", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } else { RRCM_DBG_MSG ("RTCP: Wait failed", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } // Force ungraceful thread termination dwStatus = TerminateThread (pRTCPContext->hRtcpThread, 1); if (dwStatus == FALSE) { RRCM_DBG_MSG ("RTCP: ERROR - TerminateThread ()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } // close the thread handle dwStatus = CloseHandle (pRTCPContext->hRtcpThread); if (dwStatus == TRUE) pRTCPContext->hRtcpThread = 0; else { RRCM_DBG_MSG ("RTCP: ERROR - CloseHandle()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } // close the event handle dwStatus = CloseHandle (pRTCPContext->hTerminateRtcpEvent); if (dwStatus == TRUE) pRTCPContext->hTerminateRtcpEvent = 0; else { RRCM_DBG_MSG ("RTCP: ERROR - CloseHandle()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } // close the request handle dwStatus = CloseHandle (pRTCPContext->hRtcpRptRequestEvent); if (dwStatus == TRUE) pRTCPContext->hRtcpRptRequestEvent = 0; else { RRCM_DBG_MSG ("RTCP: ERROR - CloseHandle()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } IN_OUT_STR ("RTCP: Exit terminateRtcpThread()\n"); } /*---------------------------------------------------------------------------- * Function : RTCPflushIO * Description: Flush the receive queue. * * Input : pSSRC: -> to the SSRC entry * * Return: None ---------------------------------------------------------------------------*/ DWORD RTCPflushIO (PSSRC_ENTRY pSSRC) { DWORD dwStatus = RRCM_NoError; int IoToFlush; int waitForXmtTrials; IN_OUT_STR ("RTCP: Enter RTCPflushIO()\n"); // set the flush flag EnterCriticalSection (&pSSRC->pRTCPses->critSect); pSSRC->pRTCPses->dwSessionStatus |= SHUTDOWN_IN_PROGRESS; LeaveCriticalSection (&pSSRC->pRTCPses->critSect); // check if need to flush or close the socket if (pSSRC->dwSSRCStatus & CLOSE_RTCP_SOCKET) { // get the number of outstanding buffers IoToFlush = pSSRC->pRTCPses->dwNumRcvIoPending; #ifdef _DEBUG wsprintf(debug_string, "RTCPflushIO: closing socket(%d) dwNumRcvIoPending (%d)", pSSRC->RTCPsd, pSSRC->pRTCPses->dwNumRcvIoPending); RRCM_DBG_MSG (debug_string, 0, NULL, 0, DBG_TRACE); #endif // make sure it's not < 0 if (IoToFlush < 0) IoToFlush = pRTPContext->registry.NumRTCPPostedBfr; dwStatus = RRCMws.closesocket (pSSRC->RTCPsd); if (dwStatus != 0) { RRCM_DBG_MSG ("RTCP: ERROR - closesocket ()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } else { IoToFlush = flushIO (pSSRC); } // wait for the receive side to flush it's pending I/Os if ((pSSRC->pRTCPses->dwSessionStatus & RTCP_ON) && IoToFlush) { // wait until the receiver signalled that the shutdown is done dwStatus = WaitForSingleObject (pSSRC->pRTCPses->hShutdownDone, 2000); if (dwStatus == WAIT_OBJECT_0) ; else if (dwStatus == WAIT_TIMEOUT) { RRCM_DBG_MSG ("RTCP: Flush Wait timed-out", 0, __FILE__, __LINE__, DBG_ERROR); } else if (dwStatus == WAIT_FAILED) { RRCM_DBG_MSG ("RTCP: Flush Wait failed", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } } // make sure there is no buffers in transit on the transmit side waitForXmtTrials = 3; while (waitForXmtTrials--) { if (pSSRC->dwNumXmtIoPending == 0) break; RRCM_DBG_MSG ("RTCP: Xmt I/O Pending - Waiting", 0, NULL, 0, DBG_TRACE); // wait in an alertable wait-state SleepEx (200, TRUE); } // close the shutdown handle dwStatus = CloseHandle (pSSRC->pRTCPses->hShutdownDone); if (dwStatus == TRUE) pSSRC->pRTCPses->hShutdownDone = 0; else { RRCM_DBG_MSG ("RTCP: ERROR - CloseHandle()", GetLastError(), __FILE__, __LINE__, DBG_ERROR); } IN_OUT_STR ("RTCP: Exit RTCPflushIO()\n"); return (dwStatus); } /*---------------------------------------------------------------------------- * Function : flushIO * Description: Flush the receive queue. * * Input : pSSRC: -> to the SSRC entry * * Return: None ---------------------------------------------------------------------------*/ DWORD flushIO (PSSRC_ENTRY pSSRC) { SOCKET tSocket; SOCKADDR_IN tAddr; char msg[16]; WSABUF msgBuf; DWORD BytesSent; int tmpSize; DWORD dwStatus = RRCM_NoError; int outstanding; int IoToFlush; RTCP_COMMON_T *pRTCPhdr; IN_OUT_STR ("RTCP: Enter flushIO()\n"); // target socket tSocket = pSSRC->RTCPsd; // RTCP common header pRTCPhdr = (RTCP_COMMON_T *)msg; // RTP protocol version pRTCPhdr->type = RTP_TYPE; pRTCPhdr->pt = FLUSH_RTP_PAYLOAD_TYPE; msgBuf.len = sizeof(msg); msgBuf.buf = msg; // get the address of the socket we are cleaning up tmpSize = sizeof(tAddr); if (RRCMws.getsockname (tSocket, (PSOCKADDR)&tAddr, &tmpSize)) { dwStatus = GetLastError(); RRCM_DBG_MSG ("RTCP: ERROR - getsockname()", dwStatus, __FILE__, __LINE__, DBG_ERROR); IN_OUT_STR ("RTP : Exit flushIO()\n"); // (was: return dwStatus;) // Since this function is supposed to return number of pending I/O requests // to this socket, returning a non-zero error here is BOGUS! // Just return zero because if there is an error (socket has been freed) // then just say there's no i/o pending. return 0; } if (tAddr.sin_addr.s_addr == 0) { // send to the local address tAddr.sin_addr.S_un.S_un_b.s_b1 = 127; tAddr.sin_addr.S_un.S_un_b.s_b2 = 0; tAddr.sin_addr.S_un.S_un_b.s_b3 = 0; tAddr.sin_addr.S_un.S_un_b.s_b4 = 1; } // get the number of outstanding buffers outstanding = pSSRC->pRTCPses->dwNumRcvIoPending; // make sure it's not < 0 if (outstanding < 0) outstanding = pRTPContext->registry.NumRTCPPostedBfr; // save number of pending I/Os IoToFlush = outstanding; #if _DEBUG wsprintf(debug_string, "RTCP: Flushing %d outstanding RCV buffers", outstanding); RRCM_DBG_MSG (debug_string, 0, NULL, 0, DBG_TRACE); #endif // send datagrams to the RTCP socket while (outstanding--) { #if (defined(_DEBUG) || defined(PCS_COMPLIANCE)) if (RTPLogger) { //INTEROP InteropOutput (RTPLogger, (BYTE FAR*)msgBuf.buf, (int)msgBuf.len, RTPLOG_SENT_PDU | RTCP_PDU); } #endif dwStatus = RRCMws.sendTo (tSocket, &msgBuf, 1, &BytesSent, 0, (SOCKADDR *)&tAddr, sizeof(tAddr), NULL, #if 1 NULL); #else RTCPflushCallback); #endif if (dwStatus == SOCKET_ERROR) { // If serious error, undo all our work dwStatus = GetLastError(); if (dwStatus != WSA_IO_PENDING) { RRCM_DBG_MSG ("RTCP: ERROR - sendTo()", dwStatus, __FILE__, __LINE__, DBG_ERROR); } } } IN_OUT_STR ("RTCP: Exit flushIO()\n"); return IoToFlush; } /*---------------------------------------------------------------------------- * Function : RTCPflushCallback * Description: Flush callback routine * * Input : dwError: I/O completion status * cbTransferred: Number of bytes received * lpOverlapped: -> to overlapped structure * dwFlags: Flags * * * Return: None ---------------------------------------------------------------------------*/ void CALLBACK RTCPflushCallback (DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags) { IN_OUT_STR ("RTCP: Enter RTCPflushCallback\n"); // check Winsock callback error status if (dwError) { RRCM_DBG_MSG ("RTCP: ERROR - Rcv Callback", dwError, __FILE__, __LINE__, DBG_ERROR); IN_OUT_STR ("RTCP: Exit RTCPflushCallback\n"); return; } IN_OUT_STR ("RTCP: Exit RTCPflushCallback\n"); } // [EOF]