diff -r 000000000000 -r 33413c0669b9 vpnengine/dmadengine/src/dmadutil.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/dmadengine/src/dmadutil.cpp	Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,502 @@
+/*
+* Copyright (c) 2002-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: Implementation of TDmAdUtil.
+*
+*/
+
+
+
+#include <utf.h>
+#include "dmadutil.h"
+#include "vpnlogger.h"
+
+//-----------------------------------------------------------------------   
+
+DMAD_EXPORT_C TInt TDmAdUtil::DesToInt(const TDesC& aDes)
+    {
+    if (aDes.Length() == 0)
+        {
+        return 0;
+        }
+    TLex16 lex(aDes);
+    TInt value = 0;
+    if (lex.Val(value) != KErrNone)
+        {
+        ;
+        }
+    return value;
+    }
+
+DMAD_EXPORT_C TInt TDmAdUtil::DesToInt(const TDesC8& aDes)
+    {
+    if (aDes.Length() == 0)
+        {
+        return 0;
+        }
+    TLex8 lex(aDes);
+    TInt value = 0;
+    if (lex.Val(value) != KErrNone)
+        {
+        ;
+        }
+    return value;
+    }
+
+DMAD_EXPORT_C HBufC* TDmAdUtil::IntToDesLC(const TInt aInt)
+    {
+    HBufC* buf = HBufC::NewLC(10); //10 = max length of 32bit integer
+    TPtr ptrBuf = buf->Des();
+    ptrBuf.Num(aInt);
+    return buf;
+    }
+
+DMAD_EXPORT_C HBufC8* TDmAdUtil::IntToDes8LC(const TInt aInt)
+    {
+    HBufC8* buf = HBufC8::NewLC(10); //10 = max length of 32bit integer
+    TPtr8 ptrBuf = buf->Des();
+    ptrBuf.Num(aInt);
+    return buf;
+    }
+
+DMAD_EXPORT_C HBufC* TDmAdUtil::IntToDesLC(const TInt32 aInt32)
+    {
+    return IntToDesLC((TInt)aInt32);
+    }
+    
+DMAD_EXPORT_C HBufC8* TDmAdUtil::IntToDes8LC(const TInt32 aInt32)
+    {
+    return IntToDes8LC((TInt)aInt32);
+    }
+    
+//-----------------------------------------------------------------------
+    
+DMAD_EXPORT_C TUint TDmAdUtil::DesToUint(const TDesC& aDes)
+    {
+    if (aDes.Length() == 0)
+        {
+        return 0;
+        }
+    TLex16 lex(aDes);
+    TUint value = 0;
+    if (lex.Val(value) != KErrNone)
+        {
+        ;
+        }
+    return value;
+    }
+
+DMAD_EXPORT_C TUint TDmAdUtil::DesToUint(const TDesC8& aDes)
+    {
+    if (aDes.Length() == 0)
+        {
+        return 0;
+        }
+    TLex8 lex(aDes);
+    TUint value = 0;
+    if (lex.Val(value) != KErrNone)
+        {
+        ;
+        }
+    return value;
+    }
+
+DMAD_EXPORT_C HBufC* TDmAdUtil::IntToDesLC(const TUint aUint)
+    {
+    HBufC* buf = HBufC::NewLC(10); //10 = max length of 32bit integer
+    TPtr ptrBuf = buf->Des();
+    ptrBuf.Num(aUint);
+    return buf;
+    }
+
+DMAD_EXPORT_C HBufC8* TDmAdUtil::IntToDes8LC(const TUint aUint)
+    {
+    HBufC8* buf = HBufC8::NewLC(10); //10 = max length of 32bit integer
+    TPtr8 ptrBuf = buf->Des();
+    ptrBuf.Num(aUint);
+    return buf;
+    }
+    
+DMAD_EXPORT_C HBufC* TDmAdUtil::IntToDesLC(const TUint32 aUint32)
+    {
+    return IntToDesLC((TUint)aUint32);
+    }
+
+DMAD_EXPORT_C HBufC8* TDmAdUtil::IntToDes8LC(const TUint32 aUint32)
+    {
+    return IntToDes8LC((TUint)aUint32);
+    }
+    
+//-----------------------------------------------------------------------   
+    
+DMAD_EXPORT_C TPtrC8 TDmAdUtil::LastUriSeg(const TDesC8& aUri)
+    {
+    TInt i;
+    for (i=aUri.Length()-1; i>=0; i--)
+        {
+        if (aUri[i] == '/')
+            {
+            break;
+            }
+        }
+    if (i==0)
+        {
+        return aUri;
+        }
+    else
+        {
+        return aUri.Mid(i+1);
+        }
+    }
+
+DMAD_EXPORT_C TPtrC8 TDmAdUtil::FirstUriSeg(const TDesC8& aUri)
+    {
+    TInt i;
+    TBool found = EFalse;
+    for (i=0; i<aUri.Length(); i++)
+        {
+        if (aUri[i] == '/')
+            {
+            found = ETrue;
+            break;
+            }
+        }
+    if (found)
+        {
+        return aUri.Left(i);
+        }
+    else
+        {
+        return aUri;
+        }
+    }
+
+DMAD_EXPORT_C TPtrC8 TDmAdUtil::RemoveLastUriSeg(const TDesC8& aUri)
+    {
+    TInt i;
+    for (i=aUri.Length()-1; i>=0; i--)
+        {
+        if (aUri[i] == '/')
+            {
+            break;
+            }
+        }
+    return aUri.Left(i);
+    }
+
+DMAD_EXPORT_C TInt TDmAdUtil::NumOfURISegs(const TDesC8& aUri)
+    {
+    TPtrC8 uri(TDmAdUtil::RemoveDotSlash(aUri));
+    TInt numOfURISegs = 1;
+    for (TInt i=0; i<uri.Length(); i++)
+        {
+        if (uri[i] == '/')
+            {
+            numOfURISegs++;
+            }
+        }
+    return numOfURISegs;
+    }
+
+DMAD_EXPORT_C TPtrC8 TDmAdUtil::RemoveDotSlash(const TDesC8& aUri)
+    {
+    if (aUri.Find(KDmAdUriDotSlash) == 0)
+        {
+        return aUri.Right(aUri.Length() - KDmAdUriDotSlash().Length());
+        }
+    else
+        {
+        return aUri;
+        }
+    }
+
+DMAD_EXPORT_C TInt TDmAdUtil::CompareUris(const TDesC8& aUri1, const TDesC8& aUri2)
+    {
+    TPtrC8 uri1(TDmAdUtil::RemoveDotSlash(aUri1));
+    TPtrC8 uri2(TDmAdUtil::RemoveDotSlash(aUri2));
+    return uri1.Compare(uri2);
+    }
+
+DMAD_EXPORT_C HBufC8* TDmAdUtil::BuildUriLC(const TDesC8& aUriPath, const TDesC8& aUriSeg)
+    {
+    HBufC8* uri = BuildUriL(aUriPath, aUriSeg);
+    CleanupStack::PushL(uri);
+    return uri;
+    }
+    
+DMAD_EXPORT_C HBufC8* TDmAdUtil::BuildUriL(const TDesC8& aUriPath, const TDesC8& aUriSeg)
+    {
+    HBufC8* uri = HBufC8::NewL(aUriPath.Length() + 1 + aUriSeg.Length());
+    TPtr8 uriDesc = uri->Des();
+    uriDesc.Copy(aUriPath);
+    uriDesc.Append(KDmAdSeparator);
+    uriDesc.Append(aUriSeg);
+    return uri;
+    }
+
+DMAD_EXPORT_C MSmlDmAdapter::TError TDmAdUtil::MapStatusCode(TInt aStatus)
+    {
+    TRACE("TDmAdUtil::MapStatusCode");
+    
+    
+    MSmlDmAdapter::TError dmStatus;
+    if (aStatus == KErrNone)
+        {
+        dmStatus = MSmlDmAdapter::EOk;
+        }
+    else if (aStatus == KErrNotFound)
+        {
+        dmStatus = MSmlDmAdapter::ENotFound;
+        }
+    else if (aStatus == KErrCorrupt)
+        {
+        dmStatus = MSmlDmAdapter::EInvalidObject;
+        }
+    else if (aStatus == KErrAlreadyExists)
+        {
+        dmStatus = MSmlDmAdapter::EAlreadyExists;
+        }
+    else if (aStatus == KErrTooBig)
+        {
+        dmStatus = MSmlDmAdapter::ETooLargeObject;
+        }
+    else if (aStatus == KErrDiskFull)
+        {
+        dmStatus = MSmlDmAdapter::EDiskFull;
+        }
+    /*
+                ERollbackFailed,
+                EObjectInUse,
+                ENoMemory,
+                ECommitOK,
+                ERollbackOK,
+                ECommitFailed
+    */
+    else
+        {
+        dmStatus = MSmlDmAdapter::EError;
+        }
+    return dmStatus;
+    }
+
+DMAD_EXPORT_C void TDmAdUtil::ParseUriLC(const TDesC8& aUri, CArrayFix<TPtrC8>*& aUriSegList)
+    {
+    TPtrC8 uri(TDmAdUtil::RemoveDotSlash(aUri));
+    
+    CArrayFix<TPtrC8>* uriSegList;
+    uriSegList = new (ELeave) CArrayFixFlat<TPtrC8>(8);
+    CleanupStack::PushL(uriSegList);
+
+    TPtrC8 seg;
+    TPtrC8 curr(uri);
+
+    while (curr.Length() > 0)
+        {
+        TInt offset = curr.Locate('/');
+        if (offset == KErrNotFound)
+            {
+            seg.Set(curr);
+            curr.Set(KNullDesC8);
+            }
+        else
+            {
+            seg.Set(curr.Left(offset));
+            TInt rightLth = curr.Length() - offset - 1;
+            if (rightLth <= 0)           
+                {
+                DEBUG_LOG(_L("TDmAdUtil::ParseUriLC: corrupted uri"));
+                DEBUG_LOG1(_L8("URI: %S"), &aUri);
+                
+                User::Leave(KErrGeneral);
+                }
+            curr.Set(curr.Right(rightLth));
+            }
+        uriSegList->AppendL(seg);
+        }
+    
+    aUriSegList = uriSegList;
+    }
+
+DMAD_EXPORT_C HBufC8* TDmAdUtil::LuidTo8L(const TDesC& aLuid16)
+    {
+    HBufC8* luid8 = HBufC8::NewL(aLuid16.Length());
+    luid8->Des().Copy(aLuid16);
+    return luid8;
+    }
+    
+DMAD_EXPORT_C HBufC* TDmAdUtil::LuidTo16L(const TDesC8& aLuid8)
+    {
+    HBufC* luid16 = HBufC::NewL(aLuid8.Length());
+    luid16->Des().Copy(aLuid8);
+    return luid16;
+    }
+
+//-----------------------------------------------------------------------   
+    
+DMAD_EXPORT_C void TDmAdUtil::FillNodeInfoL(MSmlDmDDFObject&               aNode,
+                                            TSmlDmAccessTypes              aAccTypes,
+                                            MSmlDmDDFObject::TOccurence    aOccurrence,
+                                            MSmlDmDDFObject::TScope        aScope,
+                                            MSmlDmDDFObject::TDFFormat     aFormat,
+                                            const TDesC8&                  aDescription,
+                                            TBool                          aObjectGroup,
+                                            const TDesC8&                  aMimeType)
+{
+    aNode.SetAccessTypesL(aAccTypes);
+    aNode.SetOccurenceL(aOccurrence);
+    aNode.SetScopeL(aScope);
+    aNode.SetDFFormatL(aFormat);
+
+    if (aMimeType.Length() > 0)
+        {
+        aNode.AddDFTypeMimeTypeL(aMimeType);
+        }
+
+    aNode.SetDescriptionL(aDescription);
+
+    (void)aObjectGroup;
+    }
+
+DMAD_EXPORT_C MSmlDmDDFObject& TDmAdUtil::AddChildObjectL(MSmlDmDDFObject& aNode, const TDesC8& aNodeName)
+    {
+    if (aNodeName.Length() == 0)
+        {
+        MSmlDmDDFObject& object = aNode.AddChildObjectGroupL();
+        return object;
+        }
+    else
+        {
+        MSmlDmDDFObject& object = aNode.AddChildObjectL(aNodeName);
+        return object;
+        }
+    }
+
+DMAD_EXPORT_C HBufC8* TDmAdUtil::BuildLocallyCreatedRtNodeUriSegLC(TInt& aLargest)
+    {
+    ++aLargest;
+    HBufC8* number = TDmAdUtil::IntToDes8LC(aLargest);
+    HBufC8* uri = HBufC8::NewL(KDmAdLocallyCreatedRtNodeUriSegPrefix().Length() + number->Length());
+    uri->Des().Copy(KDmAdLocallyCreatedRtNodeUriSegPrefix);
+    uri->Des().Append(*number);
+    CleanupStack::PopAndDestroy(); // number
+    CleanupStack::PushL(uri);
+    return uri;
+    }
+
+TInt TDmAdUtil::FindLargestLocallyCreated(const CArrayFix<TSmlDmMappingInfo>& aPreviousUriSegmentList)
+    {
+    TRACE("TDmAdUtil::FindLargestLocallyCreated");
+    TInt largest = 0;
+    for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
+        {
+        const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);        
+        if (mappingInfo.iURISeg.Find(KDmAdLocallyCreatedRtNodeUriSegPrefix) == 0)
+            {            
+            TPtrC8 numberPart(mappingInfo.iURISeg.Mid(KDmAdLocallyCreatedRtNodeUriSegPrefix().Length()));
+            TInt number = TDmAdUtil::DesToInt(numberPart);
+            if (number > largest)
+                {
+                largest = number;
+                }
+            }
+        }
+    return largest;
+    }
+    
+    
+void PointerArrayCleanup(TAny* item)
+    {
+    RPointerArray<HBufC8>* a = static_cast<RPointerArray<HBufC8>*>(item);
+    a->ResetAndDestroy();
+    a->Close();
+    }
+
+
+#define DMAD_DUMP_PREVIOUS_URI_SEGMENT_LIST
+    
+DMAD_EXPORT_C void TDmAdUtil::BuildRtNodeChildUriListL(MDmAdCallBack*                          aDmAdCallBack,
+                                                  MDmAdStoreApi*                          aStoreApi,
+                                                  const TDesC8&                           aUri,
+                                                  const TDesC8&                           aParentLuid,
+                                                  const CArrayFix<TSmlDmMappingInfo>&     aPreviousUriSegmentList,
+                                                  CBufBase&                               aCurrentList)
+    {
+#ifdef DMAD_DUMP_PREVIOUS_URI_SEGMENT_LIST
+        DEBUG_LOG(_L("BuildRtNodeChildUriListL:"));
+        {
+        for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
+            {
+            const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);
+                        
+            DEBUG_LOG1(_L("entry %d:"), i);            
+            DEBUG_LOG1(_L8("Uri: %S"), &(mappingInfo.iURISeg));
+            DEBUG_LOG_HEX(mappingInfo.iURISegLUID);
+            
+            }
+        }
+#endif
+
+    RPointerArray<HBufC8> luidList;
+    CleanupStack::PushL(TCleanupItem(PointerArrayCleanup, &luidList));
+    
+    aStoreApi->LuidListL(aUri, aParentLuid, luidList);
+
+
+    // Finds largest number used in cli<x> named nodes.
+    TInt largest = FindLargestLocallyCreated(aPreviousUriSegmentList);
+    DEBUG_LOG1(_L("largest is cli%d"), largest);
+    
+    TInt countLuidList = luidList.Count();
+    for (TInt j=0; j < countLuidList; j++)
+        {
+        const HBufC8* luidElem = luidList[j];
+
+        HBufC8* uriSeg = 0;
+        
+        //Tries to find the luid from the aPreviousUriSegmentList
+        for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++)
+            {
+            const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i);
+                        
+            if (mappingInfo.iURISegLUID.Compare(*luidElem) == 0)
+                {            
+                uriSeg = mappingInfo.iURISeg.AllocLC();
+                break;
+                }
+            }
+        
+        if (uriSeg == 0)
+            {
+            //Uri was not found from the aPreviousUriSegmentList
+            uriSeg = BuildLocallyCreatedRtNodeUriSegLC(largest);
+            
+            DEBUG_LOG2(_L8("uriSeg %S, largest %d"), uriSeg, largest);
+            
+            HBufC8* wholeUri = TDmAdUtil::BuildUriLC(aUri, *uriSeg);            
+            aDmAdCallBack->SetMappingL(*wholeUri, *luidElem);
+            CleanupStack::PopAndDestroy(); //wholeUri
+            }
+
+        //If this is not the first element, inserts slash at the beginning
+        //of the result list.
+        if (j > 0)
+            {            
+            aCurrentList.InsertL(aCurrentList.Size(), KDmAdSeparator);
+            }
+        aCurrentList.InsertL(aCurrentList.Size(), *uriSeg);
+        
+        CleanupStack::PopAndDestroy(); // uriSeg
+        }
+    
+    CleanupStack::PopAndDestroy(); //luidList
+    }