void HeadersTest::caseInsensitivity()
{
QFETCH(QByteArray, qbytearray1);
QFETCH(QByteArray, qbytearray2);
const IByteArray ibytearray1 = IByteArray{qbytearray1.constData()};
const IByteArray ibytearray2 = qbytearray2;
Headers headers;
headers.insert(ibytearray1, qbytearray2);
headers.insert(ibytearray2, qbytearray2);
QCOMPARE(headers.count(ibytearray1), 2);
QCOMPARE(headers.count(ibytearray2), 2);
QVERIFY(headers.values(ibytearray1)[0] == headers.values(ibytearray2)[1]);
/* ====================================================================== */
headers.clear();
headers.insert(ibytearray1, qbytearray2);
headers.replace(ibytearray1, qbytearray1);
headers.insert(ibytearray2, qbytearray2);
QCOMPARE(headers.count(ibytearray1), 2);
QCOMPARE(headers.count(ibytearray2), 2);
QVERIFY(headers.values(ibytearray1)[0] != headers.values(ibytearray2)[1]);
}
void QPalringoConnection::onPingReceived( const Headers, const QByteArray /* body */ )
{
Headers h;
if( protocolVersion_ == 2 )
{
h.insert( qpHeaderAttribute::PS, packetSeq_ );
}
sendCmd( qpCommand::PING, h, "");
}
/**
* @brief
*
* @param headers
* @param payload
* @param statusCode
* @param statusText
*
* @return
*/
bool RtspConnection::sendResponse( Headers &headers, std::string payload, int statusCode, std::string statusText )
{
std::string response;
response = stringtf( "RTSP/1.0 %d %s\r\n", statusCode, statusText.c_str() );
//headers.insert( Headers::value_type( "Server", "ZoneMinder Streamer V2.0" ) );
headers.insert( Headers::value_type( "Date", datetimeInet() ) );
for ( Headers::iterator iter = headers.begin(); iter != headers.end(); iter++ )
{
response += iter->first+": "+iter->second+"\r\n";
}
response += "\r\n";
if ( payload.size() )
{
response += payload;
}
Debug( 2, "Sending RTSP response: %s", response.c_str() );
if ( mSocket->send( response.c_str(), response.size() ) != (int)response.length() )
{
Error( "Unable to send response '%s': %s", response.c_str(), strerror(errno) );
return( false );
}
#if 0
// Not currently used. If RTSP over HTTP ever required then will need to do something like this
if ( mMethod == RTP_OZ_RTSP_HTTP )
{
response = base64Encode( response );
Debug( 2, "Sending encoded RTSP response: %s", response.c_str() );
if ( mRtspSocket2.send( response.c_str(), response.size() ) != (int)response.length() )
{
Error( "Unable to send response '%s': %s", response.c_str(), strerror(errno) );
return( false );
}
}
else
{
if ( mRtspSocket.send( response.c_str(), response.size() ) != (int)response.length() )
{
Error( "Unable to send response '%s': %s", response.c_str(), strerror(errno) );
return( false );
}
}
#endif
return( true );
}
void getResponseHeaders(Headers& headers) {
while (true) {
istream line(input.readLine());
Header newHeader;
getline(line, newHeader.first, ':'); // Only read up until the ':'
trim(newHeader.first);
to_lower(newHeader.first);
if (newHeader.first.empty())
break;
getline(line, newHeader.second); // Read the rest of the line
trim(newHeader.second);
headers.insert(newHeader);
}
}
void addHeader( Header const & header )
{
assert( !fromCache() );
includedHeaders_.insert( header );
}
/**
* @brief
*
* @param request
*
* @return
*/
bool RtspConnection::handleRequest( const std::string &request )
{
Debug( 2, "Handling RTSP request: %s (%zd bytes)", request.c_str(), request.size() );
StringTokenList lines( request, "\r\n" );
if ( lines.size() <= 0 )
{
Error( "Unable to split request '%s' into tokens", request.c_str() );
return( false );
}
StringTokenList parts( lines[0], " " );
if ( parts.size() != 3 )
{
Error( "Unable to split request part '%s' into tokens", lines[0].c_str() );
return( false );
}
std::string requestType = parts[0];
Debug( 4, "Got request '%s'", requestType.c_str() );
std::string requestUrl = parts[1];
Debug( 4, "Got requestUrl '%s'", requestUrl.c_str() );
std::string requestVer = parts[2];
Debug( 4, "Got requestVer '%s'", requestVer.c_str() );
if ( requestVer != "RTSP/1.0" )
{
Error( "Unexpected RTSP version '%s'", requestVer.c_str() );
return( false );
}
// Extract headers from request
Headers requestHeaders;
for ( int i = 1; i < lines.size(); i++ )
{
StringTokenList parts( lines[i], ": " );
if ( parts.size() != 2 )
{
Error( "Unable to split request header '%s' into tokens", lines[i].c_str() );
return( false );
}
Debug( 4, "Got header '%s', value '%s'", parts[0].c_str(), parts[1].c_str() );
requestHeaders.insert( Headers::value_type( parts[0], parts[1] ) );
}
if ( requestHeaders.find("CSeq") == requestHeaders.end() )
{
Error( "No CSeq header found" );
return( false );
}
Debug( 4, "Got sequence number %s", requestHeaders["CSeq"].c_str() );
uint32_t session = 0;
if ( requestHeaders.find("Session") != requestHeaders.end() )
{
Debug( 4, "Got session header, '%s', passing to session", requestHeaders["Session"].c_str() );
session = strtol( requestHeaders["Session"].c_str(), NULL, 16 );
}
Headers responseHeaders;
responseHeaders.insert( Headers::value_type( "CSeq", requestHeaders["CSeq"] ) );
if ( requestType == "OPTIONS" )
{
responseHeaders.insert( Headers::value_type( "Public", "DESCRIBE, SETUP, PLAY, GET_PARAMETER, TEARDOWN" ) );
return( sendResponse( responseHeaders ) );
}
else if ( requestType == "DESCRIBE" )
{
FeedProvider *provider = validateRequestUrl( requestUrl );
if ( !provider )
{
sendResponse( responseHeaders, "", 404, "Not Found" );
return( false );
}
const VideoProvider *videoProvider = dynamic_cast<const VideoProvider *>(provider);
int codec = AV_CODEC_ID_MPEG4;
int width = videoProvider->width();
int height = videoProvider->height();
FrameRate frameRate = 15;
//FrameRate frameRate = videoProvider->frameRate();
int bitRate = 90000;
int quality = 70;
std::string sdpFormatString =
"v=0\r\n"
"o=- %jd %jd IN IP4 %s\r\n"
"s=ZoneMinder Stream\r\n"
"i=Media Streamers\r\n"
"c=IN IP4 0.0.0.0\r\n"
"t=0 0\r\n"
"a=control:*\r\n"
"a=range:npt=0.000000-\r\n";
uint64_t now64 = time64();
char hostname[HOST_NAME_MAX] = "";
if ( gethostname( hostname, sizeof(hostname) ) < 0 )
Fatal( "Can't gethostname: %s", strerror(errno) );
std::string sdpString = stringtf( sdpFormatString, now64, now64, hostname );
if ( codec == AV_CODEC_ID_H264 )
{
if ( provider->cl4ss() == "RawH264Input" )
{
std::string encoderKey = H264Relay::getPoolKey( provider->identity(), width, height, frameRate, bitRate, quality );
if ( !(mEncoder = Encoder::getPooledEncoder( encoderKey )) )
{
H264Relay *h264Relay = NULL;
mEncoder = h264Relay = new H264Relay( provider->identity(), width, height, frameRate, bitRate, quality );
mEncoder->registerProvider( *provider );
Encoder::poolEncoder( mEncoder );
h264Relay->start();
}
sdpString += mEncoder->sdpString( 1 ); // XXX - Should be variable
responseHeaders.insert( Headers::value_type( "Content-length", stringtf( "%zd", sdpString.length() ) ) );
}
else
{
std::string encoderKey = H264Encoder::getPoolKey( provider->identity(), width, height, frameRate, bitRate, quality );
if ( !(mEncoder = Encoder::getPooledEncoder( encoderKey )) )
{
H264Encoder *h264Encoder = NULL;
mEncoder = h264Encoder = new H264Encoder( provider->identity(), width, height, frameRate, bitRate, quality );
mEncoder->registerProvider( *provider );
Encoder::poolEncoder( mEncoder );
h264Encoder->start();
}
sdpString += mEncoder->sdpString( 1 ); // XXX - Should be variable
responseHeaders.insert( Headers::value_type( "Content-length", stringtf( "%zd", sdpString.length() ) ) );
}
}
else if ( codec == AV_CODEC_ID_MPEG4 )
{
std::string encoderKey = MpegEncoder::getPoolKey( provider->identity(), width, height, frameRate, bitRate, quality );
if ( !(mEncoder = Encoder::getPooledEncoder( encoderKey )) )
{
MpegEncoder *mpegEncoder = NULL;
mEncoder = mpegEncoder = new MpegEncoder( provider->identity(), width, height, frameRate, bitRate, quality );
mEncoder->registerProvider( *provider );
Encoder::poolEncoder( mEncoder );
mpegEncoder->start();
}
sdpString += mEncoder->sdpString( 1 ); // XXX - Should be variable
responseHeaders.insert( Headers::value_type( "Content-length", stringtf( "%zd", sdpString.length() ) ) );
}
return( sendResponse( responseHeaders, sdpString ) );
}
else if ( requestType == "SETUP" )
{
// These commands are handled by RTSP session so pass them on and send any required responses
RtspSession *rtspSession = 0;
if ( session )
{
rtspSession = mRtspController->getSession( session );
}
else
{
rtspSession = mRtspController->newSession( this, mEncoder );
}
if ( rtspSession->recvRequest( requestType, requestUrl, requestHeaders, responseHeaders ) )
return( sendResponse( responseHeaders ) );
return( false );
}
else if ( requestType == "PLAY" || requestType == "GET_PARAMETER" || requestType == "TEARDOWN" )
{
// These commands are handled by RTSP session so pass them on and send any required responses
RtspSession *rtspSession = 0;
if ( session )
{
rtspSession = mRtspController->getSession( session );
if ( rtspSession && rtspSession->recvRequest( requestType, requestUrl, requestHeaders, responseHeaders ) )
return( sendResponse( responseHeaders ) );
}
return( sendResponse( responseHeaders, "", 454, "Session Not Found" ) );
}
Error( "Unrecognised RTSP command '%s'", requestType.c_str() );
return( sendResponse( responseHeaders, "", 405, "Method not implemented" ) );
}
