/*
* 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 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: 
*  Decompression buffer manager for GZip data
*
*
*/

#include <EZStream.h>
#include "GZipBufMgr.h"
//-----------------------------------------------------------------------------

// NOTE: This code was taken from the DeflateFilter (s60/DeflateFilter/)

// ----------------------------------------------------------------------------
// StreamBufMgr::NewL
// Two-phase constructor
// ----------------------------------------------------------------------------
//
GZipBufMgr* GZipBufMgr::NewL(TPtrC8 in)
    {
    GZipBufMgr* self = new (ELeave)GZipBufMgr(in);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }//lint !e1746 const reference is not necessary here, because TPtrC8 takes only 4-bytes

// ----------------------------------------------------------------------------
// GZipBufMgr::GZipBufMgr
// Constructor
// ----------------------------------------------------------------------------
//
GZipBufMgr::GZipBufMgr(TPtrC8 in)
                    : iInput(in), iOutputDes(0, 0), iOutput(0),
                      iNeedInput(EFalse), iNeedOutput(EFalse), 
                      iFinalized(EFalse), iOffset(0), iID1(31), iID2(139)
    {
    } //lint !e1746

// ----------------------------------------------------------------------------
// GZipBufMgr::ConstructL
// Initialize the output buffer
// ----------------------------------------------------------------------------
//
void GZipBufMgr::ConstructL()
    {
    // Output buffer and descriptor
    iOutput = HBufC8::NewMaxL(1<<15);
    iOutputDes.Set(iOutput->Des());

    // Setup the GZip header, this sets iOffset to after the header and start
    // of the data
	TEZGZipHeader header;
    ReadGZipHeaderL(header);

    // Move pass the header and set the buffer to the data
	TPtrC8 data(REINTERPRET_CAST(const TUint8*, iInput.Ptr() + iOffset), iInput.Length() - iOffset);

    // Setup the data buffer
	SetGZipBuffer(data);

    }

// ----------------------------------------------------------------------------
// GZipBufMgr::~GZipBufMgr
// Destructor
// ----------------------------------------------------------------------------
//
GZipBufMgr::~GZipBufMgr()
    {
    delete iOutput;
    iOutput = NULL;
    }

// ----------------------------------------------------------------------------
// GZipBufMgr::InitializeL
// Overriden function from MEZBufferManager
// ----------------------------------------------------------------------------
//
void GZipBufMgr::InitializeL(CEZZStream& aZStream)
    {
    // read more
    aZStream.SetInput(iInput);
    iOutputDes.SetLength(0);
    aZStream.SetOutput(iOutputDes);
    iNeedInput = EFalse;
    iNeedOutput = EFalse;
    }

// ----------------------------------------------------------------------------
// GZipBufMgr::NeedInputL
// Overriden function from MEZBufferManager
// ----------------------------------------------------------------------------
//
void GZipBufMgr::NeedInputL(CEZZStream& /*aZStream*/)
    {
    //aZStream.SetInput(iInput);
    iNeedInput = ETrue;
    }

// ----------------------------------------------------------------------------
// GZipBufMgr::NeedOutputL
// Overriden function from MEZBufferManager
// ----------------------------------------------------------------------------
//
void GZipBufMgr::NeedOutputL(CEZZStream& /*aZStream*/)
    {
    //aZStream.SetOutput(iOutputDes);
    iNeedOutput = ETrue;
    }

// ----------------------------------------------------------------------------
// GZipBufMgr::NeedOutputL
// Overriden function from MEZBufferManager
// ----------------------------------------------------------------------------
//
void GZipBufMgr::FinalizeL(CEZZStream& /*aZStream*/)
    {
    // do nothing now, should check the checksum value here
    // read the checksum value from the last chunk
    //const TInt32* checksum = REINTERPRET_CAST(const TInt32*, iInput.Ptr() + (iInput.Length() - sizeof(TInt32)*2));
    iFinalized = ETrue;
    }


// ----------------------------------------------------------------------------
// Public methods
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
// GZipBufMgr::ReadGZipHeaderL
// Read the header of Gzip-ed stream in Gzip format, RFC1952.
// Sets the iOffset pointer, which marks the end of the header and start of the
// data.  This method needs to be called (or iOffset set) before calling
// SetGZipBuffer method.
// ----------------------------------------------------------------------------
//
void GZipBufMgr::ReadGZipHeaderL(TEZGZipHeader& aHeader)
    {
    // construct a stream for reading
    RMemReadStream memBuf;
    memBuf.Open(iInput.Ptr(), iInput.Length());
    
    TInt obligatoryData = sizeof(aHeader.iId1) + sizeof(aHeader.iId2) +
                          sizeof(aHeader.iCompressionMethod) +
                          sizeof(aHeader.iFlags) + sizeof(aHeader.iTime) +
                          sizeof(aHeader.iExtraFlags) + sizeof(aHeader.iOs);
    
    // copy the header data
    TPtr8 des(&aHeader.iId1, 0, obligatoryData);
    TRAPD(error, memBuf.ReadL(des));
    
    if (error == KErrEof)
        {
        User::Leave(EZGZipFile::EBadGZipHeader);
        }
    
    if (des.Size() < obligatoryData)
        {
        // TODO: should consider the situation when not enough data has arrived
        User::Leave(EZGZipFile::EBadGZipHeader);
        }
    
    if (aHeader.iId1 != iID1 || aHeader.iId2 != iID2)
        {
        User::Leave(EZGZipFile::EBadGZipHeader);
        }
    
    if (aHeader.iFlags & (1 << EZGZipFile::EFExtra))
        {
        // The extra bit is set
        des.Set(REINTERPRET_CAST(TUint8 *, &aHeader.iXlen), 0, sizeof(aHeader.iXlen));
        memBuf.ReadL(des);
        if (des.Size() != sizeof(aHeader.iXlen) || aHeader.iXlen < 0) //lint !e737 sign/unsigned doesn't realy matter here
            {
            User::Leave(EZGZipFile::EBadGZipHeader);
            }
        
        aHeader.iExtra = HBufC8::NewMaxL(aHeader.iXlen);
        TPtr8 des1 = aHeader.iExtra->Des();
        memBuf.ReadL(des1);
        
        if (des1.Size() != aHeader.iXlen)
            {
            User::Leave(EZGZipFile::EBadGZipHeader);
            }
        }
    
    if (aHeader.iFlags & (1 << EZGZipFile::EFName))
        {
        // Read in filename
        ReadStringIntoDescriptorL(memBuf, &aHeader.iFname);
        }
    
    if (aHeader.iFlags & (1 << EZGZipFile::EFComment))
        {
        // Read in comment
        ReadStringIntoDescriptorL(memBuf, &aHeader.iComment);
        }
    
    if (aHeader.iFlags & (1 << EZGZipFile::EFHcrc))
        {
        des.Set(REINTERPRET_CAST(TUint8*, &aHeader.iCrc), 0, sizeof(aHeader.iCrc));
        memBuf.ReadL(des);
        if (des.Size() != sizeof(aHeader.iCrc)) //lint !e737 unsigned/signed doesn't matter
            {
            User::Leave(EZGZipFile::EBadGZipHeader);
            }
        }
    
    // Set iOffset to mark end of header and beginning of data
    iOffset = memBuf.Source()->TellL(MStreamBuf::ERead).Offset();
    
    memBuf.Close();
    }

// ----------------------------------------------------------------------------
// GZipBufMgr::ReadStringIntoDescriptorL
// Read null-terminated strings into the buffer
// ----------------------------------------------------------------------------
//
void GZipBufMgr::ReadStringIntoDescriptorL(RMemReadStream& aMem, HBufC8 **aDes) const
    {
    TInt i;
    CArrayFixFlat<TUint8> *bytes = new (ELeave) CArrayFixFlat<TUint8>(16);
    CleanupStack::PushL(bytes);
    TUint8 ch;
    
    while ((ch = aMem.ReadUint8L()) != '\0')
        {
        bytes->AppendL(ch);
        }
    
    *aDes = HBufC8::NewMaxL(bytes->Count());
    TPtr8 desPtr = (*aDes)->Des(); //lint because error #111 - separate desPtr used
    
    for (i = 0; i < bytes->Count(); i++)
        {
        desPtr[i] = (*bytes)[i]; //lint !e1058 force conversion here
        }
    
    CleanupStack::PopAndDestroy(); // delete bytes	
    }

// ----------------------------------------------------------------------------
// GZipBufMgr::SetBuffer
// Set the input buffer
// ----------------------------------------------------------------------------
//
void GZipBufMgr::SetGZipBuffer(TPtrC8 data)
    {
    iInput.Set(data);
    }//lint !e1746