/*
* Copyright (c) 2003-2009 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:   Policy importer
*
*/



#include "policypatcher.h"
#include "vpnapidefs.h"


TAny* TPatchKeyArrayPtr::At(TInt aIndex) const
    {
    if (aIndex==KIndexPtr)
        {
        TAny* base = *(TUint8**)iPtr;
        CPolicyPatchInfo* info = (CPolicyPatchInfo*)base;
        return (TAny*)&(info->iPatchOffset);
        }
    else
        {
        TAny* base = *(TUint8**)iBase->Ptr(aIndex*sizeof(TUint8**)).Ptr();
        CPolicyPatchInfo* info = (CPolicyPatchInfo*)base;
        return (TAny*)&(info->iPatchOffset);
        }
    }


CPolicyPatcher* CPolicyPatcher::NewL()
    {
    CPolicyPatcher* self = new (ELeave) CPolicyPatcher();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

CPolicyPatcher::CPolicyPatcher()
    {
    }

CPolicyPatcher::~CPolicyPatcher()
    {
    }

void CPolicyPatcher::ConstructL()
    {
    }

/*
 * The policy file is patched as follows:
 * - CA certificate references are changed from filenames
 *   into CA subject names (correspondingly, the reference
 *   type is changed from BIN to NAME)
 * - User private key and certificate references are not
 *   removed although they are no longer in use
 */
HBufC8* CPolicyPatcher::PatchPolicyL(const TDesC8& aPolicyData,
                                     CPolicyPatchInfoList* aPatchInfoList)
    {
    iInput.Set(aPolicyData);
    iPatchInfoList = aPatchInfoList;

    FindOffsetsL();

    // Sort the resulting array to ascending order, using key
    // patchInfo->iPatchOffset
    TPatchKeyArrayPtr sortedCerts(_FOFF(CPatchData, iPatchOffset), ECmpTInt32);
    iPatchInfoList->Sort(sortedCerts);

    return CreateOutputL();
    }

void CPolicyPatcher::FindOffsetsL()
    {
    TInt formatValueOffset = KErrGeneral;

    for (TInt i = 0; i < iPatchInfoList->Count(); i++)
        {
        CPolicyPatchInfo* patchInfo = iPatchInfoList->At(i);

        TInt fileNameOffset = iInput.FindF(patchInfo->iCertFileName);

        if (fileNameOffset != KErrNotFound)
            {
            TPtrC8 precedingInput = iInput.Left(fileNameOffset);

            if (0 == patchInfo->UserCertKeyLen())
                {
                // CA cert
                formatValueOffset = precedingInput.LocateReverseF(KBinChar);
                }
            else
                {
                // User cert
                formatValueOffset = precedingInput.LocateReverseF(KFormatChar);
                }

            if (formatValueOffset != KErrNone)
                {
                patchInfo->iPatchOffset = formatValueOffset;
                }
            else
                {
                User::Leave(KVpnErrInvalidPolicyFile);
                }

            patchInfo->iReminderOffset = fileNameOffset + patchInfo->iCertFileName.Length();
            }
        }
    }

HBufC8* CPolicyPatcher::CreateOutputL()
    {
    TInt patchInfoCount = iPatchInfoList->Count();

    CPatchDataList* patchDataList = new (ELeave) CPatchDataList(2);
    CleanupStack::PushL(patchDataList);

    for (TInt i = 0; i < patchInfoCount; i++)
        {
        CPolicyPatchInfo* patchInfo = iPatchInfoList->At(i);

        if (patchInfo->iPatchOffset != KUndefinedOffset)
            {
            CPatchData* patchData = new (ELeave) CPatchData;
            CleanupStack::PushL(patchData);

            patchData->iPatchOffset = patchInfo->iPatchOffset;
            patchData->iReminderOffset = patchInfo->iReminderOffset;
            patchData->iData = CreatePatchDataL(patchInfo);

            patchDataList->AppendL(patchData);

            CleanupStack::Pop(); // patchData (now owned by the list)
            }
        }

    TInt outputLength = iInput.Length();
    TInt patchDataCount = patchDataList->Count();

    for (TInt j = 0; j < patchDataCount; j++)
        {
        outputLength += patchDataList->At(j)->iData->Length();
        }

    HBufC8* output = HBufC8::NewL(outputLength);
    TPtr8 ptrOutput = output->Des();

    if (patchDataCount == 0)
        {
        ptrOutput.Append(iInput);
        }
    else
        {
        // Append all patches and the input data before,
        // between and after them to the outout
        for (TInt k = 0; k < patchDataCount; k++)
            {
            TInt startOffset;

            // If this is the first patch...
            if (k == 0)
                {
                // ...there is no previous patch whose
                // reminder offset we could use
                startOffset = 0;
                }
            else
                {
                // There is a previous patch whose reminder offset we can use
                startOffset = patchDataList->At(k - 1)->iReminderOffset;
                }

            CPatchData* currPatchData = patchDataList->At(k);

            TInt endOffset = currPatchData->iPatchOffset;

            // Append to the output the input data between the previous
            // patch (or the beginning of input if this is the first patch)
            // and the current patch
            ptrOutput.Append(iInput.Mid(startOffset, endOffset - startOffset));

            // Append the current patch data to the output
            ptrOutput.Append(*(currPatchData->iData));

            // If this is the last patch...
            if (k == (patchDataCount -1))
                {
                if(EFalse != iUserCertPatched)
                    {
                    // The data after user cert patch is not needed.
                    // Append new line instead.
                    // In practise this removes the PRIVATE_KEY_FORMAT
                    // and PRIVATE_KEY_DATA lines.
                    ptrOutput.Append(KNewLine);
                    }
                else
                    {
                    // ...append to the output the input data between the
                    // last patch and the end of the input
                    ptrOutput.Append(iInput.Mid(currPatchData->iReminderOffset));
                    }
                }
            }
        }

    CleanupStack::PopAndDestroy(); // patchDataList

    return output;
    }

HBufC8* CPolicyPatcher::CreatePatchDataL(const CPolicyPatchInfo* aPatchInfo)
    {
    TInt patchDataLength = 0;

    TBuf8<20> keyBuf;

    const TDesC8& certSubjectName = aPatchInfo->CertSubjectName();

    if (0 == aPatchInfo->UserCertKeyLen())
        {
        // CA cert patch
        patchDataLength = KName().Length() + KNewLine().Length() +
                          KDataField().Length() + KSpace().Length() +
                          certSubjectName.Length();
        }
    else
        {
        // user cert patch
        keyBuf.Num(aPatchInfo->UserCertKeyLen());
        patchDataLength = KDNField().Length() + certSubjectName.Length() +
                          KNewLine().Length() + KKeyLenField().Length() +
                          keyBuf.Length();
        }

    HBufC8* patchData = HBufC8::NewL(patchDataLength);
    CleanupStack::PushL(patchData);

    TPtr8 ptrPatchData(patchData->Des());

    if (0 == aPatchInfo->UserCertKeyLen())
        {
        // CA cert patch
        ptrPatchData.Append(KName);
        ptrPatchData.Append(KNewLine);
        ptrPatchData.Append(KDataField);
        ptrPatchData.Append(KSpace);
        ptrPatchData.Append(certSubjectName);
        }
    else
        {
        // User cert patch
        ptrPatchData.Append(KKeyLenField);
        ptrPatchData.Append(keyBuf);
        ptrPatchData.Append(KNewLine);
        ptrPatchData.Append(KDNField);
        ptrPatchData.Append(certSubjectName);
        iUserCertPatched = ETrue;
        }

    CleanupStack::Pop(); // patchData

    return patchData;
    }


// CPolicyPatchInfo

CPolicyPatchInfo::CPolicyPatchInfo()
    {
    iCertFileName.SetLength(0);
    iPatchOffset = KUndefinedOffset;
    iReminderOffset = KUndefinedOffset;
    iUserCertKeyLen = 0;
    }

CPolicyPatchInfo::~CPolicyPatchInfo()
    {
    delete iCertSubjectName;
    }

const TDesC8& CPolicyPatchInfo::CertSubjectName() const
    {
    return *iCertSubjectName;
    }

void CPolicyPatchInfo::SetCertSubjectNameL(const TDesC8& aCertSubjectName)
    {
    delete iCertSubjectName;
    iCertSubjectName = NULL;
    HBufC8* certSubjectBuf = CheckSubjectNameSyntaxL(aCertSubjectName);  
    iCertSubjectName = certSubjectBuf;
    }

void CPolicyPatchInfo::SetUserCertKeyLen(TInt aKeyLen)
    {
    iUserCertKeyLen = aKeyLen;
    }

TInt CPolicyPatchInfo::UserCertKeyLen() const
    {
    return iUserCertKeyLen;
    }
    
HBufC8* CPolicyPatchInfo::CheckSubjectNameSyntaxL(const TDesC8& aSubj)
    {
    const TInt KMaxSubjectItems = 20;
    
    _LIT8(KEqualSign, "=");
    _LIT8(KCommaSign, ",");
    _LIT8(KReplacementChar, "\"");
    
    //counts positions for equal sign characters
    CArrayFixFlat<TInt>* equalSignArr=new (ELeave) CArrayFixFlat<TInt> (KMaxSubjectItems); 
    
    //counts positions for comma characters
    CArrayFixFlat<TInt>* commaSignArr=new (ELeave) CArrayFixFlat<TInt> (KMaxSubjectItems); 
    
    //counts positions for double quatiation characters
    CArrayFixFlat<TInt>* updateArr=new (ELeave) CArrayFixFlat<TInt> (KMaxSubjectItems);
    
    TInt subjLth=aSubj.Length();
    TInt equalArrItemCount=0;
    TInt commaArrItemCount=0;
    TInt updateArrCount=0;
    
    CleanupStack::PushL(equalSignArr);
    CleanupStack::PushL(commaSignArr);
    
    //register '=' and ',' character positions 
    for (TInt i=0; i<subjLth; i++)
        {
        if ( aSubj.Mid(i, 1)== KEqualSign )
            {
            equalSignArr->AppendL(i);
            equalArrItemCount++;
            }
        
        if ( aSubj.Mid(i, 1)== KCommaSign )
            {
            commaSignArr->AppendL(i);
            commaArrItemCount++;
            }
        }
    
    CleanupStack::PushL(updateArr);
    
    TInt i=0;
    TInt j=0;
    
    // At least one comma required. Otherwise there is no chance for extra commas
    if ( commaArrItemCount )
        {
        while ( i< equalArrItemCount )
            {
            
            //advance starting position for every iteration
            TInt eqSignStartIndex=i;
            
            TInt cmCount=0;
        
            //check wether there is more than one comma between two adjacent fields.
            while ( commaSignArr->At(j)< equalSignArr->At(eqSignStartIndex) )
                {
                cmCount++;
                
                j++;
                
                if ( j==commaArrItemCount )
                    break;
                }
            
            //at least one extra comma character found. Mark positions for mofifications.
            if (cmCount>1)
                {
                TInt equalPos=equalSignArr->At(eqSignStartIndex-1) + 1;
                updateArr->AppendL(equalPos);
                
                TInt commaPos=commaSignArr->At(j-1);
                updateArr->AppendL(commaPos);
                
                updateArrCount++;
                updateArrCount++;
                }
            i++;    
            }
        }
        
        //Checking also last attribute of Subject Name string
        if ( j<commaArrItemCount )
            {
            updateArr->AppendL(equalSignArr->At(equalArrItemCount-1) + 1);
            updateArr->AppendL(subjLth);
            
            updateArrCount++;
            updateArrCount++;
            }
       
       TBuf8<256> resultBuf;
       resultBuf.Copy(aSubj);
       
       i=0;       
       
       //update subjectname acoording to updateArr array.
       if ( updateArr->Count()>0 )
           {
           while (i<updateArrCount)
               {
               if ( resultBuf.Length()<256 )
                   resultBuf.Insert(updateArr->At(i) + i, KReplacementChar);
               else
                   User::Leave(KErrNotSupported);
               i++;
               }
           }
       
       CleanupStack::Pop(updateArr);
       CleanupStack::Pop(commaSignArr);
       CleanupStack::Pop(equalSignArr);
       
       delete equalSignArr;
       equalSignArr=NULL;
       
       delete commaSignArr;
       commaSignArr=NULL;
       
       delete updateArr;
       updateArr=NULL;
       
       HBufC8* resultHeap = resultBuf.AllocL();
       
       return resultHeap;
    }


// CPolicyPatchInfoList

CPolicyPatchInfoList::CPolicyPatchInfoList(TInt aGranularity)
    : CArrayPtrFlat<CPolicyPatchInfo>(aGranularity)
    {
    }

CPolicyPatchInfoList::~CPolicyPatchInfoList()
    {
    ResetAndDestroy();
    }


// CPatchData

CPatchData::~CPatchData()
    {
    delete iData;
    }


// CPatchDataList

CPatchDataList::CPatchDataList(TInt aGranularity)
    : CArrayPtrFlat<CPatchData>(aGranularity)
    {
    }

CPatchDataList::~CPatchDataList()
    {
    ResetAndDestroy();
    }


/***/