onekopaka/Darwin-Streaming-Server
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
Darwin-Streaming-Server/APIModules/QTSSReflectorModule/QTSSRelayModule.cpp

1275 lines
45 KiB
C++
Raw Normal View History

Add even more of the source This should be about everything needed to build so far?
2017-03-07 17:14:16 -08:00
/*
*
* @APPLE_LICENSE_HEADER_START@
*
* Copyright (c) 1999-2008 Apple Inc. All Rights Reserved.
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*
*/
/*
File: QTSSReflectorModule.cpp
Contains: Implementation of QTSSReflectorModule class.
*/
#include "QTSSRelayModule.h"
#include "QTSSModuleUtils.h"
//#include "ReflectorSession.h"
#include "RelaySession.h"
#include "ReflectorStream.h"
#include "OSArrayObjectDeleter.h"
#include "QTSS_Private.h"
#include "../../defaultPaths.h"
#include "OSMemory.h"
#include "OSRef.h"
#include "IdleTask.h"
#include "Task.h"
#include "OS.h"
#include "Socket.h"
#include "SocketUtils.h"
#include "XMLParser.h"
#include "OSArrayObjectDeleter.h"
//ReflectorOutput objects
#include "RTPSessionOutput.h"
#include "RelayOutput.h"
//SourceInfo objects
#include "SDPSourceInfo.h"
#include "RelaySDPSourceInfo.h"
#include "RCFSourceInfo.h"
#include "RTSPSourceInfo.h"
#include <sys/stat.h>
#ifndef __Win32__
#include <netdb.h>
#endif
#ifndef kVersionString
#include "../../revision.h"
#endif
#if DEBUG
#define REFLECTOR_MODULE_DEBUGGING 0
#else
#define REFLECTOR_MODULE_DEBUGGING 0
#endif
// STATIC DATA
static char* sRelayPrefs = NULL;
static char* sRelayStatsURL = NULL;
static StrPtrLen sRequestHeader;
static QTSS_ModulePrefsObject sPrefs = NULL;
static QTSS_ServerObject sServer = NULL;
static QTSS_Object sAttributes = NULL;
static Bool16 sSkipAuthorization = true;
static Bool16 sIsRelaySession = true;
static char* sIsRelaySessionAttrName = "QTSSRelayModuleIsRelaySession";
static QTSS_AttributeID sIsRelaySessionAttr = qtssIllegalAttrID;
static int sRelayPrefModDate = -1;
// ATTRIBUTES
static QTSS_AttributeID sRelayModulePrefParseErr = qtssIllegalAttrID;
static char* sDefaultRelayPrefs = DEFAULTPATHS_ETC_DIR "relayconfig.xml";
#ifdef __MacOSX__
#define kResponseHeader "HTTP/1.0 200 OK\r\nServer: QuickTimeStreamingServer/%s/%s\r\nConnection: Close\r\nContent-Type: text/html\r\n\r\n<HTML><TITLE>Relay Stats</TITLE><BODY>"
#else
#define kResponseHeader "HTTP/1.0 200 OK\r\nServer: DarwinStreamingServer/%s/%s\r\nConnection: Close\r\nContent-Type: text/html\r\n\r\n<HTML><TITLE>Relay Stats</TITLE><BODY>"
#endif
static char sResponseHeader[1024];
static OSQueue* sSessionQueue = NULL;
static OSQueue* sAnnouncedQueue = NULL;
static OSQueue* sRTSPSourceInfoQueue = NULL;
static OSQueue* sRTSPSessionIDQueue = NULL;
static XMLParser* sRelayPrefsFile = NULL;
static OSMutex sResolverMutex;
class DNSResolverThread;
DNSResolverThread* sResolverThread = NULL;
Bool16 sDoResolveAgain = false;
// This struct is used when Rereading Relay Prefs
struct SourceInfoQueueElem
{
SourceInfoQueueElem(SourceInfo* inInfo, Bool16 inRTSPInfo) :fElem(), fSourceInfo(inInfo),
fIsRTSPSourceInfo(inRTSPInfo),
fShouldDelete(true) { fElem.SetEnclosingObject(this); }
~SourceInfoQueueElem() {}
OSQueueElem fElem;
SourceInfo* fSourceInfo;
Bool16 fIsRTSPSourceInfo;
Bool16 fShouldDelete;
};
// This struct is used when setting up announced source relays
struct RTSPSessionIDQueueElem
{
RTSPSessionIDQueueElem(UInt32 rtspSessionID) :fElem(), fRTSPSessionID(rtspSessionID) { fElem.SetEnclosingObject(this); }
~RTSPSessionIDQueueElem() {}
OSQueueElem fElem;
UInt32 fRTSPSessionID;
};
// FUNCTION PROTOTYPES
static QTSS_Error QTSSRelayModuleDispatch(QTSS_Role inRole, QTSS_RoleParamPtr inParams);
static QTSS_Error Register(QTSS_Register_Params* inParams);
static QTSS_Error Initialize(QTSS_Initialize_Params* inParams);
static QTSS_Error Shutdown();
static QTSS_Error RereadPrefs();
static RelaySession* CreateSession(SourceInfoQueueElem* inElem);
static RelaySession* FindSession(SourceInfoQueueElem* inElem);
static RelaySession* FindNextSession(SourceInfoQueueElem* inElem, OSQueueIter* inIterPtr);
static void AddOutputs(SourceInfo* inInfo, RelaySession* inSession, Bool16 inIsRTSPSourceInfo);
static void RemoveOutput(ReflectorOutput* inOutput, RelaySession* inSession);
static QTSS_Error Filter(QTSS_StandardRTSP_Params* inParams);
static void FindRelaySessions(OSQueue* inSessionQueue);
static QTSS_Error SetupAnnouncedSessions(QTSS_StandardRTSP_Params* inParams);
static RTSPSessionIDQueueElem* FindRTSPSessionIDQueueElem(UInt32 inSessionID);
static RTSPSourceInfo* FindAnnouncedSourceInfo(UInt32 inIP, StrPtrLen& inURL);
static RTSPSourceInfo* FindExistingRelayInfo(UInt32 inIP, StrPtrLen& inURL);
static void RereadRelayPrefs(XMLParser* prefsParser);
static void FindSourceInfos(OSQueue* inSessionQueue, OSQueue* inAnnouncedQueue, XMLParser* prefsParser);
static void ClearSourceInfos(OSQueue* inQueue);
static QTSS_Error RouteAuthorization(QTSS_StandardRTSP_Params* inParams);
static Bool16 IsRelayRequest(UInt16 inPort);
static void ReadRelayPrefsFile();
static Bool16 CheckDNSNames(XMLParser* prefsFile, Bool16 doResolution);
static void ResolveDNSAddr(XMLTag* tag);
// DNS Resolution can block a thread for a long time (there's no async version), and on X
// we only have 1 task thread, so the resolution must be on another thread. However, we
// want to do the rest of the RereadPrefs on the main task thread, so we need both a thread
// and a task. The thread resolves the addresses and fires the task, the task deletes
// the thread and is deleted itself as soon as it's done.
class DNSResolverThread : public OSThread
{
class RereadPrefsTask : public Task
{
public:
RereadPrefsTask() : Task () {this->SetTaskName("DNSResolverThread::RereadPrefsTask");}
virtual SInt64 Run()
{
RereadRelayPrefs(sRelayPrefsFile);
delete sResolverThread;
sResolverThread = NULL;
delete sRelayPrefsFile;
// we need to see if reread prefs has been called again while we were resolving.
// If so, it just exited without doing anything, and we need to start over to pick
// up whatever changed.
sResolverMutex.Lock();
sRelayPrefsFile = NULL;
if (sDoResolveAgain)
{
sDoResolveAgain = false;
sResolverMutex.Unlock();
ReadRelayPrefsFile();
}
else sResolverMutex.Unlock();
return -1;
}
};
public:
static void ResolveRelayPrefs(XMLParser* relayPrefs)
{
sResolverMutex.Lock();
if (sRelayPrefsFile == NULL)
{
sRelayPrefsFile = relayPrefs;
sResolverThread = new DNSResolverThread();
sResolverThread->Start();
}
else
{
sDoResolveAgain = true; // it's already resolving, tell it to try again when it's done
delete relayPrefs;
}
sResolverMutex.Unlock();
}
virtual void Entry()
{
if (sRelayPrefsFile != NULL)
{
CheckDNSNames(sRelayPrefsFile, true);
RereadPrefsTask* tempTask = new RereadPrefsTask();
tempTask->Signal(Task::kIdleEvent);
}
}
};
// FUNCTION IMPLEMENTATIONS
QTSS_Error QTSSRelayModule_Main(void* inPrivateArgs)
{
return _stublibrary_main(inPrivateArgs, QTSSRelayModuleDispatch);
}
QTSS_Error QTSSRelayModuleDispatch(QTSS_Role inRole, QTSS_RoleParamPtr inParams)
{
switch (inRole)
{
case QTSS_Register_Role:
return Register(&inParams->regParams);
case QTSS_Initialize_Role:
return Initialize(&inParams->initParams);
case QTSS_RereadPrefs_Role:
return RereadPrefs();
case QTSS_RTSPFilter_Role:
return Filter(&inParams->rtspRequestParams);
case QTSS_RTSPRoute_Role:
return RouteAuthorization(&inParams->rtspRouteParams);
case QTSS_RTSPPostProcessor_Role:
return SetupAnnouncedSessions(&inParams->rtspPostProcessorParams);
case QTSS_Shutdown_Role:
return Shutdown();
}
return QTSS_NoErr;
}
QTSS_Error Register(QTSS_Register_Params* inParams)
{
// Do role & attribute setup
(void)QTSS_AddRole(QTSS_Initialize_Role);
(void)QTSS_AddRole(QTSS_Shutdown_Role);
(void)QTSS_AddRole(QTSS_RTSPFilter_Role);
(void)QTSS_AddRole(QTSS_RTSPRoute_Role);
(void)QTSS_AddRole(QTSS_RereadPrefs_Role);
(void)QTSS_AddRole(QTSS_RTSPPostProcessor_Role);
// get the text for the error message from the server atrribute.
static char* sRelayModulePrefParseErrName = "QTSSRelayModulePrefParseError";
(void)QTSS_AddStaticAttribute(qtssTextMessagesObjectType, sRelayModulePrefParseErrName, NULL, qtssAttrDataTypeCharArray);
(void)QTSS_IDForAttr(qtssTextMessagesObjectType, sRelayModulePrefParseErrName, &sRelayModulePrefParseErr);
// add a boolean attribute for the relay session to the client session object
// we set it to true if we know that it is a relay session else we set it to false
// (set to true for those client sessions that are created for the relay when announces come in)
(void)QTSS_AddStaticAttribute(qtssClientSessionObjectType, sIsRelaySessionAttrName, NULL, qtssAttrDataTypeBool16);
(void)QTSS_IDForAttr(qtssClientSessionObjectType, sIsRelaySessionAttrName, &sIsRelaySessionAttr);
RelaySession::Register();
RelayOutput::Register();
// Reflector session needs to setup some parameters too.
ReflectorStream::Register();
// Tell the server our name!
static char* sModuleName = "QTSSRelayModule";
::strcpy(inParams->outModuleName, sModuleName);
return QTSS_NoErr;
}
QTSS_Error Initialize(QTSS_Initialize_Params* inParams)
{
// Setup module utils
QTSSModuleUtils::Initialize(inParams->inMessages, inParams->inServer, inParams->inErrorLogStream);
sSessionQueue = NEW OSQueue();
sAnnouncedQueue = NEW OSQueue();
sRTSPSourceInfoQueue = NEW OSQueue();
sRTSPSessionIDQueue = NEW OSQueue();
sPrefs = QTSSModuleUtils::GetModulePrefsObject(inParams->inModule);
sServer = inParams->inServer;
sAttributes = QTSSModuleUtils::GetModuleAttributesObject(inParams->inModule);
qtss_sprintf(sResponseHeader, kResponseHeader, kVersionString, kBuildString);
// Call helper class initializers
// this function calls the ReflectorSession base class Initialize function
RelaySession::Initialize(sAttributes);
#if QTSS_RELAY_EXTERNAL_MODULE
// The reflector is dependent on a number of objects in the Common Utilities
// library that get setup by the server if the reflector is internal to the
// server.
//
// So, if the reflector is being built as a code fragment, it must initialize
// those pieces itself
#if !MACOSXEVENTQUEUE
::select_startevents();//initialize the select() implementation of the event queue
#endif
OS::Initialize();
Socket::Initialize();
SocketUtils::Initialize();
const UInt32 kNumReflectorThreads = 8;
TaskThreadPool::AddThreads(kNumReflectorThreads);
IdleTask::Initialize();
Socket::StartThread();
#endif
//
// Instead of passing our own module prefs object, as one might expect,
// here we pass in the QTSSReflectorModule's, because the prefs that
// apply to ReflectorStream are stored in that module's prefs
StrPtrLen theReflectorModule("QTSSReflectorModule");
QTSS_ModulePrefsObject theReflectorPrefs =
QTSSModuleUtils::GetModulePrefsObject(QTSSModuleUtils::GetModuleObjectByName(theReflectorModule));
// Call helper class initializers
ReflectorStream::Initialize(theReflectorPrefs);
RereadPrefs();
return QTSS_NoErr;
}
QTSS_Error Shutdown()
{
#if QTSS_REFLECTOR_EXTERNAL_MODULE
TaskThreadPool::RemoveThreads();
#endif
return QTSS_NoErr;
}
QTSS_Error RereadPrefs()
{
delete [] sRelayPrefs;
delete [] sRelayStatsURL;
sRelayPrefs = QTSSModuleUtils::GetStringAttribute(sPrefs, "relay_prefs_file", sDefaultRelayPrefs);
sRelayStatsURL = QTSSModuleUtils::GetStringAttribute(sPrefs, "relay_stats_url", "");
ReadRelayPrefsFile();
return QTSS_NoErr;
}
RelaySession* CreateSession(SourceInfoQueueElem* inElem)
{
RelaySession* theSession = NEW RelaySession(NULL, inElem->fSourceInfo);
QTSS_Error theErr = theSession->SetupRelaySession(inElem->fSourceInfo);
inElem->fShouldDelete = false; // SourceInfo will be deleted by the RelaySession
if (theErr != QTSS_NoErr)
{
delete theSession;
return NULL;
}
theSession->FormatHTML(NULL);
sSessionQueue->EnQueue(theSession->GetQueueElem());
return theSession;
}
RelaySession* FindSession(SourceInfoQueueElem* inElem)
{
OSQueueIter theIter(sSessionQueue);
return FindNextSession(inElem, &theIter);
}
RelaySession* FindNextSession(SourceInfoQueueElem* inElem, OSQueueIter* inIterPtr)
{
RelaySession* theSession = NULL;
for ( ;!inIterPtr->IsDone(); inIterPtr->Next())
{
theSession = (RelaySession*)inIterPtr->GetCurrent()->GetEnclosingObject();
if (theSession->Equal(inElem->fSourceInfo))
return theSession;
}
return NULL;
}
void RemoveOutput(ReflectorOutput* inOutput, RelaySession* inSession)
{
// This function removes the output from the RelaySession, then
// checks to see if the session should go away. If it should, this deletes it
inSession->RemoveOutput(inOutput,false);
delete inOutput;
if (inSession->GetNumOutputs() == 0)
{
sSessionQueue->Remove(inSession->GetQueueElem());
delete inSession;
}
}
void RemoveAllOutputs(RelaySession* inSession)
{
OSMutexLocker locker(RelayOutput::GetQueueMutex());
for (OSQueueIter iter(RelayOutput::GetOutputQueue()); !iter.IsDone(); )
{
RelayOutput* theOutput = (RelayOutput*)iter.GetCurrent()->GetEnclosingObject();
iter.Next();
if(theOutput->GetRelaySession() == inSession)
{
inSession->RemoveOutput(theOutput,false);
delete theOutput;
}
}
Assert(inSession->GetNumOutputs() == 0);
sSessionQueue->Remove(inSession->GetQueueElem());
delete inSession;
}
QTSS_Error Filter(QTSS_StandardRTSP_Params* inParams)
{
UInt32 theLen = 0;
char* theFullRequest = NULL;
(void)QTSS_GetValuePtr(inParams->inRTSPRequest, qtssRTSPReqFullRequest, 0, (void**)&theFullRequest, &theLen);
OSMutexLocker locker(RelayOutput::GetQueueMutex());
// Check to see if this is a request we should handle
if ((sRequestHeader.Ptr == NULL) || (sRequestHeader.Len == 0))
return QTSS_NoErr;
if ((theFullRequest == NULL) || (theLen < sRequestHeader.Len))
return QTSS_NoErr;
if (::memcmp(theFullRequest, sRequestHeader.Ptr, sRequestHeader.Len) != 0)
return QTSS_NoErr;
// Keep-alive should be off!
Bool16 theFalse = false;
(void)QTSS_SetValue(inParams->inRTSPRequest, qtssRTSPReqRespKeepAlive, 0, &theFalse, sizeof(theFalse));
(void)QTSS_Write(inParams->inRTSPRequest, sResponseHeader, ::strlen(sResponseHeader), NULL, 0);
// First build up a queue of all RelaySessions with RelayOutputs. This way,
// we can present a list that's sorted.
OSQueue theSessionQueue;
FindRelaySessions(&theSessionQueue);
static StrPtrLen sNoRelays("<H2>There are no currently active relays</H2>");
if (theSessionQueue.GetLength() == 0)
(void)QTSS_Write(inParams->inRTSPRequest, sNoRelays.Ptr, sNoRelays.Len, NULL, 0);
// Now go through our RelaySessionQueue, writing the info for each RelaySession,
// and all the outputs associated with that session
for (OSQueueIter iter(&theSessionQueue); !iter.IsDone(); iter.Next())
{
RelaySession* theSession = (RelaySession*)iter.GetCurrent()->GetEnclosingObject();
(void)QTSS_Write(inParams->inRTSPRequest, theSession->GetSourceInfoHTML()->Ptr, theSession->GetSourceInfoHTML()->Len, NULL, 0);
for (OSQueueIter iter2(RelayOutput::GetOutputQueue()); !iter2.IsDone(); iter2.Next())
{
RelayOutput* theOutput = (RelayOutput*)iter2.GetCurrent()->GetEnclosingObject();
if (theSession == theOutput->GetRelaySession())
{
(void)QTSS_Write(inParams->inRTSPRequest, theOutput->GetOutputInfoHTML()->Ptr, theOutput->GetOutputInfoHTML()->Len, NULL, 0);
// Write current stats for this output
char theStatsBuf[1024];
qtss_sprintf(theStatsBuf, "Current stats for this relay: %"_U32BITARG_" packets per second. %"_U32BITARG_" bits per second. %"_64BITARG_"d packets since it started. %"_64BITARG_"d bits since it started<P>", theOutput->GetCurPacketsPerSecond(), theOutput->GetCurBitsPerSecond(), theOutput->GetTotalPacketsSent(), theOutput->GetTotalBytesSent());
(void)QTSS_Write(inParams->inRTSPRequest, &theStatsBuf[0], ::strlen(theStatsBuf), NULL, 0);
}
}
}
static StrPtrLen sResponseEnd("</BODY></HTML>");
(void)QTSS_Write(inParams->inRTSPRequest, sResponseEnd.Ptr, sResponseEnd.Len, NULL, 0);
for (OSQueueIter iter3(&theSessionQueue); !iter3.IsDone(); )
{
// Cleanup the memory we had allocated in FindRelaySessions
OSQueueElem* theElem = iter3.GetCurrent();
iter3.Next();
theSessionQueue.Remove(theElem);
delete theElem;
}
return QTSS_NoErr;
}
void FindRelaySessions(OSQueue* inSessionQueue)
{
for (OSQueueIter theIter(RelayOutput::GetOutputQueue()); !theIter.IsDone(); theIter.Next())
{
RelayOutput* theOutput = (RelayOutput*)theIter.GetCurrent()->GetEnclosingObject();
Bool16 found = false;
// Check to see if we've already seen this RelaySession
for (OSQueueIter theIter2(inSessionQueue); !theIter2.IsDone(); theIter2.Next())
{
if (theOutput->GetRelaySession() == theIter2.GetCurrent()->GetEnclosingObject())
{
found = true;
break;
}
}
if (!found)
{
// We haven't seen this one yet, so put it on the queue.
OSQueueElem* theElem = NEW OSQueueElem(theOutput->GetRelaySession());
inSessionQueue->EnQueue(theElem);
}
}
}
QTSS_Error SetupAnnouncedSessions(QTSS_StandardRTSP_Params* inParams)
{
QTSS_Error theErr = QTSS_NoErr;
Bool16 setup = false;
Bool16 play = false;
// Get the RTSP Method
QTSS_RTSPMethod* theMethod = NULL;
UInt32 theLen = 0;
theErr = QTSS_GetValuePtr(inParams->inRTSPRequest, qtssRTSPReqMethod, 0, (void**)&theMethod, &theLen);
if ((theErr != QTSS_NoErr) || (theLen != sizeof(QTSS_RTSPMethod)))
{
Assert(0);
return QTSS_NoErr;
}
// Get the SETUP Transport Mode
QTSS_RTPTransportMode* theMode = NULL;
theLen = 0;
theErr = QTSS_GetValuePtr(inParams->inRTSPRequest, qtssRTSPReqTransportMode, 0, (void**)&theMode, &theLen);
if ((theErr != QTSS_NoErr) || (theLen != sizeof(QTSS_RTPTransportMode)))
{
Assert(0);
return QTSS_NoErr;
}
if ( (*theMethod == qtssSetupMethod) && (*theMode == qtssRTPTransportModeRecord) )
setup = true;
else if (*theMethod == qtssPlayMethod || *theMethod == qtssRecordMethod)
play = true;
// We are only interested in SETUP mode=receive or mode=record and PLAY or RECORD requests
if (!(setup || play))
return QTSS_NoErr;
// Get the RTSP Status Code
QTSS_RTSPStatusCode* theStatusCode = NULL;
theLen = 0;
theErr = QTSS_GetValuePtr(inParams->inRTSPRequest, qtssRTSPReqStatusCode, 0, (void**)&theStatusCode, &theLen);
if ((theErr != QTSS_NoErr) || (theLen != sizeof(QTSS_RTSPStatusCode)))
{
Assert(0);
return QTSS_NoErr;
}
// We are only interested in 200 OK requests, ofcourse
if(*theStatusCode != qtssSuccessOK)
return QTSS_NoErr;
// Now get the RTSP Session ID
UInt32* theSessionID = 0;
theLen = 0;
theErr = QTSS_GetValuePtr(inParams->inRTSPSession, qtssRTSPSesID, 0, (void**)&theSessionID, &theLen);
if ((theErr != QTSS_NoErr) || (theLen != sizeof(UInt32)))
{
Assert(0);
return QTSS_NoErr;
}
OSMutexLocker locker(RelayOutput::GetQueueMutex());
RTSPSessionIDQueueElem* theElem = FindRTSPSessionIDQueueElem(*theSessionID);
// If the RTSPSessionID is not in the queue
if (theElem == NULL)
{
// If it's a SETUP mode=receive or record add the RTSPSessionID to the queue
if(setup)
{
RTSPSessionIDQueueElem* idElem = NEW RTSPSessionIDQueueElem(*theSessionID);
sRTSPSessionIDQueue->EnQueue(&idElem->fElem);
}
// Nothing more to do
return QTSS_NoErr;
}
// If theElem is not NULL
if(setup) // No need to add it to the queue twice
return QTSS_NoErr;
// At this point it has to be a PLAY request with the session ID in the queue
// Remove the session ID from the queue
sRTSPSessionIDQueue->Remove(&theElem->fElem);
delete theElem;
theElem = 0;
// Get the Remote IP address
UInt32* theIP = 0;
theLen = 0;
theErr = QTSS_GetValuePtr(inParams->inRTSPSession, qtssRTSPSesRemoteAddr, 0, (void**)&theIP, &theLen);
if ((theErr != QTSS_NoErr) || (theLen != sizeof(UInt32)))
{
Assert(0);
return QTSS_NoErr;
}
// Get the URI
theLen = 0;
char* theURLStr = NULL;
theErr = QTSS_GetValuePtr(inParams->inRTSPRequest, qtssRTSPReqURI, 0, (void**)&theURLStr, &theLen);
if ((theErr != QTSS_NoErr) || (theURLStr == NULL))
{
Assert(0);
return QTSS_NoErr;
}
StrPtrLen theURL(theURLStr, theLen);
// Check if a source info exists for this ANNOUNCED URL
RTSPSourceInfo* info = FindAnnouncedSourceInfo(*theIP, theURL);
if(info == NULL) // if a source info does not exists, we don't have to do anything
return QTSS_NoErr;
// Check if a relay has already been set up for this
// if it has, remove all the outputs, delete the session
// before creating a new source info etc...
RTSPSourceInfo* existingInfo = FindExistingRelayInfo(*theIP, theURL);
if(existingInfo != NULL)
{
RelaySession* session = existingInfo->GetRelaySession();
if(session == NULL)
delete existingInfo;
else
RemoveAllOutputs(session);
}
RTSPSourceInfo* newInfo = NEW RTSPSourceInfo(*info);
newInfo->SetAnnounceActualIP(*theIP); // this is used later along with the source url to check if a relay is already set up
UInt16 thePort = 0;
theLen = sizeof(UInt16);
theErr = QTSS_GetValue(sServer, qtssSvrRTSPPorts, 0, (void *) &thePort, &theLen);
if ((theErr != QTSS_NoErr) || (theLen != sizeof(UInt16)))
{
delete newInfo;
return QTSS_NoErr;
}
newInfo->SetSourceParameters(INADDR_LOOPBACK, thePort, theURL);
newInfo->StartSessionCreatorTask(sSessionQueue, sRTSPSourceInfoQueue);
return QTSS_NoErr;
}
RTSPSessionIDQueueElem* FindRTSPSessionIDQueueElem(UInt32 inSessionID)
{
for (OSQueueIter iter(sRTSPSessionIDQueue); !iter.IsDone(); iter.Next())
{
RTSPSessionIDQueueElem* theElem = (RTSPSessionIDQueueElem*)iter.GetCurrent()->GetEnclosingObject();
if (theElem->fRTSPSessionID == inSessionID)
return theElem;
}
return NULL;
}
RTSPSourceInfo* FindAnnouncedSourceInfo(UInt32 inIP, StrPtrLen& inURL)
{
RTSPSourceInfo* info = NULL;
Bool16 ipMatchfound = false;
// check to see if the ip address + URL match any of the source infos in the sAnnouncedQueue.
// in this order:
// 1. IP + URL match
// 2. IP match
// 3. All IPs+URLs match (meaning all announced broadcasts)
for (OSQueueIter iter(sAnnouncedQueue); !iter.IsDone(); iter.Next())
{
SourceInfo* theInfo = ((SourceInfoQueueElem*)iter.GetCurrent()->GetEnclosingObject())->fSourceInfo;
// RTSPSourceInfo* announceInfo = dynamic_cast<RTSPSourceInfo *>(theInfo);
RTSPSourceInfo* announceInfo = (RTSPSourceInfo *)(theInfo);
// if ((announceInfo == NULL) || (!announceInfo->IsAnnounce()))
// continue;
UInt32 infoIP = announceInfo->GetAnnounceIP();
StrPtrLen infoURL(announceInfo->GetAnnounceURL());
// if there is a source info for ANNOUNCE ALL, keep this info until a better one is found
if (!ipMatchfound && (infoIP == 0) && ((infoURL.Ptr == NULL) || (infoURL.Len == 0)))
{
info = announceInfo;
continue;
}
// if there is a source info for ANNOUNCE any URL from an IP, keep this info until a better one is found
if ((infoIP == inIP) && ((infoURL.Ptr == NULL) || (infoURL.Len == 0)))
{
info = announceInfo;
ipMatchfound = true;
continue;
}
// if there is a source info for ANNOUNCE for the URL + IP combo, return this as the source info
// strip leading path delimiters
UInt32 count = 0;
while (count < inURL.Len && inURL.Ptr[count] == '/')
{ count ++;
}
StrPtrLen announcedURL(&inURL.Ptr[count],inURL.Len - count);
// strip leading path delimiters
count = 0;
while (count < infoURL.Len && infoURL.Ptr[count] == '/')
{ count ++;
}
StrPtrLen configMountPoint(&infoURL.Ptr[count],infoURL.Len - count);
if ((infoIP == inIP) && (configMountPoint.Equal(announcedURL)))
{
info = announceInfo;
break;
}
}
// cast the source info to RTSPSourceInfo because all the elements of the sAnnouncedQueue
// are RTSPSourceInfos anyway.
// Don't really like this but I suppose it will do for now
return info;
}
RTSPSourceInfo* FindExistingRelayInfo(UInt32 inIP, StrPtrLen& inURL)
{
if (inURL.Ptr == NULL)
return NULL;
for (OSQueueIter iter(sRTSPSourceInfoQueue); !iter.IsDone(); iter.Next())
{
RTSPSourceInfo* info = (RTSPSourceInfo*)iter.GetCurrent()->GetEnclosingObject();
if ((inIP == info->GetAnnounceActualIP()) && inURL.Equal(info->GetSourceURL()))
return info;
}
return NULL;
}
void RereadRelayPrefs(XMLParser* prefsParser)
{
// Construct a SourceInfo object for each relayable thingy
OSQueue sourceInfoQueue;
ClearSourceInfos(sAnnouncedQueue);
FindSourceInfos(&sourceInfoQueue, sAnnouncedQueue, prefsParser);
// Ok, we have all our SourceInfo objects. Now, lets alter the list of Relay
// outputs to match
// Go through the queue of Relay outputs, removing the source Infos that
// are already going
OSMutexLocker locker(RelayOutput::GetQueueMutex());
// We must reread the relay stats URL here, because we have the RelayOutput
// mutex so we know that Filter can't be filtering now
delete [] sRequestHeader.Ptr;
sRequestHeader.Ptr = NULL;
sRequestHeader.Len = 0;
if ((sRelayStatsURL != NULL) && (::strlen(sRelayStatsURL) > 0))
{
// sRequestHeader line should look like: GET /sRelayStatsURL HTTP
sRequestHeader.Ptr = NEW char[::strlen(sRelayStatsURL) + 15];
::strcpy(sRequestHeader.Ptr, "GET /");
::strcat(sRequestHeader.Ptr, sRelayStatsURL);
::strcat(sRequestHeader.Ptr, " HTTP");
sRequestHeader.Len = ::strlen(sRequestHeader.Ptr);
}
for (OSQueueIter iter(RelayOutput::GetOutputQueue()); !iter.IsDone(); )
{
RelayOutput* theOutput = (RelayOutput*)iter.GetCurrent()->GetEnclosingObject();
Bool16 stillActive = false;
// Check to see if this RelayOutput matches one of the streams in the
// SourceInfo queue. If it does, this has 2 implications:
//
// 1) The stream in the SourceInfo that matches should NOT be setup as a
// new RelayOutput, because it already exists. (Equal will set a flag in
// the StreamInfo object saying as much)
//
// 2) This particular RelayOutput should remain (not be deleted).
for (OSQueueIter iter2(&sourceInfoQueue); !iter2.IsDone(); iter2.Next())
{
SourceInfo* theInfo =
((SourceInfoQueueElem*)iter2.GetCurrent()->GetEnclosingObject())->fSourceInfo;
if (theOutput->Equal(theInfo))
{
stillActive = true;
break;
}
}
// Also check if this RelayOutput matches one of the streams in the
// AnnouncedInfo queue. If it does, the implications are same as above.
// Perform this check only if it is not already found in the first queue
if(!stillActive)
{
for (OSQueueIter iter3(sAnnouncedQueue); !iter3.IsDone(); iter3.Next())
{
SourceInfo* theInfo =
((SourceInfoQueueElem*)iter3.GetCurrent()->GetEnclosingObject())->fSourceInfo;
if (theOutput->Equal(theInfo))
{
stillActive = true;
break;
}
}
}
iter.Next();
// This relay output is no longer on our list
if (!stillActive)
RemoveOutput(theOutput, theOutput->GetRelaySession());
}
// We've pruned the list of RelayOutputs of all outputs that are no longer
// going on. Now, all that is left to do is to create any new outputs (and sessions)
// that are just starting up
for (OSQueueIter iter4(&sourceInfoQueue); !iter4.IsDone(); iter4.Next())
{
SourceInfoQueueElem* theElem = (SourceInfoQueueElem*)iter4.GetCurrent()->GetEnclosingObject();
if (theElem->fSourceInfo->GetNumNewOutputs() == 0) // Because we've already checked for Outputs
continue; // That already exist, we know which ones are new
RelaySession* theSession = FindSession(theElem);
if (theSession == NULL)
{
if (theElem->fIsRTSPSourceInfo)
{
theElem->fShouldDelete = false;
// RTSPSourceInfo* theInfo = dynamic_cast<RTSPSourceInfo *>(theElem->fSourceInfo);
RTSPSourceInfo* theInfo = (RTSPSourceInfo *)(theElem->fSourceInfo);
theInfo->StartSessionCreatorTask(sSessionQueue, sRTSPSourceInfoQueue);
}
else
{
theSession = CreateSession(theElem);
if (theSession != NULL)
AddOutputs(theElem->fSourceInfo, theSession, theElem->fIsRTSPSourceInfo);
}
}
else
{
AddOutputs(theElem->fSourceInfo, theSession, theElem->fIsRTSPSourceInfo);
}
}
// For the announced source infos, find a session that is already active, and add any
// output that isn't already set up. If a session isn't found, don't create it!
for (OSQueueIter iter5(sAnnouncedQueue); !iter5.IsDone(); iter5.Next())
{
SourceInfoQueueElem* theElem = (SourceInfoQueueElem*)iter5.GetCurrent()->GetEnclosingObject();
if (theElem->fSourceInfo->GetNumNewOutputs() == 0) // Because we've already checked for Outputs
continue; // That already exist, we know which ones are new
for (OSQueueIter iter6(sSessionQueue); !iter6.IsDone(); )
{
RelaySession* theSession = FindNextSession(theElem, &iter6);
if(!iter6.IsDone())
iter6.Next();
if (theSession == NULL)
continue;
AddOutputs(theElem->fSourceInfo, theSession, theElem->fIsRTSPSourceInfo);
}
}
// Clear only the first source info queue. The announced source info queue
// must be kept around so that we know which announced broadcasts to relay
ClearSourceInfos(&sourceInfoQueue);
}
void AddOutputs(SourceInfo* inInfo, RelaySession* inSession, Bool16 inIsRTSPSourceInfo)
{
for (UInt32 x = 0; x < inInfo->GetNumOutputs(); x++)
{
SourceInfo::OutputInfo* theOutputInfo = inInfo->GetOutputInfo(x);
if (theOutputInfo->fAlreadySetup)
continue;
RelayOutput* theOutput = NEW RelayOutput(inInfo, x, inSession, inIsRTSPSourceInfo);
if (theOutput->IsValid())
inSession->AddOutput(theOutput, false);
else
delete theOutput;
}
}
void FindSourceInfos(OSQueue* inSessionQueue, OSQueue* inAnnouncedQueue, XMLParser* prefsParser)
{
SourceInfoQueueElem* theElem = NULL;
XMLTag* tag = prefsParser->GetRootTag();
XMLTag* relayTag;
UInt32 index = 0;
while ((relayTag = tag->GetEmbeddedTagByNameAndAttr("OBJECT", "TYPE", "relay", index)) != NULL)
{
index++;
XMLTag* enabledTag = relayTag->GetEmbeddedTagByNameAndAttr("PREF", "NAME", "enabled");
if ((enabledTag != NULL) && (enabledTag->GetValue() != NULL) && !strcmp(enabledTag->GetValue(), "false"))
continue; // this relay pref is disabled
XMLTag* sourceTag = relayTag->GetEmbeddedTagByNameAndAttr("OBJECT", "CLASS", "source");
if (sourceTag == NULL)
continue;
char* type = sourceTag->GetAttributeValue("TYPE");
if (type == NULL)
continue;
if (!strcmp(type, "relay_sdp"))
{
XMLTag* fileNameTag = sourceTag->GetEmbeddedTagByNameAndAttr("PREF", "NAME", "sdp_path");
if (!fileNameTag)
continue;
char* fileName = fileNameTag->GetValue();
if (fileName == NULL)
continue;
StrPtrLen theFileData;
(void)QTSSModuleUtils::ReadEntireFile(fileName, &theFileData);
if (theFileData.Len > 0) // There is a Relay SDP file!
{
RelaySDPSourceInfo* theInfo = NEW RelaySDPSourceInfo(&theFileData);
// Only keep this sdp file around if there are input streams &
// output streams described in it.
if ((theInfo->GetNumStreams() == 0) || (theInfo->GetNumOutputs() == 0))
delete theInfo;
else
{
theElem = NEW SourceInfoQueueElem(theInfo, false);
inSessionQueue->EnQueue(&theElem->fElem);
}
delete [] theFileData.Ptr;// We don't need the file data anymore
}
}
else if (!strcmp(type, "udp_source"))
{
RCFSourceInfo* theRCFInfo = NEW RCFSourceInfo(relayTag);
// Only keep this sdp file around if there are input streams &
// output streams described in it.
if ((theRCFInfo->GetNumStreams() == 0) || (theRCFInfo->GetNumOutputs() == 0))
delete theRCFInfo;
else
{
theElem = NEW SourceInfoQueueElem(theRCFInfo, false);
inSessionQueue->EnQueue(&theElem->fElem);
}
}
else if (!strcmp(type, "rtsp_source"))
{
// This is an rtsp source, so go through the describe, setup, play connect
// process before moving on.
RTSPSourceInfo* theRTSPInfo = NEW RTSPSourceInfo(0);
QTSS_Error theErr = theRTSPInfo->ParsePrefs(relayTag, false);
if (theErr == QTSS_NoErr)
{
// We have to do this *after* doing the DESCRIBE because parsing
// the relay destinations depends on information in the SDP
theRTSPInfo->ParseRelayDestinations(relayTag);
if (theRTSPInfo->GetNumOutputs() == 0)
delete theRTSPInfo;
else
{
theElem = NEW SourceInfoQueueElem(theRTSPInfo, true);
inSessionQueue->EnQueue(&theElem->fElem);
}
}
else
delete theRTSPInfo;
}
else if (!strcmp(type, "announced_source"))
{
// This is an announced rtsp source, so just set up an RTSPSourceInfo object and parse
// through the destinations. Leave the rest for later.
RTSPSourceInfo* theRTSPInfo = NEW RTSPSourceInfo(true);
QTSS_Error theErr = theRTSPInfo->ParsePrefs(relayTag, true);
if (theErr == QTSS_NoErr)
{
theRTSPInfo->ParseRelayDestinations(relayTag);
if (theRTSPInfo->GetNumOutputs() == 0)
delete theRTSPInfo;
else
{
theElem = NEW SourceInfoQueueElem(theRTSPInfo, true);
// put this sourceinfo elem on the global sAnnouncedQueue so that
// its session can be set up when an ANNOUNCE is received
inAnnouncedQueue->EnQueue(&theElem->fElem);
}
}
else
delete theRTSPInfo;
}
}
}
void ClearSourceInfos(OSQueue* inQueue)
{
for (OSQueueIter theIter(inQueue); !theIter.IsDone(); )
{
// Get the current queue element, and make sure to move onto the
// next one, as the current one is going away.
SourceInfoQueueElem* theElem = (SourceInfoQueueElem*)theIter.GetCurrent()->GetEnclosingObject();
theIter.Next();
inQueue->Remove(&theElem->fElem);
// If we're supposed to delete this SourceInfo, then do so
if (theElem->fShouldDelete)
delete theElem->fSourceInfo;
delete theElem;
}
}
QTSS_Error RouteAuthorization(QTSS_StandardRTSP_Params* inParams)
{
QTSS_Error theErr = QTSS_NoErr;
UInt32 theLen = 0;
// Get the Remote IP address
UInt32* theIP = 0;
theErr = QTSS_GetValuePtr(inParams->inRTSPSession, qtssRTSPSesRemoteAddr, 0, (void**)&theIP, &theLen);
if ((theErr != QTSS_NoErr) || (theLen != sizeof(UInt32)))
{
Assert(0);
return QTSS_NoErr;
}
if (*theIP != INADDR_LOOPBACK)
return QTSS_NoErr;
// Get the Remote Port
UInt16* thePort = 0;
theLen = 0;
theErr = QTSS_GetValuePtr(inParams->inRTSPSession, qtssRTSPSesRemotePort, 0, (void**)&thePort, &theLen);
if ((theErr != QTSS_NoErr) || (theLen != sizeof(UInt16)))
{
Assert(0);
return QTSS_NoErr;
}
// Check to see if any of the outputs has an announced source
// whose source URI and request port match theURL and thePort
if (IsRelayRequest(*thePort))
{
// ask server to skip authorization
if (QTSS_NoErr != QTSS_SetValue(inParams->inRTSPRequest,qtssRTSPReqSkipAuthorization, 0, &sSkipAuthorization, sizeof(sSkipAuthorization)))
return QTSS_RequestFailed; // bail on the request if the SetValue call fails!
// set the client session QTSSRelayModuleIsRelaySession attribute to true
if (QTSS_NoErr != QTSS_SetValue(inParams->inClientSession, sIsRelaySessionAttr, 0,(void *)&sIsRelaySession, sizeof(sIsRelaySession)))
return QTSS_RequestFailed; // bail on the request if the SetValue call fails!
}
return QTSS_NoErr;
}
Bool16 IsRelayRequest(UInt16 inPort)
{
for (OSQueueIter iter(sRTSPSourceInfoQueue); !iter.IsDone(); iter.Next())
{
RTSPSourceInfo* info = (RTSPSourceInfo*)iter.GetCurrent()->GetEnclosingObject();
if (inPort == (info->GetClientSocket())->GetLocalPort())
return true;
}
return false;
}
void ReadRelayPrefsFile()
{
// check to see if file has changed
struct stat buf;
if (::stat(sRelayPrefs, &buf) >= 0)
{
if (sRelayPrefModDate == buf.st_mtime)
return;
sRelayPrefModDate = buf.st_mtime;
}
XMLParser* xmlFile = new XMLParser(sRelayPrefs);
if (!xmlFile->DoesFileExist())
{
delete xmlFile;
return; // just return with no error logged
}
char errorBuffer[1000];
if (!xmlFile->ParseFile(errorBuffer, sizeof(errorBuffer)))
{
// log this error to the error log
QTSSModuleUtils::LogError( qtssWarningVerbosity, sRelayModulePrefParseErr, 0, NULL, NULL);
delete xmlFile;
return; // file was invalid, so no source infos
}
if (!CheckDNSNames(xmlFile, false))
{
// do reread prefs stuff now
RereadRelayPrefs(xmlFile);
delete xmlFile;
return;
}
// otherwise we need to do the DNS resolution on another thread
DNSResolverThread::ResolveRelayPrefs(xmlFile); // will keep or delete xmlFile
}
Bool16 CheckDNSNames(XMLParser* prefsFile, Bool16 doResolution)
{
XMLTag* tag = prefsFile->GetRootTag();
XMLTag* relayTag;
XMLTag* prefTag;
UInt32 index = 0;
while ((relayTag = tag->GetEmbeddedTagByNameAndAttr("OBJECT", "TYPE", "relay", index)) != NULL)
{
index++;
XMLTag* enabledTag = relayTag->GetEmbeddedTagByNameAndAttr("PREF", "NAME", "enabled");
if ((enabledTag != NULL) && (enabledTag->GetValue() != NULL) && !strcmp(enabledTag->GetValue(), "false"))
continue; // this relay pref is disabled
XMLTag* sourceTag = relayTag->GetEmbeddedTagByNameAndAttr("OBJECT", "CLASS", "source");
if (sourceTag == NULL)
continue;
prefTag = sourceTag->GetEmbeddedTagByNameAndAttr("PREF", "NAME", "in_addr");
if (prefTag != NULL)
{
char* destAddrStr = prefTag->GetValue();
if (destAddrStr != NULL)
if (SocketUtils::ConvertStringToAddr(destAddrStr) == INADDR_NONE)
{
if (doResolution)
ResolveDNSAddr(prefTag);
else
return true;
}
}
prefTag = sourceTag->GetEmbeddedTagByNameAndAttr("PREF", "NAME", "source_addr");
if (prefTag != NULL)
{
char* srcAddrStr = prefTag->GetValue();
if (srcAddrStr != NULL)
if (SocketUtils::ConvertStringToAddr(srcAddrStr) == INADDR_NONE)
{
if (doResolution)
ResolveDNSAddr(prefTag);
else
return true;
}
}
UInt32 numTags = relayTag->GetNumEmbeddedTags();
for (UInt32 y = 0; y < numTags; y++)
{
XMLTag* destTag = relayTag->GetEmbeddedTagByNameAndAttr("OBJECT", "CLASS", "destination", y);
if (destTag == NULL)
break;
prefTag = destTag->GetEmbeddedTagByNameAndAttr("PREF", "NAME", "out_addr");
if (prefTag != NULL)
{
char* outAddrStr = prefTag->GetValue();
if (outAddrStr != NULL)
if (SocketUtils::ConvertStringToAddr(outAddrStr) == INADDR_NONE)
{
if (doResolution)
ResolveDNSAddr(prefTag);
else
return true;
}
}
prefTag = destTag->GetEmbeddedTagByNameAndAttr("PREF", "NAME", "dest_addr");
if (prefTag != NULL)
{
char* destAddrStr = prefTag->GetValue();
if (destAddrStr != NULL)
if (SocketUtils::ConvertStringToAddr(destAddrStr) == INADDR_NONE)
{
if (doResolution)
ResolveDNSAddr(prefTag);
else
return true;
}
}
}
}
return false;
}
void ResolveDNSAddr(XMLTag* tag)
{
struct in_addr inAddr;
struct hostent* theHostent = ::gethostbyname(tag->GetValue());
if (theHostent != NULL)
{
char buffer[50];
StrPtrLen temp(buffer);
inAddr.s_addr = *(UInt32*)(theHostent->h_addr_list[0]);
SocketUtils::ConvertAddrToString(inAddr, &temp);
tag->SetValue(buffer);
}
}
Reference in a new issue Copy permalink