/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  GetReferencedObjects -operation implementation

*

*/

// INCLUDE FILES

#include "BTServiceUtils.h"

#include "BTSBPPObjectRequest.h"

#include "BTSUDataConverter.h"

#include "BTSUImageConverter.h"

#include "BTSUDebug.h"

#include <f32file.h>    // RFile

#include <s32mem.h>     // RBufWriteStream

#include <s32file.h>    // RFileReadStream

// CONSTANTS

const TInt KBTSBPPFileSizeNotSet         = 0;

const TInt KBTSBPPFileSizeRequested      = 1;

const TInt KBTSBPPFileSizeUnknown        = -1;

const TInt KBTSBPPRestOfTheFileRequested = -1;

// The field lengths of Application Parameters -header in bytes

//

const TInt KBTSBPPFieldTag       = 1;

const TInt KBTSBPPFieldLength    = 1;

const TInt KBTSBPPValue          = 4;

const TInt KBTSBPPAppParamLength = KBTSBPPFieldTag + KBTSBPPFieldLength + KBTSBPPValue;

_LIT8(KBTSBPPRefObjectOper, "x-obex/referencedobject\0");

static const TUint8 KBTSBPPFileSizeTag = 0x04;

static const TUint8 KBTSBPPFileSizeLength = 0x04;

// MODULE DATA STRUCTURES

enum KBTSBPPAppParamTags

    {

    KBTSBPPTagOffset = 1,

    KBTSBPPTagCount,

    KBTSBPPTagJobId, // used only in JobBased-printing

    KBTSBPPTagFileSize

    };

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

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

// CBTSBPPObjectRequest::CBTSBPPObjectRequest

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

// might leave.

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

//

CBTSBPPObjectRequest::CBTSBPPObjectRequest( CObexBaseObject* aGetOperation,

    const CDesCArray* aRefObjectList ) : iRequest( aGetOperation ), 

                                         iObjectList( aRefObjectList )

    {

    }

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

// CBTSBPPObjectRequest::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CBTSBPPObjectRequest::ConstructL()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::ConstructL()"));

    User::LeaveIfError( iFileSession.Connect() );

    // Check the validity of the operation and it's paramters.

    //

    CheckGetRequestL();

    // Execute any tasks needed and create the requested object.

    //

    ExecuteGetRequestL();

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::ConstructL() completed"));

    }

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

// CBTSBPPObjectRequest::NewL

// Two-phased constructor.

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

//

CBTSBPPObjectRequest* CBTSBPPObjectRequest::NewL( CObexBaseObject* aGetOperation,

                                              const CDesCArray* aRefObjectList )

    {

    CBTSBPPObjectRequest* self = new( ELeave ) CBTSBPPObjectRequest( aGetOperation,

                                                                 aRefObjectList );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CBTSBPPObjectRequest::~CBTSBPPObjectRequest()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::~CBTSBPPObjectRequest()"));

    iFileSession.Close();

    delete iResponse;

    delete iResponseBuffer;

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::~CBTSBPPObjectRequest() completed"));

    }

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

// CBTSBPPObjectRequest::GetResponse

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

//

CObexBufObject* CBTSBPPObjectRequest::GetResponse()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::GetResponse()"));

    return iResponse;

    }

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

// CBTSBPPObjectRequest::CheckGetRequestL

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

//

void CBTSBPPObjectRequest::CheckGetRequestL()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckGetRequestL()"));

    CheckTypeHeaderL();

    CheckNameHeaderL();

    CheckAppParamsHeaderL();

    }

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

// CBTSBPPObjectRequest::CheckTypeHeaderL

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

//

void CBTSBPPObjectRequest::CheckTypeHeaderL()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckTypeHeaderL()"));

    __ASSERT_DEBUG( iRequest, BTSUPanic( EBTSUPanicNullPointer ) );

    const TDesC8& typeHeader = iRequest->Type();

    if ( typeHeader.Length() == 0 )

        {

        FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckTypeHeaderL() ERROR, no type header"));

        User::Leave( KErrNotFound );

        }

    else if ( typeHeader.Length() > KBTSUMaxStringLength )

        {

        FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckTypeHeaderL() ERROR, type header too long"));

        User::Leave( KErrTooBig );

        }

    else

        {

        FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckTypeHeaderL() type header '%S'"), &typeHeader ));

        // The only supported operation is GetReferencedObjects

        //

        if ( typeHeader != KBTSBPPRefObjectOper() )

            {

            FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckTypeHeaderL() ERROR, unsupported operation"));

            User::Leave( KErrNotSupported );

            }

        }

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckTypeHeaderL() completed"));

    }

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

// CBTSBPPObjectRequest::CheckNameHeaderL

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

//

void CBTSBPPObjectRequest::CheckNameHeaderL()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckNameHeaderL()"));

    __ASSERT_DEBUG( iRequest, BTSUPanic( EBTSUPanicNullPointer ) );

    const TDesC& nameHeader = iRequest->Name();

    if ( nameHeader.Length() == 0 )

        {

        FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckNameHeaderL() ERROR, no name header"));

        User::Leave( KErrNotFound );

        }

    else

        {

        FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckNameHeaderL() filename '%S'"), &nameHeader ));

        // Check are we allowed to send this file

        //

        TInt dummy;

        if ( iObjectList->Find( nameHeader, dummy ) != KBTSUEqualStrings )

            {

            FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckNameHeaderL() ERROR, the asked object is not referenced in the document"));

            User::Leave( KErrPermissionDenied );

            }

        iRequestParams.iName = &nameHeader;

        }

    }

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

// CBTSBPPObjectRequest::CheckAppParamsHeaderL

//

// This method expects a Tag-Length-Value format. The method is as defensive 

// as possible, for example unknown or illegal values are discarded.

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

//

void CBTSBPPObjectRequest::CheckAppParamsHeaderL()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckAppParamsHeaderL()"));

    __ASSERT_DEBUG( iRequest, BTSUPanic( EBTSUPanicNullPointer ) );

    TPtrC8 header( iRequest->AppParam() );    

    if ( header.Length() == 0 )

        {

        FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckAppParamsHeaderL() ERROR, no AppParam header"));

        User::Leave( KErrNotFound );

        }

    else if ( header.Length() < KBTSBPPAppParamLength * 2)

        {

        // There has to be at least offset and count -parameters.

        //

        FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckAppParamsHeaderL() ERROR, incomplete AppParam header"));

        User::Leave( KErrArgument );

        }

    else

        {

        // Parse the header

        //

        while( header.Length() >= KBTSBPPAppParamLength )

            {

            // Extract tag number and remove it from the header

            //

            TInt tagNumber = TBTSUDataConverter::ConvertByteL(

                header.Left( KBTSBPPFieldTag ) );

            header.Set( header.Mid( KBTSBPPFieldTag ) );

            // Extract value length and remove it from the header

            //

            TInt valueLength = TBTSUDataConverter::ConvertByteL( 

                header.Left( KBTSBPPFieldLength ) );

            header.Set( header.Mid( KBTSBPPFieldLength ) );

            if ( valueLength != KBTSBPPValue )

                {

                FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckAppParamsHeaderL() WARNING, illegal length %d"), valueLength ));

                valueLength = KBTSBPPValue;

                // This is an interesting choice of what to do, I would argue that for future compatibility you'll probably want to accept the length

                // provided as it might be for a new tag that is not yet published.  (Checking of the size for known tags is handled by the conversion

                // functions anyway).

                // So, in summary I wouldn't change valueLength from what it is in the payload.  But I've left it in for now in case it was added for

                // interoperability reasons with some existing device.

                }

            // Extract value...

            //

            switch ( tagNumber )

                {

                case KBTSBPPTagOffset:

                    {

                    iRequestParams.iOffset = 

                        TBTSUDataConverter::ConvertDataUnsignedL( 

                        header.Left( valueLength ) );

                    FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckAppParamsHeaderL() offset '%d'"), iRequestParams.iOffset ));

                    break;

                    }

                case KBTSBPPTagCount:

                    {

                    iRequestParams.iCount = 

                        TBTSUDataConverter::ConvertDataSignedL( 

                        header.Left( valueLength ) );

                    FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckAppParamsHeaderL() count '%d'"), iRequestParams.iCount ));

                    break;

                    }

                case KBTSBPPTagFileSize:

                    {

                    // The value is not interesting, we just need to know whether 

                    // the parameter was received (and thus requested)

                    //

                    iRequestParams.iOffset = KBTSBPPFileSizeRequested;

                    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::ParseHeadersL() fileSize parameter received"));

                    break;

                    }

                case KBTSBPPTagJobId:

                default:

                    {

                    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckAppParamsHeaderL() WARNING, illegal tag"));

                    break;

                    }

                }

            // ...and remove it from the header

            //

            header.Set( header.Mid( valueLength ) );

            }

        }

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CheckAppParamsHeaderL() completed"));

    }

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

// CBTSBPPObjectRequest::ExecuteGetRequestL

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

//

void CBTSBPPObjectRequest::ExecuteGetRequestL()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::ExecuteGetRequestL()"));

    // If iCount is 0, an empty body will be sent

    //

    if ( iRequestParams.iCount != 0 )

        {

        ResolveGetRequestL();

        ReadFileToBufferL();      

        }

    CreateResponseObjectL();

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::ExecuteGetRequestL() completed"));

    }

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

// CBTSBPPObjectRequest::ResolveGetRequestL

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

//

void CBTSBPPObjectRequest::ResolveGetRequestL()

    {

    FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::ResolveGetRequestL()"));

    // Get the file size

    //

    RFile file;

    TInt size = 0;

    User::LeaveIfError( file.Open( iFileSession, *iRequestParams.iName, 

                                   EFileShareReadersOnly | EFileStream ) );

    TInt error = file.Size( size );

    if ( error )

        {

        FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::ResolveGetRequestL() error %d in getting the size"), error ) );

        size = KBTSBPPFileSizeUnknown;

        }

    file.Close();

    // Store the file size if it was requested

    //

    if ( iRequestParams.iFileSize == KBTSBPPFileSizeRequested )

        {

        iRequestParams.iFileSize = size;

        }

    // Resolve the actual amount of data that needs to be read.

    // 

    TInt dataLeft = size - iRequestParams.iOffset;

    if ( iRequestParams.iCount == KBTSBPPRestOfTheFileRequested )

        {

        if ( size == KBTSBPPFileSizeUnknown )

            {

            // The size of the file is unknown, so read as much 

            // as would fit into the buffer

            //

            iRequestParams.iCount = KBTSUDataBufferMaxSize;

            }        

        else

            {

            // The rest of the file is requested, so correct the count

            //

            iRequestParams.iCount = dataLeft;

            }

        }

    else if ( iRequestParams.iCount > dataLeft )

        {

        // There is less data left that was requested, so correct the count

        //

        iRequestParams.iCount = dataLeft;

        }

    if ( iRequestParams.iCount > KBTSUDataBufferMaxSize )

        {

        // The requested count is too big

        //

        FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::ResolveGetRequestL() iCount too big %d"), iRequestParams.iCount ) );

        User::Leave( KErrTooBig );

        }

    FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::ResolveGetRequestL() completed, requested %d bytes"), iRequestParams.iCount ) );

    }

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

// CBTSBPPObjectRequest::ReadFileToBufferL

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

//

void CBTSBPPObjectRequest::ReadFileToBufferL()

    {

    __ASSERT_DEBUG( !iResponseBuffer, BTSUPanic( EBTSUPanicExistingObject ) );

    // Create a buffer for the object and reserve space according to the request

    //

    iResponseBuffer = CBufFlat::NewL( KBTSUDataBufferExpandSize );

    iResponseBuffer->SetReserveL( iRequestParams.iCount );

    iResponseBuffer->ResizeL( iRequestParams.iCount );

    // Open the file

    //

    RFile file;

    User::LeaveIfError( file.Open( iFileSession, *iRequestParams.iName, 

                                   EFileShareReadersOnly | EFileStream ) );

    CleanupClosePushL( file );

    // Create a stream for reading from the file

    //

    RFileReadStream readStream( file, iRequestParams.iOffset );

    // Create a stream for writing into the buffer

    //

    RBufWriteStream writeStream( *iResponseBuffer );

    // Read the data from file to the buffer

    //

    readStream.ReadL( writeStream, iRequestParams.iCount );

    FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::ReadFileToBufferL() space reserved '%d'"), iRequestParams.iCount ));

    FTRACE(FPrint(_L("[BTSBPP]\t CBTSBPPObjectRequest::ReadFileToBufferL() data read '%d'"), iResponseBuffer->Size() ));

    CleanupStack::PopAndDestroy(&file);

    }

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

// CBTSBPPObjectRequest::CreateResponseObjectL

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

//

void CBTSBPPObjectRequest::CreateResponseObjectL()

    {

    __ASSERT_DEBUG( iResponseBuffer || (iRequestParams.iCount == 0), BTSUPanic( EBTSUPanicNoBufferEvenThoughCountNotZero ) );

    __ASSERT_DEBUG( !iResponse, BTSUPanic( EBTSUPanicResponseAlreadyPresent ) );

    // Create the OBEX response object using the buffer already created (or no buffer if appropriate)

    //

    iResponse = CObexBufObject::NewL( iResponseBuffer );

    // Generate FileSize parameter if requested

    //

    if ( iRequestParams.iFileSize != KBTSBPPFileSizeNotSet )

        {

        FLOG(_L("[BTSBPP]\t CBTSBPPObjectRequest::CreateResponseObjectL() generate file size param"));

        TBuf8<KBTSBPPAppParamLength> params;

        params.SetMax();

        TUint8* ptr = const_cast<TUint8*>(params.Ptr());

        *ptr++ = KBTSBPPFileSizeTag;

        *ptr++ = KBTSBPPFileSizeLength;

        BigEndian::Put32(ptr, *reinterpret_cast<TUint32*>(&iRequestParams.iFileSize)); // reinterpret cast to retain signed nature...

        iResponse->SetAppParamL( params );

        }

    }

//  End of File