/** @file

* Copyright (c) 2005-2006 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:  Declares HttpServer class.

 *

*/

// INCLUDE FILES

#include "upnphttpsession.h"

#include "upnphttpfileaccess.h"

#include "upnpcommonupnplits.h"

#include "upnpfileutils.h"

#include "upnpcons.h"

#define KLogFile _L("DLNAWebServer.txt")

#include "upnpcustomlog.h"

#include <e32math.h>

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

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

// CUpnpHttpFileAccess::NewL

// Two-phased constructor

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

//

CUpnpHttpFileAccess* CUpnpHttpFileAccess::NewL( CUpnpHttpSession* aSession,

    const TDesC8& aHeaderBuffer, const TDesC16& aFilename, TInt aFileSize )

    {

    LOGSH( aHandle, "CUpnpHttpFileAccess::NewL" );

    CUpnpHttpFileAccess* self = new (ELeave) CUpnpHttpFileAccess(

            aFileSize );

    CleanupStack::PushL( self );

    self->ConstructL( aSession, aHeaderBuffer, aFilename );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpHttpFileAccess::NewL

// C++ default constructor, called when saving download

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

//

CUpnpHttpFileAccess* CUpnpHttpFileAccess::NewL( CUpnpHttpSession* aSession,

    const TDesC16& aFilename )

    {

    LOG_FUNC_NAME;

    CUpnpHttpFileAccess* self = new (ELeave) CUpnpHttpFileAccess();

    CleanupStack::PushL( self );

    self->ConstructL( aSession, aFilename );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpHttpFileAccess::~CUpnpHttpBuffer

// C++ default destructor

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

//

CUpnpHttpFileAccess::~CUpnpHttpFileAccess()

    {

    LOGS1( "%i, CUpnpHttpFileAccess::~CUpnpHttpFileAccess", this );

    if ( iIsDownload )

        {

        if ( !iIsDeleted )

            {

            iFile.Close( );

            if ( (iTotalSizeOfDownload - iBytesWritten )!= 0

                    || ( !iIsChunkCompleted && iIsChunked ) )

                iFsSession.Delete( *iFileToServe );

            }

        }

    if ( iOpen )

        {

        iTargetFile.Close( );

        }

    iFsSession.Close( );

    delete iHeaderBuffer;

    delete iFileToServe;

    delete iOpenedFile;

    }

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

// CUpnpHttpFileAccess::CUpnpHttpFileAccess

// C++ default constructor

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

//

CUpnpHttpFileAccess::CUpnpHttpFileAccess( TInt aFileSize )

    {

    LOGS1H( aHandle, "%i, CUpnpHttpFileAccess::CUpnpHttpFileAccess", this );

    SetPosOfFile( 0 );

    SetEndPosOfFile( KErrNotFound );

    SetPosOfHeader( 0 );

    iSizeOfFile = aFileSize;

    iHeadersSent = EFalse;

    iTotalSizeOfDownload = KErrNotFound;

    iIsDownload = EFalse;

    iIsDeleted = EFalse;

    }

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

// CUpnpHttpFileAccess::CUpnpHttpFileAccess

// C++ default constructor, called when saving download

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

//

CUpnpHttpFileAccess::CUpnpHttpFileAccess()

    {

    LOGS1H( aHandle, "%i, CUpnpHttpFileAccess::CUpnpHttpFileAccess", this );

    SetPosOfFile( 0 );

    SetEndPosOfFile( KErrNotFound );

    iHeadersSent = ETrue;

    iTotalSizeOfDownload = KErrNotFound;

    iSizeOfFile = KErrNotFound;

    iIsDownload = ETrue;

    iBytesWritten = 0;

    iIsDeleted = EFalse;

    }

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

// CUpnpHttpFileAccess::CUpnpHttpFileAccess

// Two-phased constructor, called when saving download

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

//

void CUpnpHttpFileAccess::ConstructL( CUpnpHttpSession* aSession,

    const TDesC16& aFilename )

    {

    LOGS1(

            "%i, CUpnpHttpFileAccess::ConstructL(CUpnpHttpSession*, TDesC16&)",

            this );

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

    iFileToServe = aFilename.AllocL(); 

    TInt error =  0; 

    iPosInFile = 0;

    iHeaderLength = 0;

    iSession = aSession;

    if (iSession->OverwriteExisting() && !iSession->SaveAtOffset())

        {

        error = iFile.Replace(iFsSession, *iFileToServe, EFileWrite

                | EFileShareAny);

        User::LeaveIfError(error);

        }

    else if (iSession->OverwriteExisting() && iSession->SaveAtOffset())

        {

        error = iFile.Open(iFsSession, *iFileToServe, EFileWrite

                | EFileShareAny);

        if (error != KErrNotFound)

            {

            TInt size = 0;

            error = iFile.Size(size);

            if (size >= (iSession->Offset()))

                {

                iPosInFile = iSession->Offset();

                }

            else

                {

                iFile.Close();

                error = iFile.Replace(iFsSession, *iFileToServe, EFileWrite

                        | EFileShareAny);

                User::LeaveIfError(error);

                }

            }

        else

            {

            error = iFile.Create(iFsSession, *iFileToServe, EFileWrite

                    | EFileShareAny);

            User::LeaveIfError(error);

            }

        }

    else

        {

        error = iFile.Open(iFsSession, *iFileToServe, EFileWrite

                | EFileShareAny);

        if (error == KErrNotFound)

            {

            error = iFile.Create(iFsSession, *iFileToServe, EFileWrite

                    | EFileShareAny);

            User::LeaveIfError(error);

            }

        }

    }

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

// CUpnpHttpFileAccess::ConstructL

// Two-phased constructor, called when serving file

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

//

void CUpnpHttpFileAccess::ConstructL( CUpnpHttpSession* aSession,

    const TDesC8& aHeaderBuffer, const TDesC16& aFilename )

    {

    LOGS1H(

        iHandle,

        "%i, CUpnpHttpFileAccess::ConstructL(CUpnpHttpSession*, TDesC8&, TDesC16&)",

        this );

    iHeaderBuffer = HBufC8::NewL( aHeaderBuffer.Length( ) );

    iHeaderBuffer->Des().Zero( );

    iHeaderBuffer->Des().Append( aHeaderBuffer );

    iFileToServe = HBufC16::NewL( aFilename.Length( ) );

    iFileToServe->Des().Zero( );

    iFileToServe->Des().Append( aFilename );

    iHeaderLength = aHeaderBuffer.Length( );

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

    iSession = aSession;

    iOpenedFile = KNullDesC().AllocL( );

    }

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

// CUpnpHttpFileAccess::SetPosOfFile

// 

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

//

void CUpnpHttpFileAccess::SetPosOfFile( TUint aNewPos )

    {

    iPosInFile = aNewPos;

    }

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

// CUpnpHttpFileAccess::PosOfFile

// 

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

//

TUint CUpnpHttpFileAccess::PosOfFile()

    {

    return iPosInFile;

    }

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

// CUpnpHttpFileAccess::SetPosOfFile

// 

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

//

void CUpnpHttpFileAccess::SetEndPosOfFile( TInt aNewEndPos )

    {

    iEndPosOfFile = aNewEndPos;

    }

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

// CUpnpHttpFileAccess::PosOfFile

// 

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

//

TInt CUpnpHttpFileAccess::EndPosOfFile()

    {

    return iEndPosOfFile;

    }

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

// CUpnpHttpFileAccess::GetHeaders

// 

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

//

const TDesC8& CUpnpHttpFileAccess::GetHeaders()

    {

    return (iHeaderBuffer) ? *iHeaderBuffer : KNullDesC8( );

    }

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

// CUpnpHttpFileAccess::SetPosOfHeader

// 

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

//	

void CUpnpHttpFileAccess::SetPosOfHeader( TUint aNewPos )

    {

    iPosToReadHeader = aNewPos;

    }

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

// CUpnpHttpFileAccess::SetTotalSize

// 

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

//

void CUpnpHttpFileAccess::SetTotalSize( TInt aSizeToSet )

    {

    iTotalSizeOfDownload = aSizeToSet;

    }

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

// CUpnpHttpFileAccess::SaveL

// 

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

//

TInt CUpnpHttpFileAccess::SaveL( TDesC8& aBuffer )

    {

    LOGS1( "%i, CUpnpHttpFileAccess::SaveL()", this );

    if ( iIsDeleted )

        {

        LOGS( "file closed" );

        return KErrGeneral;

        }

    LOGS( "file not closed" );

    TInt toWrite = (EncodingMode( )|| (TransferTotal( ) == KErrNotFound ) )

        ? aBuffer.Length( ) : (TransferTotal( )- iBytesWritten);

    if ( aBuffer.Size( ) < toWrite )

        {

        toWrite = aBuffer.Size( );

        }

    if ( UpnpFileUtil::CheckDiskSpaceShortL( iFileToServe->Des( ), toWrite,

        iFsSession ) )

        {

        DeleteFile( );

        return EHttpInsufficientStorage;

        }

    TInt error = KErrNone;

    // At first time iPosInFile == 0 or range offset, see ConstructL, and the next time 

    // saving will continue at stopped point. 	

    error = iFile.Write( iPosInFile, aBuffer.Right( toWrite ) );

    if ( error != KErrNone )

        {

        return error;

        }

    iPosInFile += toWrite;

    iBytesWritten += toWrite;

    return KErrNone;

    }

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

// CUpnpHttpFileAccess::TransferredBytes

// 

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

//

TInt CUpnpHttpFileAccess::TransferredBytes()

    {

    LOGS1( "%i, CUpnpHttpFileAccess::TransferredBytes()", this);

    TInt sent = 0;

    if ( !iHeadersSent )

        {

        sent = iPosToReadHeader;

        }

    else

        {

        sent = PosOfFile();

        }

    return sent;

    }

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

// CUpnpHttpFileAccess::TransferTotal

// 

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

//

TInt CUpnpHttpFileAccess::TransferTotal()

    {

    LOGS1( "%i, CUpnpHttpFileAccess::TransferTotal()", this);

    if ( iTotalSizeOfDownload == KErrNotFound )

        {

        return iSizeOfFile;

        }

    else

        {

        return iTotalSizeOfDownload;

        }

    }

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

// CUpnpHttpFileAccess::FileToServe

// 

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

//

TDesC16& CUpnpHttpFileAccess::FileToServe()

    {

    return *iFileToServe;

    }

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

// CUpnpHttpFileAccess::GetL

// 

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

//

TBool CUpnpHttpFileAccess::GetL( TPtr8& aPointer, TInt aBytesToSend )

    {

    LOGS1H( aHandle, "%i, CUpnpHttpFileAccess::GetL", this );

    if ( iFileToServe->Compare( *iOpenedFile ) ) // ignore if the same file

        {

        if ( iOpen )

            {

            iTargetFile.Close( );

            }

        iOpen = EFalse;

        }

    if ( !iOpen )

        {

        User::LeaveIfError( iTargetFile.Open( iFsSession, *iFileToServe,

            EFileRead|EFileShareReadersOnly ) );

        HBufC* tmp = iFileToServe->AllocL( );

        delete iOpenedFile;

        iOpenedFile = tmp;

        iOpen = ETrue;

        }

    User::LeaveIfError( iTargetFile.Seek( ESeekStart, iPosInFile ) );

    TInt BytesToRead = aBytesToSend;

    // Get min value from iEndPosInFile and buffer length 

    // iEndPosInFile + - iPosInFile 1 because indicated byte should also be included

    if ( EndPosOfFile( ) != KErrNotFound )

        BytesToRead = (EndPosOfFile( ) - iPosInFile + 1) < BytesToRead

            ? (EndPosOfFile( ) - iPosInFile + 1) : BytesToRead;

    LOGS1( "BytesToRead: %d", BytesToRead );

    User::LeaveIfError( iTargetFile.Read( aPointer, BytesToRead ) );

    iPosInFile = iPosInFile + aPointer.Length( );

    return IsEndOfFile();

    }

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

//CUpnpHttpFileAccess::DeleteServedFile

// 

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

//

void CUpnpHttpFileAccess::DeleteFile()

    {

    LOGS1( "%i, CUpnpHttpFileAccess::DeleteFile()", this );

    if ( !iIsDeleted )

        {

        iFile.Close( );

        iFsSession.Delete( *iFileToServe );

        iIsDeleted = ETrue;

        }

    }

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

// CUpnpHttpFileAccess::Download

// 

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

//

TBool CUpnpHttpFileAccess::Download()

    {

    return iIsDownload;

    }

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

// CUpnpHttpFileAccess::FileExist

// 

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

//

TBool CUpnpHttpFileAccess::FileExist()

    {

    return !iIsDeleted;

    }

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

// CUpnpHttpFileAccess::BytesWritten

// 

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

//

TBool CUpnpHttpFileAccess::BytesWritten()

    {

    return (iIsDownload ? iBytesWritten : 0);   

    }

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

// CUpnpHttpFileAccess::SetEncodingMode(TBool aIsChunked)

// 

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

//

void CUpnpHttpFileAccess::SetEncodingMode( TBool aIsChunked )

    {

    iIsChunked = aIsChunked;

    }

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

// CUpnpHttpFileAccess::EncodingMode()

// 

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

//

TBool CUpnpHttpFileAccess::EncodingMode()

    {

    return iIsChunked;

    }

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

// CUpnpHttpFileAccess::SetTransferTotal(aLength)

// 

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

//

void CUpnpHttpFileAccess::SetTransferTotal( TInt aLength )

    {

    iTotalSizeOfDownload = aLength;

    }

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

// CUpnpHttpFileAccess::HeadersSent

// 

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

//

void CUpnpHttpFileAccess::SetHeadersSent()

    {

    delete iHeaderBuffer;

    iHeaderBuffer = NULL;

    iPosToReadHeader = NULL;

    iHeadersSent = ETrue;

    }

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

// CUpnpHttpFileAccess::HeadersSent()

// 

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

//