CHttpCacheStreamHandler::CHttpCacheStreamHandler()

    iActiveEntries = new( ELeave )CArrayPtrFlat<CHttpCacheEntry>( KHttpCacheActiveCount );

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

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

//

    if ( iActiveEntries )

TBool CHttpCacheStreamHandler::AttachL( CHttpCacheEntry& aCacheEntry )

    for ( TInt i = 0; i < iActiveEntries->Count(); i++ )

        __ASSERT_DEBUG( iActiveEntries->At( i ) != &aCacheEntry,

        User::Panic( _L("cacheStreamHandler Panic"), KErrCorrupt )  );

    TBool cacheFilesOpened( EFalse );

    if ( aCacheEntry.CacheFilesOpened() )

        // Cache files already opened, no need to reopen

        cacheFilesOpened = ETrue;

        }

    else if ( aCacheEntry.State() == CHttpCacheEntry::ECacheUninitialized )

        {

        // Create new cache files, they don't already exist

        cacheFilesOpened = CreateNewFilesL( aCacheEntry );

    else

        // Open existing cache files

        cacheFilesOpened = OpenCacheFiles( aCacheEntry );

    if ( cacheFilesOpened )

        // Add to our active array, if not already there

        TInt index( -1 );

        FindCacheEntryIndex( aCacheEntry, &index );

        if ( index == -1 )

            {

            iActiveEntries->AppendL( &aCacheEntry );

            }

    aCacheEntry.SetCacheFilesOpened( cacheFilesOpened );

    // Return ETrue, if files opened and attached

    return cacheFilesOpened;

void CHttpCacheStreamHandler::Detach( CHttpCacheEntry& aCacheEntry )

    // Close the files, this will commit changes

    if ( aCacheEntry.CacheFilesOpened() )

        {

        aCacheEntry.BodyFile().Close();

        aCacheEntry.HeaderFile().Close();

        aCacheEntry.SetCacheFilesOpened( EFalse );

        }

    // Delete from our active array

    TInt index( -1 );

    FindCacheEntryIndex( (const CHttpCacheEntry&)aCacheEntry, &index );

    if ( index >= 0 )

// CHttpCacheStreamHandler::EraseCacheFile

void CHttpCacheStreamHandler::EraseCacheFile( CHttpCacheEntry& aCacheEntry )

    HttpCacheUtil::WriteUrlToLog( 0, _L( "CHttpCacheStreamHandler::Erase - erase files associated with" ), aCacheEntry.Url() );

    aCacheEntry.HeaderFile().Close();

    aCacheEntry.BodyFile().Close();

    aCacheEntry.SetCacheFilesOpened( EFalse );

    // Get body filename

    TFileName bodyFileName = aCacheEntry.Filename();

    // Get header filename

    TFileName headerFileName;

    HttpCacheUtil::GetHeaderFileName( bodyFileName, headerFileName );

    TInt statusBody( KErrNotFound );

    statusBody = iRfs.Delete( bodyFileName );

    TInt statusHeader( KErrNotFound );

    statusHeader = iRfs.Delete( headerFileName );

    // Adjust the size

    iContentSize -= aCacheEntry.BodySize();

    iContentSize -= aCacheEntry.HeaderSize();

#ifdef __CACHELOG__

    if ( statusBody != KErrNone ) {

        HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                           _L("CCHttpCacheStreamEntry::Erase - ERROR bodyFile delete"),

                                           aCacheEntry.Filename(),

                                           aCacheEntry.Url(),

                                           statusBody,

                                           ELogFileErrorCode );

        }

    else {

        HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                           _L("CCHttpCacheStreamEntry::Erase - SUCCESS bodyFile delete"),

                                           aCacheEntry.Filename(),

                                           aCacheEntry.Url(),

                                           aCacheEntry.BodySize(),

                                           ELogEntrySize );

    if ( statusHeader != KErrNone ) {

        HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                           _L("CCHttpCacheStreamEntry::Erase - ERROR headerFile delete"),

                                           aCacheEntry.Filename(),

                                           aCacheEntry.Url(),

                                           statusHeader,

                                           ELogFileErrorCode );

        }

    else {

        HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                           _L("CCHttpCacheStreamEntry::Erase - SUCCESS headerFile delete"),

                                           aCacheEntry.Filename(),

                                           aCacheEntry.Url(),

                                           aCacheEntry.BodySize(),

                                           ELogEntrySize );

        }

#endif //__CACHELOG__

HBufC8* CHttpCacheStreamHandler::HeadersL( CHttpCacheEntry& aCacheEntry )

    TInt headerLen( 0 );

    TInt err( KErrNone );

    if ( !aCacheEntry.CacheFilesOpened() )

        OpenCacheFiles( aCacheEntry );

    err = aCacheEntry.HeaderFile().Size( headerLen );

    if ( err == KErrNone && headerLen > 0 )

        {

        headerStr = HBufC8::NewL( headerLen );

        TPtr8 ptr( headerStr->Des() );

        // read headers

        aCacheEntry.HeaderFile().Read( 0, ptr, headerLen );

        }

    // Read whole body

    TInt size( 0 );

    TInt sizeErr( KErrNone );

    if ( !aCacheEntry.CacheFilesOpened() )

        {

        OpenCacheFiles( aCacheEntry );

        }

    sizeErr = aCacheEntry.BodyFile().Size( size );

    if ( sizeErr == KErrNone && size > 0 )

        bodyStr = HBufC8::NewL( size );

        TPtr8 ptr( bodyStr->Des() );

        TInt readErr( KErrNone );

        readErr = aCacheEntry.BodyFile().Read( ptr, size );

#ifdef __CACHELOG__

        if ( readErr != KErrNone ) {

            HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                               _L("CCHttpCacheStreamEntry::NextChunkL - bodyFile.read"),

                                               aCacheEntry.Filename(),

                                               aCacheEntry.Url(),

                                               readErr,

                                               ELogFileErrorCode );

            }

        else {

            HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                               _L("CCHttpCacheStreamEntry::NextChunkL - bodyFile.read"),

                                               aCacheEntry.Filename(),

                                               aCacheEntry.Url(),

                                               ptr.Length(),

                                               ELogEntrySize );

            }

#endif  // __CACHELOG__

    aLastChunk = ETrue;

    TBool headerSaved( EFalse );

    if ( !aCacheEntry.CacheFilesOpened() )

        OpenCacheFiles( aCacheEntry );

        }

    if ( aHeaderStr.Length() && IsDiskSpaceAvailable( aHeaderStr.Length() ) )

        {

        // We have space on disk, save headers. Don't force a flush, as the

        // File Server takes care of write and read consistency.

        TInt writeErr = aCacheEntry.HeaderFile().Write( aHeaderStr );

        if ( writeErr == KErrNone )

            aCacheEntry.SetHeaderSize( aHeaderStr.Length() );

            iContentSize += aHeaderStr.Length();

            headerSaved = ETrue;

    return headerSaved;

void CHttpCacheStreamHandler::RemoveHeaders( CHttpCacheEntry& aCacheEntry )

    iContentSize -= aCacheEntry.HeaderSize();

    // Destroy data

    aCacheEntry.HeaderFile().SetSize( 0 );

    aCacheEntry.SetHeaderSize( 0 );

    TInt bodySaved( EFalse );

    TInt newBodyLength( aBodyStr.Length() );

    TPtr8 buffer( aCacheEntry.CacheBuffer() );

    if ( newBodyLength && buffer.MaxLength() )

        // Calculate if we have enough space in the buffer for incoming body

        if ( buffer.Length() + newBodyLength > buffer.MaxLength() )

            // Incoming data is too big for the buffer

            HBufC8* overflowBuffer = NULL;

            TInt bufferSpaceLeft( -1 );

            TPtrC8 writePtr;

            if ( buffer.Length() == 0 )

                {

                // Buffer is empty and the body is bigger than the buffer,

                // just take all of the incoming data

                writePtr.Set( aBodyStr );

                }

            else

                // We have some data in buffer, how much space do we have left

                bufferSpaceLeft = buffer.MaxLength() - buffer.Length();

                if ( newBodyLength - bufferSpaceLeft > buffer.MaxLength() )

                    {

                    // Not enough space, so lets put the buffer and the new

                    // body together and write it in one go.

                    overflowBuffer = HBufC8::New( buffer.Length() + newBodyLength );

                    if ( !overflowBuffer )

                        {

                        return EFalse;

                        }

                    TPtr8 overflowPtr( overflowBuffer->Des() );

                    overflowPtr.Copy( buffer );

                    overflowPtr.Append( aBodyStr );

                    writePtr.Set( overflowBuffer->Des() );

                    // empty buffer

                    buffer.Zero();

                    // no leftover left

                    bufferSpaceLeft = -1;

                    }

                else

                    {

                    // Copy what we have enough space for

                    buffer.Append( aBodyStr.Left( bufferSpaceLeft ) );

                    writePtr.Set( buffer );

                    }

            // Write to the disk, if we have disk space

            TInt writeErr( KErrNone );

            if ( IsDiskSpaceAvailable( writePtr.Length() ) )

                if ( !aCacheEntry.CacheFilesOpened() )

                    {

                    OpenCacheFiles( aCacheEntry );

                    }

                // We have enough disk space, save body

                TInt writeErr = aCacheEntry.BodyFile().Write( writePtr );

                bodySaved = ETrue;

                }

            else

                {

                // We don't have enough disk space, clean up 

                bodySaved = EFalse;

                buffer.Zero();

            if ( writeErr == KErrNone && bufferSpaceLeft >= 0 )

                {

                // Copy what we can of the leftover in to the buffer

                buffer.Copy( aBodyStr.Mid( bufferSpaceLeft ) );

                }

            delete overflowBuffer;

        else

            {

            // We have enough space in buffer, add and wait for next body

            // before writing to file

            buffer.Append( aBodyStr );

            bodySaved = ETrue;

            }

        // Body saved, update state

        aCacheEntry.SetBodySize( aCacheEntry.BodySize() + newBodyLength );

        iContentSize += aBodyStr.Length();

    return bodySaved;

void CHttpCacheStreamHandler::RemoveBodyData( CHttpCacheEntry& aCacheEntry )

#ifdef __CACHELOG__

     HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                           _L("CHttpCacheStreamHandler::RemoveBodyData - CLEAR iCacheBuffer, entrySize, and iBodyFile"),

                                           aCacheEntry.Filename(),

                                           aCacheEntry.Url(),

                                           aCacheEntry.BodySize(),

                                           ELogEntrySize );

#endif