void RTSPRequest::ParseAddrSubHeader(StrPtrLen* inSubHeader, StrPtrLen* inHeaderName, UInt32* outAddr)
{
if (!inSubHeader || !inHeaderName || !outAddr)
return;
StringParser theSubHeaderParser(inSubHeader);
// Skip over to the value
StrPtrLen theFirstBit;
theSubHeaderParser.GetThru(&theFirstBit, '=');
theFirstBit.TrimWhitespace();
// First make sure this is the proper subheader
if (!theFirstBit.EqualIgnoreCase(*inHeaderName))
return;
//Find the IP address
theSubHeaderParser.ConsumeUntilDigit();
//Set the addr string param.
StrPtrLen theAddr(theSubHeaderParser.GetCurrentPosition(), theSubHeaderParser.GetDataRemaining());
//Convert the string to a UInt32 IP address
char theTerminator = theAddr.Ptr[theAddr.Len];
theAddr.Ptr[theAddr.Len] = '\0';
*outAddr = SocketUtils::ConvertStringToAddr(theAddr.Ptr);
theAddr.Ptr[theAddr.Len] = theTerminator;
}
inline void ParseAuthNameAndPassword(StrPtrLen *codedStrPtr, StrPtrLen* namePtr, StrPtrLen* passwordPtr)
{
if (!codedStrPtr || (codedStrPtr->Len >= kAuthNameAndPasswordBuffSize) )
{ return;
}
StrPtrLen codedLineStr;
StrPtrLen nameAndPassword;
memset(decodedLine,0,kAuthNameAndPasswordBuffSize);
memset(codedLine,0,kAuthNameAndPasswordBuffSize);
memcpy (codedLine,codedStrPtr->Ptr,codedStrPtr->Len);
codedLineStr.Set((char*) codedLine, codedStrPtr->Len);
(void) Base64decode(decodedLine, codedLineStr.Ptr);
nameAndPassword.Set((char*) decodedLine, strlen(decodedLine));
StringParser parsedNameAndPassword(&nameAndPassword);
parsedNameAndPassword.ConsumeUntil(namePtr,':');
parsedNameAndPassword.ConsumeLength(NULL, 1);
// password can have whitespace, so read until the end of the line, not just until whitespace
parsedNameAndPassword.ConsumeUntil(passwordPtr, StringParser::sEOLMask);
namePtr->Ptr[namePtr->Len]= 0;
passwordPtr->Ptr[passwordPtr->Len]= 0;
//qtss_printf("decoded nameAndPassword="******"decoded name="); PRINT_STR(namePtr);
//qtss_printf("decoded password="); PRINT_STR(passwordPtr);
return;
};
Bool16 IsAuthentic(QTSS_Filter_Params* inParams,StringParser *fullRequestPtr)
{
Bool16 isAuthentic = false;
if (!sAuthenticationEnabled) // no authentication
{
isAuthentic = true;
}
else // must authenticate
{
StrPtrLen theClientIPAddressStr;
(void) QTSS_GetValuePtr(inParams->inRTSPSession, qtssRTSPSesRemoteAddrStr, 0, (void**)&theClientIPAddressStr.Ptr, &theClientIPAddressStr.Len);
Bool16 isLocal = IPComponentStr(&theClientIPAddressStr).IsLocal();
StrPtrLen authenticateName;
StrPtrLen authenticatePassword;
StrPtrLen authType;
Bool16 hasAuthentication = HasAuthentication(fullRequestPtr,&authenticateName,&authenticatePassword, &authType);
if (hasAuthentication)
{
if (authType.Equal(sAuthRef))
{
if (isLocal)
isAuthentic = OSXAuthenticate(&authenticatePassword);
}
else
isAuthentic = Authenticate(inParams->inRTSPRequest, &authenticateName,&authenticatePassword);
}
}
// if (isAuthentic)
// isAuthentic = AuthorizeAdminRequest(inParams->inRTSPRequest);
(void) QTSS_SetValue(inParams->inRTSPRequest, sAuthenticatedID, 0, (void*)&isAuthentic, sizeof(isAuthentic));
return isAuthentic;
}
void HttpParsingBasicObject::extractServerVersionNum()
{
StrCSumPtrLen serverKey = "Server";
StrPtrLen serverValue;
if (!iParser->getField(serverKey, serverValue)) return;
if (serverValue.length() == 0) return;
// Has Sever header
char *ptr = (char*)serverValue.c_str();
for (int32 i = 0; i < serverValue.length(); i++)
{
if (!PE_isDigit(*ptr))
{
ptr++;
continue;
}
iServerVersionNumber = *ptr++ - '0';
if (PE_isDigit(*ptr) && ++i < serverValue.length())
{
iServerVersionNumber = iServerVersionNumber * 10 + (*ptr - '0');
}
break;
}
}
void QueryParamList::BulidList( StrPtrLen* querySPL )
{
// parse the string and build the name/value list from the tokens.
// the string is a 'form' encoded query string ( see rfc - 1808 )
StringParser queryParser( querySPL );
while ( queryParser.GetDataRemaining() > 0 )
{
StrPtrLen theCGIParamName;
StrPtrLen theCGIParamValue;
queryParser.ConsumeUntil(&theCGIParamName, '='); // leaves "=..." in cgiParser, puts item keywd in theCGIParamName
if ( queryParser.GetDataRemaining() > 1 )
{
queryParser.ConsumeLength(&theCGIParamValue, 1 ); // the '='
queryParser.ConsumeUntil(&theCGIParamValue, '&'); // our value will end by here...
AddNameValuePairToList( theCGIParamName.GetAsCString(), theCGIParamValue.GetAsCString() );
queryParser.ConsumeLength(&theCGIParamValue, 1 ); // the '='
}
}
}
QTSS_Error HTTPRequest::ParseRequestLine(StringParser* parser)
{
// Get the method - If the method is not one of the defined methods
// then it doesn't return an error but sets fMethod to httpIllegalMethod
StrPtrLen theParsedData;
parser->ConsumeWord(&theParsedData);
fMethod = HTTPProtocol::GetMethod(&theParsedData);
//还有可能是HTTP Response类型
if((fMethod == httpIllegalMethod) && theParsedData.Equal("HTTP"))
{
parser->ConsumeUntilWhitespace();//过滤掉HTTP/1.1
parser->ConsumeUntilDigit(NULL);
UInt32 statusCode = parser->ConsumeInteger(NULL);
if( statusCode != 0 )
{
fHTTPType = httpResponseType;
parser->ConsumeWhitespace();
parser->ConsumeUntilWhitespace(NULL);
// Go past the end of line
if (!parser->ExpectEOL())
{
fStatusCode = httpBadRequest;
return QTSS_BadArgument; // Request line is not properly formatted!
}
return QTSS_NoErr;
}
}
// Consume whitespace
parser->ConsumeWhitespace();
// Parse the URI - If it fails returns an error after setting
// the fStatusCode to the appropriate error code
QTSS_Error err = ParseURI(parser);
if (err != QTSS_NoErr)
return err;
// Consume whitespace
parser->ConsumeWhitespace();
// If there is a version, consume the version string
StrPtrLen versionStr;
parser->ConsumeUntil(&versionStr, StringParser::sEOLMask);
// Check the version
if (versionStr.Len > 0)
fVersion = HTTPProtocol::GetVersion(&versionStr);
// Go past the end of line
if (!parser->ExpectEOL())
{
fStatusCode = httpBadRequest;
return QTSS_BadArgument; // Request line is not properly formatted!
}
return QTSS_NoErr;
}
void SDPContainer::PrintLine(SInt32 lineIndex)
{
StrPtrLen *printLinePtr = GetLine(lineIndex);
if (printLinePtr)
{ printLinePtr->PrintStr();
qtss_printf("\n");
}
}
void HTTPRequest::SetKeepAlive(StrPtrLen *keepAliveValue)
{
if ( sCloseString.EqualIgnoreCase(keepAliveValue->Ptr, keepAliveValue->Len) )
fRequestKeepAlive = sFalse;
else
{
Assert( sKeepAliveString.EqualIgnoreCase(keepAliveValue->Ptr, keepAliveValue->Len) );
fRequestKeepAlive = sTrue;
}
}
inline Bool16 HasAuthentication(StringParser *theFullRequestPtr, StrPtrLen* namePtr, StrPtrLen* passwordPtr, StrPtrLen* outAuthTypePtr)
{
// Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
Bool16 hasAuthentication = false;
StrPtrLen strPtr;
StrPtrLen authType;
StrPtrLen authString;
while (theFullRequestPtr->GetDataRemaining() > 0)
{
theFullRequestPtr->ConsumeWhitespace();
theFullRequestPtr->ConsumeUntilWhitespace(&strPtr);
if ( strPtr.Len == 0 || !strPtr.Equal(StrPtrLen("Authorization:")) )
continue;
theFullRequestPtr->ConsumeWhitespace();
theFullRequestPtr->ConsumeUntilWhitespace(&authType);
if ( authType.Len == 0 )
continue;
theFullRequestPtr->ConsumeWhitespace();
theFullRequestPtr->ConsumeUntil(&authString, StringParser::sEOLMask);
if ( authString.Len == 0 )
continue;
if (outAuthTypePtr != NULL)
outAuthTypePtr->Set(authType.Ptr, authType.Len);
if (authType.Equal(StrPtrLen("Basic") ) )
{
(void) ParseAuthNameAndPassword(&authString,namePtr, passwordPtr);
if (namePtr->Len == 0)
continue;
hasAuthentication = true;
break;
}
else if (authType.Equal(sAuthRef) )
{
namePtr->Set(NULL,0);
passwordPtr->Set(authString.Ptr, authString.Len);
hasAuthentication = true;
break;
}
};
return hasAuthentication;
}
QTSS_RTSPHeader RTSPProtocol::GetRequestHeader(const StrPtrLen &inHeaderStr)
{
if (inHeaderStr.Len == 0)
return qtssIllegalHeader;
QTSS_RTSPHeader theHeader = qtssIllegalHeader;
//chances are this is one of our selected "VIP" headers. so check for this.
switch(*inHeaderStr.Ptr)
{
case 'C': case 'c': theHeader = qtssCSeqHeader; break;
case 'S': case 's': theHeader = qtssSessionHeader; break;
case 'U': case 'u': theHeader = qtssUserAgentHeader; break;
case 'A': case 'a': theHeader = qtssAcceptHeader; break;
case 'T': case 't': theHeader = qtssTransportHeader; break;
case 'R': case 'r': theHeader = qtssRangeHeader; break;
case 'X': case 'x': theHeader = qtssExtensionHeaders; break;
}
//
// Check to see whether this is one of our extension headers. These
// are very likely to appear in requests.
if (theHeader == qtssExtensionHeaders)
{
for (SInt32 y = qtssExtensionHeaders; y < qtssNumHeaders; y++)
{
if (inHeaderStr.EqualIgnoreCase(sHeaders[y].Ptr, sHeaders[y].Len))
return y;
}
}
//
// It's not one of our extension headers, check to see if this is one of
// our normal VIP headers
if ((theHeader != qtssIllegalHeader) &&
(inHeaderStr.EqualIgnoreCase(sHeaders[theHeader].Ptr, sHeaders[theHeader].Len)))
return theHeader;
//
//If this isn't one of our VIP headers, go through the remaining request headers, trying
//to find the right one.
for (SInt32 x = qtssNumVIPHeaders; x < qtssNumHeaders; x++)
{
if (inHeaderStr.EqualIgnoreCase(sHeaders[x].Ptr, sHeaders[x].Len))
return x;
}
return qtssIllegalHeader;
}
void QTSServerPrefs::UpdateAuthScheme()
{
static StrPtrLen sNoAuthScheme("none");
static StrPtrLen sBasicAuthScheme("basic");
static StrPtrLen sDigestAuthScheme("digest");
// Get the auth scheme attribute
StrPtrLen* theAuthScheme = this->GetValue(qtssPrefsAuthenticationScheme);
if (theAuthScheme->Equal(sNoAuthScheme))
fAuthScheme = qtssAuthNone;
else if (theAuthScheme->Equal(sBasicAuthScheme))
fAuthScheme = qtssAuthBasic;
else if (theAuthScheme->Equal(sDigestAuthScheme))
fAuthScheme = qtssAuthDigest;
}
void RTConnectionManager::GenericSessionId(std::string& strId)
{
SInt64 curTime = OS::Microseconds();
MD5_CTX context;
StrPtrLen hashStr;
OSMutexLocker locker(&s_mutex);
memset(s_curMicroSecStr, 0, 128);
memset(s_digest, 0, 16);
qtss_sprintf(s_curMicroSecStr, "%lld", curTime);
MD5_Init(&context);
MD5_Update(&context, (unsigned char*)s_curMicroSecStr, (unsigned int)strlen((const char*)s_curMicroSecStr));
MD5_Update(&context, (unsigned char*)m_lastUpdateTime.c_str(), (unsigned int)m_lastUpdateTime.length());
MD5_Final(s_digest, &context);
HashToString(s_digest, &hashStr);
strId = hashStr.GetAsCString();
m_lastUpdateTime = s_curMicroSecStr;
}
void RTSPRequest::ParseTimeToLiveSubHeader(StrPtrLen* inTimeToLiveSubHeader)
{
static StrPtrLen sTimeToLiveSubHeader("ttl");
StringParser theSubHeaderParser(inTimeToLiveSubHeader);
// Skip over to the first part
StrPtrLen theFirstBit;
theSubHeaderParser.GetThru(&theFirstBit, '=');
theFirstBit.TrimWhitespace();
// Make sure this is the ttl subheader
if (!theFirstBit.EqualIgnoreCase(sTimeToLiveSubHeader))
return;
// Parse out the time to live...
theSubHeaderParser.ConsumeWhitespace();
fTtl = (UInt16)theSubHeaderParser.ConsumeInteger(NULL);
}
void RTSPRequest::ParsePrebufferHeader()
{
StringParser thePrebufferParser(fHeaderDictionary.GetValue(qtssXPreBufferHeader));
StrPtrLen thePrebufferArg;
while (thePrebufferParser.GetThru(&thePrebufferArg, '='))
{
thePrebufferArg.TrimWhitespace();
static const StrPtrLen kMaxTimeSubHeader("maxtime");
if (thePrebufferArg.EqualIgnoreCase(kMaxTimeSubHeader))
{
thePrebufferParser.ConsumeWhitespace();
fPrebufferAmt = thePrebufferParser.ConsumeFloat();
}
thePrebufferParser.GetThru(NULL, ';'); //Skip past ';'
}
}
QTSS_Error RTSPRequest::ParseBasicHeader(StringParser *inParsedAuthLinePtr)
{
QTSS_Error theErr = QTSS_NoErr;
fAuthScheme = qtssAuthBasic;
StrPtrLen authWord;
inParsedAuthLinePtr->ConsumeWhitespace();
inParsedAuthLinePtr->ConsumeUntilWhitespace(&authWord);
if (0 == authWord.Len )
return theErr;
char* encodedStr = authWord.GetAsCString();
OSCharArrayDeleter encodedStrDeleter(encodedStr);
char *decodedAuthWord = NEW char[Base64decode_len(encodedStr) + 1];
OSCharArrayDeleter decodedAuthWordDeleter(decodedAuthWord);
(void) Base64decode(decodedAuthWord, encodedStr);
StrPtrLen nameAndPassword;
nameAndPassword.Set(decodedAuthWord, ::strlen(decodedAuthWord));
StrPtrLen name("");
StrPtrLen password("");
StringParser parsedNameAndPassword(&nameAndPassword);
parsedNameAndPassword.ConsumeUntil(&name,':');
parsedNameAndPassword.ConsumeLength(NULL, 1);
parsedNameAndPassword.GetThruEOL(&password);
// Set the qtssRTSPReqUserName and qtssRTSPReqUserPassword attributes in the Request object
(void) this->SetValue(qtssRTSPReqUserName, 0, name.Ptr , name.Len, QTSSDictionary::kDontObeyReadOnly);
(void) this->SetValue(qtssRTSPReqUserPassword, 0, password.Ptr , password.Len, QTSSDictionary::kDontObeyReadOnly);
// Also set the qtssUserName attribute in the qtssRTSPReqUserProfile object attribute of the Request Object
(void) fUserProfile.SetValue(qtssUserName, 0, name.Ptr, name.Len, QTSSDictionary::kDontObeyReadOnly);
return theErr;
}
char* GetPrefAsString(QTSS_ModulePrefsObject inPrefsObject, char* inPrefName)
{
static StrPtrLen sEmpty("");
//
// Get the attribute ID of this pref.
QTSS_AttributeID theID = qtssIllegalAttrID;
if(inPrefsObject != NULL)
theID = QTSSModuleUtils::GetAttrID(inPrefsObject, inPrefName);
char* theString = NULL;
if(inPrefsObject != NULL)
(void)QTSS_GetValueAsString(inPrefsObject, theID, 0, &theString);
if (theString == NULL)
theString = sEmpty.GetAsCString();
return theString;
}
void RTSPRequest::ParseModeSubHeader(StrPtrLen* inModeSubHeader)
{
static StrPtrLen sModeSubHeader("mode");
static StrPtrLen sReceiveMode("receive");
static StrPtrLen sRecordMode("record");
StringParser theSubHeaderParser(inModeSubHeader);
// Skip over to the first port
StrPtrLen theFirstBit;
theSubHeaderParser.GetThru(&theFirstBit, '=');
theFirstBit.TrimWhitespace();
// Make sure this is the client port subheader
if (theFirstBit.EqualIgnoreCase(sModeSubHeader)) do
{
theSubHeaderParser.ConsumeWhitespace();
StrPtrLen theMode;
theSubHeaderParser.ConsumeWord(&theMode);
if ( theMode.EqualIgnoreCase(sReceiveMode) || theMode.EqualIgnoreCase(sRecordMode) )
{ fTransportMode = qtssRTPTransportModeRecord;
break;
}
} while (false);
}
// Parse out the URL from the HTTP GET line.
Bool16 ParseURL(StrPtrLen& theRequest, char* outURL, UInt16 maxlen)
{
StringParser reqParse(&theRequest);
StrPtrLen strPtr;
::memset(outURL, 0, maxlen);
reqParse.ConsumeWord(&strPtr);
if ( !strPtr.Equal(StrPtrLen("GET")) )
{
return false;
}
reqParse.ConsumeWhitespace();
reqParse.ConsumeUntilWhitespace(&strPtr);
if (strPtr.Len == 0)
return false;
else if ((UInt16)strPtr.Len > maxlen-1)
strPtr.Len = maxlen-1;
::memcpy(outURL, strPtr.Ptr, strPtr.Len);
return true;
}
void RTSPRequest::ParseClientPortSubHeader(StrPtrLen* inClientPortSubHeader)
{
static StrPtrLen sClientPortSubHeader("client_port");
static StrPtrLen sErrorMessage("Received invalid client_port field: ");
StringParser theSubHeaderParser(inClientPortSubHeader);
// Skip over to the first port
StrPtrLen theFirstBit;
theSubHeaderParser.GetThru(&theFirstBit, '=');
theFirstBit.TrimWhitespace();
// Make sure this is the client port subheader
if (!theFirstBit.EqualIgnoreCase(sClientPortSubHeader))
return;
// Store the two client ports as integers
theSubHeaderParser.ConsumeWhitespace();
fClientPortA = (UInt16)theSubHeaderParser.ConsumeInteger(NULL);
theSubHeaderParser.GetThru(NULL,'-');
theSubHeaderParser.ConsumeWhitespace();
fClientPortB = (UInt16)theSubHeaderParser.ConsumeInteger(NULL);
if (fClientPortB != fClientPortA + 1) // an error in the port values
{
// The following to setup and log the error as a message level 2.
StrPtrLen *userAgentPtr = fHeaderDictionary.GetValue(qtssUserAgentHeader);
ResizeableStringFormatter errorPortMessage;
errorPortMessage.Put(sErrorMessage);
if (userAgentPtr != NULL)
errorPortMessage.Put(*userAgentPtr);
errorPortMessage.PutSpace();
errorPortMessage.Put(*inClientPortSubHeader);
errorPortMessage.PutTerminator();
QTSSModuleUtils::LogError(qtssMessageVerbosity,qtssMsgNoMessage, 0, errorPortMessage.GetBufPtr(), NULL);
//fix the rtcp port and hope it works.
fClientPortB = fClientPortA + 1;
}
}
void RTSPRequest::ParseTransportOptionsHeader()
{
StringParser theRTPOptionsParser(fHeaderDictionary.GetValue(qtssXTransportOptionsHeader));
StrPtrLen theRTPOptionsSubHeader;
do
{
static StrPtrLen sLateTolerance("late-tolerance");
if (theRTPOptionsSubHeader.NumEqualIgnoreCase(sLateTolerance.Ptr, sLateTolerance.Len))
{
StringParser theLateTolParser(&theRTPOptionsSubHeader);
theLateTolParser.GetThru(NULL,'=');
theLateTolParser.ConsumeWhitespace();
fLateTolerance = theLateTolParser.ConsumeFloat();
fLateToleranceStr = theRTPOptionsSubHeader;
}
(void)theRTPOptionsParser.GetThru(&theRTPOptionsSubHeader, ';');
} while(theRTPOptionsSubHeader.Len > 0);
}
QTSS_Error Initialize(QTSS_Initialize_Params* inParams)
{
// Setup module utils
QTSSModuleUtils::Initialize(inParams->inMessages, inParams->inServer, inParams->inErrorLogStream);
sAccessLogPrefs = QTSSModuleUtils::GetModulePrefsObject(QTSSModuleUtils::GetModuleObjectByName("QTSSAccessLogModule"));
sReflectorPrefs = QTSSModuleUtils::GetModulePrefsObject(QTSSModuleUtils::GetModuleObjectByName("QTSSReflectorModule"));
sPrefs = QTSSModuleUtils::GetModulePrefsObject(inParams->inModule);
// This module may not be present, so be careful...
QTSS_ModuleObject theSvrControlModule = QTSSModuleUtils::GetModuleObjectByName("QTSSSvrControlModule");
if (theSvrControlModule != NULL)
sSvrControlPrefs = QTSSModuleUtils::GetModulePrefsObject(theSvrControlModule);
sServer = inParams->inServer;
sServerPrefs = inParams->inPrefs;
sStartupTime = ::time(NULL);
sDefaultURLStr.Delete();
sDefaultURLStr.Set(QTSSModuleUtils::GetStringAttribute(sPrefs, sDefaultURLPrefName, sDefaultURL));
return QTSS_NoErr;
}
SDPContainer* QTSS3GPPModuleUtils::Get3GPPSDPFeatureListCopy(ResizeableStringFormatter &buffer)
{
SDPContainer* resultList = NEW SDPContainer;
StrPtrLen theLinePtr;
if (s3gppEnabled)
{
if (s3gppRateAdaptationEnabled)
{
buffer.Put(s3gppBitRateAdaptationSDPStr);
buffer.Put((SInt32)s3gppRateAdaptationReportFrequency);
buffer.PutEOL();
theLinePtr.Set(buffer.GetBufPtr(), buffer.GetBytesWritten());
resultList->AddHeaderLine(&theLinePtr);
buffer.Reset();
}
}
return resultList;
}
void QueryParamList::BulidList( StrPtrLen* querySPL )
{
// parse the string and build the name/value list from the tokens.
// the string is a 'form' encoded query string ( see rfc - 1808 )
StringParser queryParser( querySPL );
char *stopCharPtr = NULL;
while ( queryParser.GetDataRemaining() > 0 )
{
StrPtrLen theCGIParamName;
StrPtrLen theCGIParamValue;
queryParser.ConsumeUntil(&theCGIParamName, '='); // leaves "=..." in cgiParser, puts item keywd in theCGIParamName
if ( queryParser.GetDataRemaining() > 1 )
{
queryParser.ConsumeLength(&theCGIParamValue, 1 ); // the '='
stopCharPtr = queryParser.GetCurrentPosition();
if (*stopCharPtr == '"') // if quote read to next quote
{
queryParser.ConsumeLength(NULL, 1);
queryParser.ConsumeUntil(&theCGIParamValue, '"');
queryParser.ConsumeLength(NULL, 1);
queryParser.ConsumeUntil(NULL, '&'); // our value will end by here...
}
else
queryParser.ConsumeUntil(&theCGIParamValue, '&'); // our value will end by here...
AddNameValuePairToList( theCGIParamName.GetAsCString(), theCGIParamValue.GetAsCString() );
queryParser.ConsumeLength(&theCGIParamValue, 1 ); // the '='
}
}
}
QTSS_RTSPMethod
RTSPProtocol::GetMethod(const StrPtrLen &inMethodStr)
{
//chances are this is one of our selected "VIP" methods. so check for this.
QTSS_RTSPMethod theMethod = qtssIllegalMethod;
switch(*inMethodStr.Ptr)
{
case 'S': case 's': theMethod = qtssSetupMethod; break;
case 'D': case 'd': theMethod = qtssDescribeMethod; break;
case 'T': case 't': theMethod = qtssTeardownMethod; break;
case 'O': case 'o': theMethod = qtssOptionsMethod; break;
case 'A': case 'a': theMethod = qtssAnnounceMethod; break;
}
if ((theMethod != qtssIllegalMethod) &&
(inMethodStr.EqualIgnoreCase(sMethods[theMethod].Ptr, sMethods[theMethod].Len)))
return theMethod;
for (SInt32 x = qtssNumVIPMethods; x < qtssIllegalMethod; x++)
if (inMethodStr.EqualIgnoreCase(sMethods[x].Ptr, sMethods[x].Len))
return x;
return qtssIllegalMethod;
}
inline Bool16 IsAdminRequest(StringParser *theFullRequestPtr)
{
Bool16 handleRequest = false;
if (theFullRequestPtr != NULL) do
{
StrPtrLen strPtr;
theFullRequestPtr->ConsumeWord(&strPtr);
if ( !strPtr.Equal(StrPtrLen("GET")) ) break; //it's a "Get" request
theFullRequestPtr->ConsumeWhitespace();
if ( !theFullRequestPtr->Expect('/') ) break;
theFullRequestPtr->ConsumeWord(&strPtr);
if ( strPtr.Len == 0 || !strPtr.Equal(StrPtrLen("modules") ) ) break;
if (!theFullRequestPtr->Expect('/') ) break;
theFullRequestPtr->ConsumeWord(&strPtr);
if ( strPtr.Len == 0 || !strPtr.Equal(StrPtrLen("admin") ) ) break;
handleRequest = true;
} while (false);
return handleRequest;
}
void RTSPRequest::ParseRetransmitHeader()
{
StringParser theRetransmitParser(fHeaderDictionary.GetValue(qtssXRetransmitHeader));
StrPtrLen theProtName;
Bool16 foundRetransmitProt = false;
do
{
theRetransmitParser.ConsumeWhitespace();
theRetransmitParser.ConsumeWord(&theProtName);
theProtName.TrimTrailingWhitespace();
foundRetransmitProt = theProtName.EqualIgnoreCase(RTSPProtocol::GetRetransmitProtocolName());
}
while ( (!foundRetransmitProt) &&
(theRetransmitParser.GetThru(NULL, ',')) );
if (!foundRetransmitProt)
return;
//
// We are using Reliable RTP as the transport for this stream,
// but if there was a previous transport header that indicated TCP,
// do not set the transport to be reliable UDP
if (fTransportType == qtssRTPTransportTypeUDP)
fTransportType = qtssRTPTransportTypeReliableUDP;
StrPtrLen theProtArg;
while (theRetransmitParser.GetThru(&theProtArg, '='))
{
//
// Parse out params
static const StrPtrLen kWindow("window");
theProtArg.TrimWhitespace();
if (theProtArg.EqualIgnoreCase(kWindow))
{
theRetransmitParser.ConsumeWhitespace();
fWindowSize = theRetransmitParser.ConsumeInteger(NULL);
// Save out the window size argument as a string so we
// can easily put it into the response
// (we never muck with this header)
fWindowSizeStr.Ptr = theProtArg.Ptr;
fWindowSizeStr.Len = theRetransmitParser.GetCurrentPosition() - theProtArg.Ptr;
}
theRetransmitParser.GetThru(NULL, ';'); //Skip past ';'
}
}
QTSS_ModulePrefsObject QTSSModuleUtils::GetModuleObjectByName(const StrPtrLen& inModuleName)
{
QTSS_ModuleObject theModule = NULL;
UInt32 theLen = sizeof(theModule);
for (int x = 0; QTSS_GetValue(sServer, qtssSvrModuleObjects, x, &theModule, &theLen) == QTSS_NoErr; x++)
{
Assert(theModule != NULL);
Assert(theLen == sizeof(theModule));
StrPtrLen theName;
QTSS_Error theErr = QTSS_GetValuePtr(theModule, qtssModName, 0, (void**)(void*)&theName.Ptr, &theName.Len);
Assert(theErr == QTSS_NoErr);
if (inModuleName.Equal(theName))
return theModule;
#if DEBUG
theModule = NULL;
theLen = sizeof(theModule);
#endif
}
return NULL;
}
void QTSServerPrefs::UpdatePrintfOptions()
{
StrPtrLen* theOptions = this->GetValue(qtssPrefsPacketHeaderPrintfOptions);
if (theOptions == NULL || theOptions->Len == 0)
return;
fPacketHeaderPrintfOptions = 0;
if (theOptions->FindStringIgnoreCase("rtp"))
fPacketHeaderPrintfOptions |= kRTPALL;
if (theOptions->FindStringIgnoreCase("sr"))
fPacketHeaderPrintfOptions |= kRTCPSR;
if (theOptions->FindStringIgnoreCase("rr"))
fPacketHeaderPrintfOptions |= kRTCPRR;
if (theOptions->FindStringIgnoreCase("app"))
fPacketHeaderPrintfOptions |= kRTCPAPP;
if (theOptions->FindStringIgnoreCase("ack"))
fPacketHeaderPrintfOptions |= kRTCPACK;
}
//获取服务器RTP/RTCP包头打印选项的预设值,解析并重新设置数据成员fPacketHeaderPrintfOptions
void QTSServerPrefs::UpdatePrintfOptions()
{
//首先获得服务器RTP/RTCP包头打印选项的预设值,假如没有,立即返回
StrPtrLen* theOptions = this->GetValue(qtssPrefsPacketHeaderPrintfOptions);
if (theOptions == NULL || theOptions->Len == 0)
return;
//解析该预设值,重新设置数据成员fPacketHeaderPrintfOptions
fPacketHeaderPrintfOptions = 0;
if (theOptions->FindStringIgnoreCase("rtp"))
fPacketHeaderPrintfOptions |= kRTPALL;
if (theOptions->FindStringIgnoreCase("sr"))
fPacketHeaderPrintfOptions |= kRTCPSR;
if (theOptions->FindStringIgnoreCase("rr"))
fPacketHeaderPrintfOptions |= kRTCPRR;
if (theOptions->FindStringIgnoreCase("app"))
fPacketHeaderPrintfOptions |= kRTCPAPP;
if (theOptions->FindStringIgnoreCase("ack"))
fPacketHeaderPrintfOptions |= kRTCPACK;
}
void AccessChecker::GetAccessFileInfo(const char* inQTAccessDir)
{
Assert( fAccessFile != NULL);
const int kBufLen = 2048;
char buf[kBufLen];
StrPtrLen bufLine;
::qtss_printf("QTSSDemoODAuthModule: File Info\n");
while ( std::fgets(buf, kBufLen, fAccessFile) != NULL )
{
bufLine.Set(buf, strlen(buf));
StringParser bufParser(&bufLine);
//skip over leading whitespace
bufParser.ConsumeUntil(NULL, StringParser::sWhitespaceMask);
//skip over comments and blank lines...
if ( (bufParser.GetDataRemaining() == 0) || (bufParser[0] == '#') || (bufParser[0] == '\0') )
continue;
StrPtrLen word;
bufParser.ConsumeWord(&word);
bufParser.ConsumeWhitespace();
if ( word.Equal("AuthName") ) //realm name
{
bufParser.GetThruEOL(&word);
fRealmHeader = word.Ptr;
}
else if ( word.Equal("AuthUserFile" ) ) //users name
{
char filePath[kBufLen];
bufParser.GetThruEOL(&word);
if (word.Ptr[0] == '/') //absolute path
{
std::memcpy(filePath, word.Ptr, word.Len);
filePath[word.Len] = '\0';
}
else
{
std::snprintf(filePath, sizeof(filePath), "%s/%s", inQTAccessDir, word.Ptr);
}
fUsersFile = std::fopen(filePath, "r");
}
else if ( word.Equal("AuthGroupFile") ) //groups name
{
char filePath[kBufLen];
bufParser.GetThruEOL(&word);
if (word.Ptr[0] == '/') //absolute path
{
std::memcpy(filePath, word.Ptr, word.Len);
filePath[word.Len] = '\0';
}
else
{
std::snprintf(filePath, sizeof(filePath), "%s/%s", inQTAccessDir, word.Ptr);
}
fGroupsFile = std::fopen(filePath, "r");
}
}
if (fUsersFile == NULL)
{
fUsersFile = std::fopen(fUsersFilePath.c_str(), "r");
}
if (fGroupsFile == NULL)
{
fGroupsFile = std::fopen(fGroupsFilePath.c_str(), "r");
}
}