/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:    RTSP command/response common part*

*/

// INCLUDE FILES

#include "CRRtspCommon.h"

#include "videoserviceutilsLogger.h"

// CONSTANTS

const TReal KRealZero( 0.0 ); 

const TReal KRealMinusOne( -1.0 ); 

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CCRRtspCommon::CCRRtspCommon

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

CCRRtspCommon::CCRRtspCommon ()

  : iContentLen( KErrNotFound ),

    iContent( NULL, 0 ),

    iCSeq( KErrNotFound ),

    iSessionId( NULL, 0 ),

    iClientPort( KErrNotFound ),

    iLowerRange( KRealZero ),

    iUpperRange( KRealMinusOne ),

    iIsLiveStream( EFalse )

    {  

    // None

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::~CCRRtspCommon

// Destructor.

// -----------------------------------------------------------------------------

//

CCRRtspCommon::~CCRRtspCommon()

    {

    LOG( "CCRRtspCommon::~CCRRtspCommon()" );

    delete iRtspText; 

    delete iRealm;

    delete iOpaque;

    delete iNonce;

    delete iUserName;

    delete iUri; 

    delete iPassword;

    delete iAuthType;

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::CSeq

// 

// -----------------------------------------------------------------------------

//

TInt CCRRtspCommon::CSeq( void ) 

    {

    return iCSeq;   

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::SetCSeq

// 

// -----------------------------------------------------------------------------

//

void CCRRtspCommon::SetCSeq( TInt aCSeq ) 

    {

    iCSeq = aCSeq;  

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::FindCSeqL

// 

// -----------------------------------------------------------------------------

//

void CCRRtspCommon::FindCSeqL( void ) 

    {

    TInt offSet( iRtspText->FindC( KCRCSeq() ) ); 

    if ( offSet == KErrNotFound ) 

        {

        LOG( "CCRRtspCommon::FindCSeqL FAILED, 'CSeq' not found [1]" );

        User::Leave ( KErrNotSupported ); 

        }

    offSet += KCRCSeq().Length();       

    TInt eolOffSet = iRtspText->Right ( iRtspText->Length() - 

                                        offSet ).Find ( KCRNewLine() ); 

    if ( eolOffSet == KErrNotFound ) 

        {

        LOG1( "CCRRtspCommon::FindCSeqL FAILED, 'CSeq' not found [2], offset=%d", offSet );

        User::Leave ( KErrNotSupported ); 

        }

    TPtrC8 CSeqString ( iRtspText->Mid ( offSet, eolOffSet ) );     

    TLex8 CSeqNumberLex( CSeqString ); 

    User::LeaveIfError ( CSeqNumberLex.Val( iCSeq ) ) ;

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::FindSessionIdL

//

// method that finds session id from RTSP response

// -----------------------------------------------------------------------------

//  

void CCRRtspCommon::FindSessionIdL( void ) 

    {

    iSessionId.Set( NULL, 0 );

    TInt sessionStringOffset( iRtspText->FindC( KCRNlAndSession() ) );

    if ( sessionStringOffset > 0 )

        {

        TPtrC8 beginningFromSession( iRtspText->Right( iRtspText->Length() - 

                                   ( sessionStringOffset + 11 ) ) );

        TInt lfStringOffset( beginningFromSession.Find( KCRNewLine ) );

        if ( lfStringOffset != KErrNotFound )

            {

            iSessionId.Set( beginningFromSession.Mid( 0, lfStringOffset ) );

            // with some servers there is;Timeout=xxx after the session id; 

            // lets strip that out:

            TInt semicolonOffset( iSessionId.Locate( ';' ) ); 

            if ( semicolonOffset > 0 )

                {

                iSessionId.Set( iSessionId.Mid( 0, semicolonOffset ) ); 

                }

            }

        }

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::SessionId

//

// method that returns session id string

// -----------------------------------------------------------------------------

//  

TInt CCRRtspCommon::SessionId( TPtrC8& aId ) 

    {

    if ( iSessionId.Ptr() != NULL )     

        {

        aId.Set( iSessionId ); 

        return KErrNone;

        }

    else

        {

        return KErrNotFound; 

        }       

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::SetSessionId

//

// 

// -----------------------------------------------------------------------------

//  

void CCRRtspCommon::SetSessionId( TPtrC8& aId ) 

    {

    iSessionId.Set( aId ); 

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::FindContentL

//

// 

// -----------------------------------------------------------------------------

//  

void CCRRtspCommon::FindContentL( void ) 

    {

#ifdef _DEBUG       

    _LIT(KPanicStr, "RTSPCommon"); 

    __ASSERT_DEBUG( iRtspText, 

                    User::Panic( KPanicStr, KErrBadHandle ) );

#endif                    

    // find possible content:

    //

    TInt replyEndOffSet( iRtspText->Find( KCR2NewLines ) );

    if ( replyEndOffSet > KErrNotFound )

        {

        replyEndOffSet += KCR2NewLines().Length();

        }

    // next thing to check if there is content-length-header, 

    // it seems like it may follow about any response..

    //

    TInt contentLenOffset( KErrNotFound ); 

    iContentLen = KErrNotFound; // this will hold (usually SDP) length

    if ( ( contentLenOffset = iRtspText->Des().FindC( 

                              KCRRTSPContentLength() ) ) != KErrNotFound )

        {

        TLex8 contentLenLex( iRtspText->Des().Mid( contentLenOffset + 16, 5 ) );

        User::LeaveIfError( contentLenLex.Val( iContentLen ) ); 

        }

    LOG1( "CCRRtspCommon::FindContentL(), iContentLen: %d", iContentLen );                       

    // then set content in place    

    if ( replyEndOffSet > iRtspText->Length() )

        {

        LOG( "CCRRtspCommon::FindContentL() out because too litle data !" );

        User::Leave( KErrUnderflow ); 

        }

    if ( iContentLen > KErrNotFound )

        {   

        iContent.Set( iRtspText->Des().Mid( replyEndOffSet, iContentLen ) );

        }

    else

        {

        iContent.Set( NULL, 0 );

        }

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::ContentLen

// 

// -----------------------------------------------------------------------------

//

TInt CCRRtspCommon::ContentLen( void ) 

    {

    return iContentLen; 

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::Content

// 

// -----------------------------------------------------------------------------

//

TPtrC8& CCRRtspCommon::Content( void ) 

    {

    return iContent ; 

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::FindClientPorts

//

// method that finds client port numeric value

// -----------------------------------------------------------------------------

//  

void CCRRtspCommon::FindClientPorts( void )

    {

    iClientPort = KErrNotFound;

    // Bend concept of client port to mean also the interleaved channel for TCP streaming

    const TDesC8& portdes( ( iTransport == ERTPOverTCP )? KCRInterleaved():

                           ( iTransport == ERTPOverMulticast )? KCRPort():

                            KCRClient_Port() );

    TInt portNumberOffset( iRtspText->FindC( portdes ) ); 

    if ( portNumberOffset != KErrNotFound )

        {

        TPtrC8 portNumberStr( iRtspText->Mid( portNumberOffset + portdes.Length() ) );

        TInt endoffset = portNumberStr.FindC( KCRDash() );

        if ( endoffset >= 0 )

            {

            portNumberStr.Set( portNumberStr.Left( endoffset ) );

            }

        else

            {

            endoffset = portNumberStr.FindC( KCRSemiColon() );

            if ( endoffset >= 0 )

                {

                portNumberStr.Set( portNumberStr.Left( endoffset ) );

                }

            }

        TLex8 portNumberLex( portNumberStr );

        if ( portNumberLex.Val( iClientPort ) != KErrNone )

            { // something wrong? 

            LOG( "CCRRtspCommon::FindClientPorts val != KErrNone" );

            }

        }

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::ClientPort

//

// method that returns client port numeric value

// -----------------------------------------------------------------------------

//  

TInt CCRRtspCommon::ClientPort( void )

    {

    return iClientPort; 

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::SetClientPort

//

// method that sets client port numeric value

// -----------------------------------------------------------------------------

//  

void CCRRtspCommon::SetClientPort( TInt aPort )

    {

    iClientPort = aPort; 

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::FindTransport

// -----------------------------------------------------------------------------

//

void CCRRtspCommon::FindTransport()

    {

    // User TCP streaming if 'RTP/AVP/TCP' found

    if ( iRtspText->FindC( KCRSDPRTPAVPTCP ) != KErrNotFound )

        {

        iTransport = ERTPOverTCP;

        }

    // multicast UDP if 'multicast' present

    else if ( iRtspText->FindC( KCRSDPMulticast ) != KErrNotFound ||

              iRtspText->FindC( KCRSDPRTPAVPUDP ) != KErrNotFound &&

              iRtspText->FindC( KCRDestination )  != KErrNotFound )

        {

        iTransport = ERTPOverMulticast;

        }

    // otherwise, plain unicast UDP

    else

        {

        iTransport = ERTPOverUDP;

        }

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::Transport

// -----------------------------------------------------------------------------

//

TCRRTPTransport CCRRtspCommon::Transport()

    {

    return iTransport;

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::SetTransport

// -----------------------------------------------------------------------------

//

void CCRRtspCommon::SetTransport( TCRRTPTransport aTransport )

    {

    iTransport = aTransport; 

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::FindDestination

// -----------------------------------------------------------------------------

//

void CCRRtspCommon::FindDestination()

    {

    // resets destination to KAFUnspec

    iDestination = TInetAddr();

    // search for destination

    TInt startoffset = iRtspText->FindC( KCRDestination() );

    if ( startoffset >= 0 )

        {

        startoffset += KCRDestination().Length();

        TPtrC8 destdes = iRtspText->Mid( startoffset );

        TInt endoffset = destdes.FindC( KCRSemiColon() );

        if ( endoffset >= 0 )

            {

            destdes.Set( destdes.Left(endoffset) );

            }

        TBuf<128> destbuf;

        destbuf.Copy( destdes.Left(128) );

        TInt err = iDestination.Input( destbuf );

        if ( err != KErrNone )

            {

            LOG1( "CCRRtspCommon::FindDestination(), INVALID destination address '%S'", &destbuf );

            }

        else

            {

            LOG1( "CCRRtspCommon::FindDestination(), multicast address '%S'", &destbuf );

            iDestination.ConvertToV4Mapped();

            }

        }

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::Destination

// -----------------------------------------------------------------------------

//

const TInetAddr& CCRRtspCommon::Destination()

    {

    return iDestination;

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::SetRange

//

// method that sets Range: header values

// -----------------------------------------------------------------------------

//  

void CCRRtspCommon::SetRange( TReal aLower , TReal aUpper ) 

    {

    iLowerRange = aLower; 

    iUpperRange = aUpper; 

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::GetRange

//

// method that gets Range: header values

// -----------------------------------------------------------------------------

//  

void CCRRtspCommon::GetRange( TReal& aLower , TReal& aUpper ) 

    {

    aLower = iLowerRange; 

    aUpper = iUpperRange; 

    }

// -----------------------------------------------------------------------------

// CCRRtspCommon::ParseRange

//

// method that tries to parse contents of possible Range: header 

// -----------------------------------------------------------------------------

//  

void CCRRtspCommon::ParseRange( void ) 

    {

    if ( iRtspText )

        {

        TInt rangeHeaderOffset( iRtspText->Des().FindC( KCRRangeHeader ) );

        if ( rangeHeaderOffset > 0 )

            {

            // check for live-stream specific range "Range: npt=now-"

            if ( iRtspText->Des().FindC( KCRRangeHeaderLiveStream ) > KErrNotFound )

                { // yes, this is a live stream

                iLowerRange = KRealZero; 

                iUpperRange = KRealMinusOne; 

                iIsLiveStream = ETrue; 

                LOG( "CCRRtspCommon::ParseRange(), Found livestream range" );

                }

            else

                {

                TPtrC8 rangeHeader = iRtspText->Des().Mid(

                                     rangeHeaderOffset + KCRRangeHeader().Length() ); 

                TInt minusSignOffset( rangeHeader.Locate( '-' ) ); 

                if ( minusSignOffset > 0 ) 

                    {

                    TPtrC8 startPosStr = rangeHeader.Left( minusSignOffset ); 

                    TLex8 startPosLex ( startPosStr ); 

                    startPosLex.Val ( iLowerRange ) ; // if .Val fails, value will just remain zero

                    LOG1( "CCRRtspCommon::ParseRange(), start: %f", iLowerRange );

                    }

                TInt lineFeedOffset( rangeHeader.Locate( '\n' ) );

                if ( lineFeedOffset > ( minusSignOffset + 2 ) )

                    {

                    TPtrC8 endPosStr = rangeHeader.Mid( minusSignOffset + 1,

                                       lineFeedOffset - ( minusSignOffset + 1 ) ); 

                    TLex8 endPosLex ( endPosStr ); 

                    endPosLex.Val ( iUpperRange ) ; // if .Val fails, value will just remain -1.0

                    LOG1( "CCRRtspCommon::ParseRange(), end: %f", iUpperRange );

                    }

                else

                    {

                    iUpperRange = KRealMinusOne; 

                    LOG( "CCRRtspCommon::ParseRange(), Setting end range to -1.0" );

                    }

                }

            }

        }   

    }

// -----------------------------------------------------------------------------

// CCRRTSPResponse::AuthenticationTypeL

//

// method that returns authentication type

// -----------------------------------------------------------------------------

//  

TDesC8& CCRRtspCommon::AuthenticationTypeL( void )

    {

    if ( !iAuthType )

        {

        iAuthType = HBufC8::NewL( 0 );

        }

    return *iAuthType;

    }

// -----------------------------------------------------------------------------

// CCRRTSPResponse::NonceL

//

// method that returns session nonce

// -----------------------------------------------------------------------------

//  

TDesC8& CCRRtspCommon::NonceL( void )

    {   

    if ( !iNonce )

        {           

        iNonce = HBufC8::NewL( 0 );

        }   

    return *iNonce;

    }

// -----------------------------------------------------------------------------

// CCRRTSPResponse::RealmL

//

// method that returns session realm

// -----------------------------------------------------------------------------

//  

TDesC8& CCRRtspCommon::RealmL( void )

    {   

    if ( !iRealm )

        {           

        iRealm = HBufC8::NewL( 0 );

        }

    return *iRealm;

    }

// -----------------------------------------------------------------------------

// CCRRTSPResponse::OpaqueL

//

// method that returns session opaque value

// -----------------------------------------------------------------------------

//  

TDesC8& CCRRtspCommon::OpaqueL( void )

    {

    if ( !iOpaque )