/*
* Copyright (c) 2002-2007 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:          
*
*/












#include "senchunk.h"
#include "sendebug.h" // internal Utils\inc - filelogging MACROs
#include "senlogger.h"

const TInt KSenChunkFourByteAlignment = 4;

EXPORT_C CSenChunk* CSenChunk::NewL(const TDesC& aChunkName)
    {
    CSenChunk* pOperation = NewLC(aChunkName);
    CleanupStack::Pop();
    return pOperation;
    }

EXPORT_C CSenChunk* CSenChunk::NewLC(const TDesC& aChunkName)
    {
    CSenChunk* pOperation = new (ELeave) CSenChunk;
    CleanupStack::PushL(pOperation);
    pOperation->ConstructL(aChunkName);
    return pOperation;
    }

void CSenChunk::ConstructL(const TDesC& aChunkName)
    {
    if (aChunkName.Length() > 0)
        {
        ipChunkName = aChunkName.AllocL();
        }
    else
        {
        ipChunkName = NULL;
        }
    }

EXPORT_C CSenChunk::CSenChunk() :
    ipChunkName(NULL)
    {
    }

EXPORT_C CSenChunk::~CSenChunk()
    {
    CloseChunk();
    delete ipChunkName;
    }

EXPORT_C RChunk& CSenChunk::Chunk()
    {
    return iChunk;
    }

EXPORT_C TPtrC CSenChunk::ChunkName() const
    {
    if(ipChunkName)
        {
        return *ipChunkName;
        }
    else
        {
        return KNullDesC();
        }
    }

EXPORT_C TBool CSenChunk::operator==(const CSenChunk& a)
    {
    return (this==&a);
    }

EXPORT_C TInt CSenChunk::CreateChunk()
    {
    TInt retVal(KErrNone);
#ifdef EKA2
    // Create protected global chunk in EKA2
    // (Global chunk will be protected chunk when chunk name length is zero)
    retVal = iChunk.CreateGlobal(KNullDesC, KSenMinRChunkSize, KSenMaxRChunkSize);
#else // EKA1
    // Create named global chunk in EKA1
    retVal = iChunk.CreateGlobal(*ipChunkName, KSenMinRChunkSize, KSenMaxRChunkSize);
#ifdef _SENDEBUG
        TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- RChunk.CreateGlobal('%S', %d, %d) returned: %d"),
                ipChunkName,
                KSenMinRChunkSize,
                KSenMinRChunkSize,
                retVal));
#endif // _SENDEBUG
#endif // EKA2/EKA1
    if (retVal == KErrNone)
        {
        TUint8* heapPtr = iChunk.Base();
        // Create header in the beginning of the chunk
        TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("CSenChunk::CreateChunk KHeaderOffset size: (%d)"), KHeaderOffset));        
        new (heapPtr+KHeaderOffset) TChunkHeader;
        TChunkHeader& header = ChunkHeader();
        header.SetDescriptorCount(0);
        header.SetMessageType(MSenMessage::EMessageBase);
        header.SetMessageDirection(MSenMessage::EOutbound);
        header.SetPropertiesType(MSenProperties::ENotInUse);
        header.SetDoInitBeforeSending(EFalse);
        header.SetTransactionId(0);
        header.SetPendingTransactionId(0);
        }
    return retVal;
    }
    
EXPORT_C TInt CSenChunk::OpenChunk()
    {
    TInt retVal(KErrNone);
#ifdef EKA2
    retVal = KErrNotSupported;
#else // EKA1
    // Open named global chunk in EKA1
    retVal = iChunk.OpenGlobal(*ipChunkName, EFalse); 
#ifdef _SENDEBUG
        TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- RChunk.OpenGlobal() returned %d"), retVal));
#endif // _SENDEBUG
#endif // EKA2/EKA1
    return retVal;
    }
    
EXPORT_C TInt CSenChunk::OpenChunkFromRMsgL(const RMessage2& aMessage, TInt aIndex)
    {
    TInt retVal(KErrNone);
#ifdef EKA2 // // EKA2
    retVal = iChunk.Open(aMessage, aIndex, EOwnerProcess);
#else // EKA1
    HBufC* pChunkName = HBufC::NewLC(KMaxName);
    TPtr chunkname = pChunkName->Des();
    TInt leaveCode(KErrNone);
    TRAP(leaveCode, retVal = aMessage.Read(aIndex, chunkname); )

    if(retVal==KErrNone && leaveCode != KErrNone)
        {
#ifdef _SENDEBUG
            TLSLOG_FORMAT((KSenUtilsLogChannel, KMinLogLevel, _L8("- aMessage.Read(aIndex, chunkname) leaved: %d"), leaveCode ));
#endif // _SENDEBUG
        retVal = leaveCode;
        }
        
    ipChunkName = chunkname.AllocL();
    CleanupStack::PopAndDestroy(pChunkName);

#ifdef _SENDEBUG
    if (ipChunkName->Length() > 0 )
        {
        TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- RChunk name from RMessage2: '%S'"), ipChunkName ));
        }
#endif // _SENDEBUG

    if(retVal==KErrNone)
        {
        retVal = iChunk.OpenGlobal(*ipChunkName, EFalse); 
#ifdef _SENDEBUG
             TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- RChunk.OpenGlobal() returned %d"), retVal));
#endif // _SENDEBUG
        }    
#endif // EKA2/EKA1
    return retVal;
    }

EXPORT_C TInt CSenChunk::OpenChunkFromHandleNumberL(TInt aHandleOrError)
    {
    TInt retVal(KErrNone);
#ifdef EKA2 // // EKA2
    retVal = iChunk.SetReturnedHandle(aHandleOrError);
#else // EKA1
    iChunk.SetHandle(aHandleOrError);
#endif // EKA2/EKA1
    return retVal;
    }
    
EXPORT_C void CSenChunk::CloseChunk()
    {
#ifdef _SENDEBUG
        TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("CSenChunk::CloseChunk - handle: %d"), iChunk.Handle()));
#endif // _SENDEBUG

    THandleInfo chunkInfo;
    iChunk.HandleInfo(&chunkInfo);
#ifdef _SENDEBUG
        TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- Before Close(): TChunkInfo: numOpenInThread: %d, numOpenInProcess: %d, numProcesses: %d"),
            chunkInfo.iNumOpenInThread,
            chunkInfo.iNumOpenInProcess,
            chunkInfo.iNumProcesses));
#endif // _SENDEBUG

    iChunk.Close();
    }
    
EXPORT_C TInt CSenChunk::AdjustChunk(TInt aNewSize)
    {
    // Ensure that at least 10064 bytes are allocated:
    if(aNewSize<KSenMinRChunkSize)
        {
        aNewSize = KSenMinRChunkSize;
        }
    TInt retVal = iChunk.Adjust(aNewSize);
    TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("CSenChunk::AdjustChunk returns: (%d)"), retVal));
    return retVal;
    }

EXPORT_C TChunkHeader& CSenChunk::ChunkHeader()
    {
    return *reinterpret_cast<TChunkHeader*>(iChunk.Base()+KHeaderOffset);
    }

EXPORT_C TInt CSenChunk::DescToChunk(const TDesC8& aDescriptor)
    {
    TInt retVal(KErrNone);

    TInt size(aDescriptor.Length()+sizeof(TPtr8)+KSenChunkFourByteAlignment+KDataOffset);

    retVal = AdjustChunk(size);

    if(retVal == KErrNone)
        {
        TUint8* heapPtr = iChunk.Base();
        TChunkHeader& header = ChunkHeader();
        header.SetDescriptorCount(1);
        heapPtr += KDataOffset;
        heapPtr = RoundToNextDividableByFourAddress(heapPtr);
        // Place a new descriptor in the chunk to initialize it
        new (heapPtr) TPtr8(heapPtr + sizeof(TPtr8), 0, aDescriptor.Length());
        // Set the descriptor
        TPtr8* pDes = reinterpret_cast<TPtr8*>(heapPtr);
        pDes->Zero();
        pDes->Append(aDescriptor);
        }
    return retVal;
    }
EXPORT_C TInt CSenChunk::DescToChunk(const TDesC8& aDescriptor, TInt aIndex)
    {
#ifdef _SENDEBUG
        TLSLOG_L(KSenUtilsLogChannel,KMinLogLevel ,"CSenChunk::DescFromChunk");
#endif // _SENDEBUG
    TInt retVal(KErrNone);
    
    if ( iChunk.Handle() > KErrNone )
        {
        TInt maxPtr = iChunk.Size();

        TInt size(aDescriptor.Length()+sizeof(TPtr8)+(aIndex+1)*KSenChunkFourByteAlignment);
        retVal = AdjustChunk(maxPtr+size);
        
        TChunkHeader& header = *reinterpret_cast<TChunkHeader*>(iChunk.Base() + KHeaderOffset);
        
        if ( aIndex <= header.DescriptorCount() )
            {
            header.SetDescriptorCount(aIndex+1);
            
            TUint8* heapPtr = iChunk.Base();
            heapPtr += KDataOffset;
            heapPtr = RoundToNextDividableByFourAddress(heapPtr);
            TPtr8* pDesc;
            pDesc = reinterpret_cast<TPtr8*>(heapPtr);
            for (TInt i=1; i < aIndex; i++)
                {
                heapPtr += (sizeof(TPtr8) + pDesc->MaxLength());
                heapPtr = RoundToNextDividableByFourAddress(heapPtr);
                pDesc = reinterpret_cast<TPtr8*>(heapPtr);
                }
            heapPtr += (sizeof(TPtr8) + pDesc->MaxLength());
            heapPtr = RoundToNextDividableByFourAddress(heapPtr);
            
            // Place a new descriptor in the chunk to initialize it
            new (heapPtr) TPtr8(heapPtr + sizeof(TPtr8), 0, aDescriptor.Length());
            // Set the descriptor
            pDesc = reinterpret_cast<TPtr8*>(heapPtr);
            pDesc->Zero();
            pDesc->Append(aDescriptor);
            }
        else
            {
            retVal = KErrNotFound;
            }
        }
    else
        {
        retVal = KErrBadHandle;
#ifdef _SENDEBUG
            TLSLOG_FORMAT((KSenUtilsLogChannel, KMinLogLevel, _L8("CSenChunk::DescFromChunk(chunk), RChunk.Handle(): %d is an error!"),
                iChunk.Handle()));
#endif // _SENDEBUG
        }
        
    return retVal;
    }
    
EXPORT_C TInt CSenChunk::AllocDescToChunk(TInt size, TPtr8*& apAllocated)
    {
    TInt retVal(KErrNone);
    
    retVal = AdjustChunk(size+KSenChunkFourByteAlignment);
    
    if(retVal == KErrNone)
        {
        TUint8* heapPtr = iChunk.Base();
        TChunkHeader& header = ChunkHeader();
        header.SetDescriptorCount(1);
        heapPtr += KDataOffset;
        heapPtr = RoundToNextDividableByFourAddress(heapPtr);
        // Place a new descriptor in the chunk to initialize it
        new (heapPtr) TPtr8(heapPtr + sizeof(TPtr8), 0, size);
        // Set the descriptor
        apAllocated = reinterpret_cast<TPtr8*>(heapPtr);
        apAllocated->Zero();
        }
    return retVal;    
    }

EXPORT_C TInt CSenChunk::DescsToChunk(const TDesC8& aDescriptor1,
                                   const TDesC8& aDescriptor2)
    {
TInt retVal(KErrNone);

    TInt size(KDataOffset+aDescriptor1.Length()+aDescriptor2.Length()+\
              2*sizeof(TPtr8)+2*KSenChunkFourByteAlignment); 

    retVal = AdjustChunk(size);

    if(retVal == KErrNone)
        {
        TUint8* heapPtr = iChunk.Base();
        TChunkHeader& header = ChunkHeader();
        header.SetDescriptorCount(2);
        heapPtr += KDataOffset;
        heapPtr = RoundToNextDividableByFourAddress(heapPtr);
        // Place a new descriptor in the chunk to initialize it
        new (heapPtr) TPtr8(heapPtr + sizeof(TPtr8), 0, aDescriptor1.Length());
        // Set the descriptor
        TPtr8* pDes = reinterpret_cast<TPtr8*>(heapPtr);
        pDes->Zero();
        pDes->Append(aDescriptor1);

        heapPtr = heapPtr + sizeof(TPtr8) + aDescriptor1.Length();
        heapPtr = RoundToNextDividableByFourAddress(heapPtr);
        // Place a new descriptor in the chunk to initialize it
        new (heapPtr) TPtr8(heapPtr + sizeof(TPtr8), 0, aDescriptor2.Length());
        // Set the descriptor
        pDes = reinterpret_cast<TPtr8*>(heapPtr);
        pDes->Zero();
        pDes->Append(aDescriptor2);
        }
    return retVal;

    }

EXPORT_C TInt CSenChunk::DescFromChunk(TPtrC8& aDesc, TInt aIndex)
    {
#ifdef _SENDEBUG
        TLSLOG_L(KSenUtilsLogChannel,KMinLogLevel ,"CSenChunk::DescFromChunk");
#endif // _SENDEBUG
    TInt retVal(KErrNone);
    
    if(iChunk.Handle()>KErrNone)
        {
        TChunkHeader& header = *reinterpret_cast<TChunkHeader*>(iChunk.Base() + KHeaderOffset);
        
        if (aIndex < header.DescriptorCount() && aIndex >= 0)
            {
            TUint8* heapPtr = iChunk.Base();
            heapPtr += KDataOffset;
            heapPtr = RoundToNextDividableByFourAddress(heapPtr);
            TPtr8* pDesc;
            pDesc = reinterpret_cast<TPtr8*>(heapPtr);
            for (TInt i=1; i <= aIndex; i++)
                {
                heapPtr += (sizeof(TPtr8) + pDesc->MaxLength());
                heapPtr = RoundToNextDividableByFourAddress(heapPtr);
                pDesc = reinterpret_cast<TPtr8*>(heapPtr);
                }
            const TInt length = pDesc->Length();
            const TInt maxLength = pDesc->MaxLength();
            pDesc->Set(heapPtr + sizeof(TPtr8), length, maxLength);
            aDesc.Set(*pDesc);
            }
        else
            {
            retVal = KErrNotFound;
            }
        }
    else
        {
        retVal = KErrBadHandle;
#ifdef _SENDEBUG
            TLSLOG_FORMAT((KSenUtilsLogChannel, KMinLogLevel, _L8("CSenChunk::DescFromChunk(chunk), RChunk.Handle(): %d is an error!"),
                iChunk.Handle()));
#endif // _SENDEBUG
        }

    return retVal;
    }
    
EXPORT_C TInt CSenChunk::DescsFromChunk(TPtrC8& aDesc1, TPtrC8& aDesc2)
    {
    TInt retVal;
    retVal = DescFromChunk(aDesc1,0);
    if (retVal == KErrNone)
        {
        retVal = DescFromChunk(aDesc2,1);
        }
    return retVal;
    }

EXPORT_C void CSenChunk::ChunkToArgs(TIpcArgs& aArgs, TInt aIndex)
    {
#ifdef EKA2
    aArgs.Set(aIndex, iChunk); // EKA2
#else
    aArgs.Set(aIndex, ipChunkName); // EKA1
#endif
    }

EXPORT_C void CSenChunk::SetLogger(RFileLogger* aLog)
    {
    iLog = aLog;
    }

EXPORT_C RFileLogger* CSenChunk::Log() const
    {
    return iLog;
    }
    
TUint8* CSenChunk::RoundToNextDividableByFourAddress(TUint8* aValue)
    {
    TInt modulo = ((TUint)aValue)%KSenChunkFourByteAlignment;
    if ( modulo == 0 ) 
        {
        return aValue;
        }
    else
        {
        return aValue+(KSenChunkFourByteAlignment-modulo);        
        }
    }
    
EXPORT_C RFile& CSenChunk::RequestFileHandle()
	{
	return iFile;
	}
	
EXPORT_C void CSenChunk::RequestFileHandle(RFile& aFile)
	{
	iFile = aFile;
	}
    

    
// End of File