webservices/wsstar/wsstarplugin/src/wsstardictionary.cpp
changeset 0 62f9d29f7211
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsstar/wsstarplugin/src/wsstardictionary.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,944 @@
+/*
+* Copyright (c) 2006-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:           
+*
+*/
+
+
+
+
+
+
+
+
+
+
+#include <e32std.h>
+#include <utf.h>
+#include <sysutil.h>
+#include <ezcompressor.h>
+#include "wsstardictionary.h"
+#include "wsstarhttpclient.h"
+#include "wsstarpolicy.h"
+#include "sendebug.h"
+#include "senxmldebug.h"
+#include "senlogger.h"
+
+using namespace WSPolicy;
+namespace
+{
+    _LIT8(KHttp, "http");
+    _LIT(KDictionaryFile, "dictionary.xml");
+    _LIT8(KDictionaryType, "Type");
+    _LIT8(KDictionaryId, "Id");
+    _LIT8(KDictionaryChkSum, "Chksum");
+    // helper methods          
+    /*
+    void TUint32ToDes(TDes8& aResult, TUint32 aData)
+        {
+        TUint32 part1= aData & 0xff000000 ;
+        part1 = part1 >> 24;
+        TUint32 part2= aData & 0x00ff0000;
+        part2 = part2 >> 16;
+        TUint16 part3= aData & 0x0000ff00;
+        part3 = part3 >> 8;
+        TUint16 part4= aData & 0x000000ff;
+        
+        TUint8 p1(part1);
+        TUint8 p2(part2);
+        TUint8 p3(part3);
+        TUint8 p4(part4);
+        
+        aResult.Append(p1);
+        aResult.Append(p2);
+        aResult.Append(p3);
+        aResult.Append(p4);
+        }
+    */
+    
+    /*
+    TUint32 DesToTUint32(const TDesC8& aData)
+        {
+        TUint32 part1 = aData[0];
+        part1 = part1-48;
+        part1 = part1 << 24;
+        TUint32 part2 = aData[1];
+        part2 = part2-48;
+        part2 = part2 << 16;
+        TUint32 part3 = aData[2];
+        part3 = part3-48;
+        part3 = part3 << 8;
+        TUint32 part4 = aData[3];
+        part4 = part4-48;
+       
+        TUint32 ret = part1+part2+part3+part4;
+        return ret;
+        }
+    */      
+}
+//---------------------------------------------------------------------------
+// Create instance of this class
+//---------------------------------------------------------------------------
+//
+CWSStarDictionary* CWSStarDictionary::NewL(CSIF& aSIF, RFileLogger& aLogger)
+    {
+    
+    CWSStarDictionary* self   = new (ELeave) CWSStarDictionary(aSIF, aLogger);
+    CleanupStack::PushL (self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+
+//---------------------------------------------------------------------------
+// Constructor
+//---------------------------------------------------------------------------
+//
+CWSStarDictionary::CWSStarDictionary(CSIF& aSIF, RFileLogger& aLogger) 
+:iSIF(&aSIF), iLog(aLogger)
+    {
+    }
+
+//---------------------------------------------------------------------------
+// Destructor
+//---------------------------------------------------------------------------
+//
+CWSStarDictionary::~CWSStarDictionary()
+    {
+    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarDictionary::~CWSStarDictionary()")));
+    iDictionaires.ResetAndDestroy();
+    delete iSavePath;
+    }
+
+//---------------------------------------------------------------------------
+// void CWSStarDictionary::ConstructL()
+//---------------------------------------------------------------------------
+//
+void CWSStarDictionary::ConstructL()
+    {   
+     TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarDictionary::ConstructL()")));
+
+#if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )
+        iSavePath = KPrivateFolder().AllocL();
+#else
+        TBuf<KMaxPath> privatePath;
+        RFs fss;
+            User::LeaveIfError(fss.Connect());
+            CleanupClosePushL(fss);
+        fss.CreatePrivatePath(EDriveC);
+        fss.PrivatePath(privatePath);
+        iSavePath = privatePath.AllocL();
+        CleanupStack::PopAndDestroy(1);
+#endif
+    }
+CZlibDictionary* CWSStarDictionary::Dictionary(const TDesC8& aName)
+{
+ 
+    TInt count(iDictionaires.Count());
+    for (TInt i = 0; i< count; i++)
+    {
+        CZlibDictionary* tempDict = iDictionaires[i];
+        if(tempDict->DictName() == aName)
+        {
+          return tempDict;  
+        }
+    }
+
+    return NULL;
+}    
+
+TBool CWSStarDictionary::IfDictionaryExist(CZlibDictionary* aDict)
+{
+ 
+    TInt count(iDictionaires.Count());
+    for (TInt i = 0; i< count; i++)
+    {
+        CZlibDictionary* tempDict = iDictionaires[i];
+        if(tempDict->DictName() == aDict->DictName() &&  
+        tempDict->DictCheckSumPtr() == aDict->DictCheckSumPtr()
+        ) //Id and checksum is same, its same dictionary
+        {
+          return ETrue;  
+        }
+    }
+    
+    return EFalse;
+}
+
+//---------------------------------------------------------------------------
+// void CWSStarDictionary::CreateZlibL
+// create a CZlibDictionary object from given dictionary inforamtion
+//---------------------------------------------------------------------------
+//
+void CWSStarDictionary::CreateMSZlibL(const TDesC8* name, CSenElement* aDict)
+{
+
+    const TDesC8* type = aDict->AttrValue(KMwsType);
+    const TDesC8* checksum = aDict->AttrValue(KMwsId);
+
+   if(aDict->HasContent())
+    {
+        TPtrC8 uri = aDict->Content();
+            
+        if(name && type && checksum && uri!= KNullDesC8())
+        {
+
+            CZlibDictionary* dict = CZlibDictionary::NewLC(uri, name, type, checksum);
+            if(dict)
+            {
+                if(!IfDictionaryExist(dict))
+                {
+                    iDictionaires.Append(dict);    
+                    CleanupStack::Pop( dict );                    
+                }
+                else //exist
+                {
+//                Reset only when we know that the uri has been changed
+               
+                    CZlibDictionary* tempDict = Dictionary(dict->DictName());
+                    if(tempDict)                     
+                    {
+                        if( tempDict->DictUri() == dict->DictUri()
+//                         && tempDict->DictType() == dict->DictType()
+                            )
+                        {
+                            //do nuthhing
+                        }
+                        else
+                        {
+                            tempDict->ResetL(dict);
+                        }
+                    }
+                    CleanupStack::PopAndDestroy( dict );
+                }
+            }
+            else
+            {
+                CleanupStack::PopAndDestroy( dict );
+            }
+        }
+        
+    }    
+    
+}
+
+void CWSStarDictionary::CreateZlibL(const TDesC8* name, CSenElement* aDict)
+{
+    if(!name || ! aDict)
+        return;
+
+    const TDesC8* type = aDict->AttrValue(KDictionaryType);
+    const TDesC8* checksum = aDict->AttrValue(KDictionaryChkSum);
+
+   if(aDict->HasContent())
+    {
+        TPtrC8 uri = aDict->Content();
+            
+        if(name && type && checksum && uri!= KNullDesC8())
+        {
+
+            CZlibDictionary* dict = CZlibDictionary::NewLC(uri, name, type, checksum);
+            if(dict && !IfDictionaryExist(dict))
+            {
+                iDictionaires.Append(dict);
+                CleanupStack::Pop( dict );
+                
+            }
+            else
+            {
+                CleanupStack::PopAndDestroy( dict );
+            }
+        }
+        
+    }    
+    
+}
+
+//---------------------------------------------------------------------------
+// TInt CWSStarDictionary::InvokeL
+// This method invoke the Http download of dictionaries. The dictionaries will 
+// be downloaded adn saves to private folder of the serene
+//---------------------------------------------------------------------------
+//
+TInt CWSStarDictionary::InvokeL(MSenHandlerContext* iHndlrCtx, CSenWSDescription* aSD)
+    {
+    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarDictionary::InvokeL(MSenMessageContext& aCtx)")));
+    TInt error(KErrNotFound);
+//1..load dictionary.xml file
+//2..load all of dictionaries and verify it
+    LoadDictionariesL();
+
+
+//3..get dictionary element from policy
+//only sts policy will be considered at this point
+   CSenElement* ret = CWSStarPolicy::GetElementL(KDictionaries, KNullDesC8(), *iHndlrCtx, aSD);
+    if(ret)
+    {
+        RPointerArray<CSenElement>& children = ret->ElementsL();
+        TInt count = children.Count();
+        for (TInt i =0; i < count; i++)
+        {
+            CSenElement* ele = children[i];
+            if(ele)
+            {
+                const TDesC8* name = ele->AttrValue(KMwsId);
+                RPointerArray<CSenElement> dicts;
+                CleanupClosePushL(dicts);
+                ele->ElementsL(dicts, KDictionary);
+
+                TInt count2 = dicts.Count();
+                for (TInt j =0; j < count2; j++)
+                {
+                    CSenElement* dictEle = dicts[j];
+                    if(dictEle)
+                    {
+                       CreateMSZlibL(name,dictEle);
+                       
+                    }
+                    
+                }
+                CleanupStack::PopAndDestroy(); //dicts
+                    
+             }
+
+        }
+
+    }
+//4..start putting dictionaries in xml file
+
+        
+ //5.. now use http to get all invalid dictionaries from iDictionaries
+   
+    TInt count(iDictionaires.Count());
+    TPtrC8 finalUri(KHttp);
+    if(finalUri != KNullDesC8)
+        {
+        TRAP(error, GetHttpDictionaryL(finalUri, iHndlrCtx));
+        }
+    else 
+        {
+        error = KErrPathNotFound;
+        }
+
+//6..write iDictionaries to xml file
+    SaveConfigurationL();
+    iDictionaires.ResetAndDestroy(); //we dont need it any more
+    return error;
+    }
+
+//---------------------------------------------------------------------------
+// TInt CWSStarDictionary::SaveL
+// Saves a dictionary to a file
+//---------------------------------------------------------------------------
+//
+TInt CWSStarDictionary::SaveL(TFileName aFileName, const TDesC8& aContents)
+{
+    if (aFileName.Length() < 1 || aContents.Length() < 1)
+        return KErrArgument;
+    RFs fss;
+    User::LeaveIfError(fss.Connect());
+    CleanupClosePushL(fss);
+
+    TInt size = aContents.Length();
+
+    TInt retVal(SysUtil::FFSSpaceBelowCriticalLevelL(&fss, size));
+    if(retVal == KErrNone)
+        {
+        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"File system check: OK, there is enough space available.");
+        }
+    else
+        {
+        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"File system check: FAILED, NOT enough space available.");
+        CleanupStack::PopAndDestroy(); //fss
+        User::Leave(retVal);
+        }
+        
+        RFile  dictFile;
+        CleanupClosePushL(dictFile);
+
+        retVal = dictFile.Replace(fss , aFileName, EFileWrite );
+        if(retVal == KErrNone)
+            {
+            retVal = dictFile.Write(aContents);        
+            }
+
+       
+       CleanupStack::PopAndDestroy(2); //fss, dictFile
+       return retVal;
+
+}
+//---------------------------------------------------------------------------
+// CWSStarDictionary::SaveFileL
+// Saves a dictionary to a file
+//---------------------------------------------------------------------------
+//
+
+void CWSStarDictionary::SaveFileL(const TDesC8& aUri, const TDesC8& aContents)
+{
+    TFileName filepath(iSavePath->Des());
+
+    TInt loc = aUri.LocateReverse('/');
+    if(loc != KErrNotFound)
+    {
+        TPtrC8 name = aUri.Right(aUri.Length() - loc - 1);
+        HBufC* nameBuf = HBufC::NewLC(name.Length());
+        TPtr nameBufPtr(nameBuf->Des());
+        TInt ret = CnvUtfConverter::ConvertToUnicodeFromUtf8(nameBufPtr, name);        
+        if(ret == KErrNone)
+        {
+            TFileName filename; 
+            filename.Append(nameBufPtr);
+            filepath.Append(filename);
+            ret = SaveL(filepath, aContents);
+        }
+        CleanupStack::PopAndDestroy(nameBuf);
+    }
+}
+//---------------------------------------------------------------------------
+// TInt CWSStarDictionary::GetHttpDictionaryL
+//Method to download the dictionaries by HTTP
+//---------------------------------------------------------------------------
+//
+
+TInt CWSStarDictionary::GetHttpDictionaryL( const TDesC8& aEndpoint, MSenHandlerContext* aHndlrCtx )
+    {
+    if( !aHndlrCtx )
+        {
+        return KErrArgument;
+        }    
+//find the service description from handlercontext i.e. STS service        
+    TPtrC8 contract(KWSStarSTSContract);
+    RPointerArray<CSenWSDescription> serviceDescriptions;
+    CleanupClosePushL(serviceDescriptions);
+    TInt retVal(KErrNone);
+    TInt leaveCode(KErrNone);
+    TRAP(leaveCode, retVal = aHndlrCtx->GetSenCoreServiceManager()->ServiceDescriptionsL(serviceDescriptions, contract));
+    CSenWSDescription* pSD = NULL;   
+    
+    if(leaveCode == KErrNone && retVal == KErrNone && serviceDescriptions.Count() > 0)
+        {
+         
+        TUint32 iap(0);
+        for(TInt j = 0; j < serviceDescriptions.Count(); j++)
+            {
+            pSD = serviceDescriptions[j];
+            if( pSD )
+                {
+                TInt getIapRetCode = pSD->IapId(iap);    
+                if( getIapRetCode == KErrNone )
+                    {
+                    pSD = serviceDescriptions[j]; // value IAP property over others (temp solution)
+                    break;
+                    }
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy( );  // serviceDescriptions.Close()
+
+    CSenWSDescription* pInitializer = CSenWSDescription::NewLC();
+    pInitializer->SetEndPointL(aEndpoint);
+
+    CWSStarHttpClient* pHttpClient = CWSStarHttpClient::NewLC(*(CSIF*)aHndlrCtx->GetAnyL(HandlerContextKey::KSIF()), pInitializer, *Log()); //*(CSIF*)iSenHandlerContext.GetAny(HandlerContextKey::KSIF()), pInitializer, *Log());//codescannerwarnings
+        
+    // Fix the first URI and request part of the request
+    TInt count( iDictionaires.Count() );
+    for (TInt i = 0; i< count; i++)
+        {
+        CZlibDictionary* tempDict = iDictionaires[i];   
+        if(!tempDict->Verified())
+            {
+        
+            TPtrC8 endpoint(tempDict->DictUri());        
+            TPtrC8 request(endpoint.Right(endpoint.Length() - aEndpoint.Length()));        
+
+            HBufC8* pResponse = NULL;
+            TInt leaveCode(KErrNone);
+            TInt submitRetCode(KErrNone);
+
+            TRAP( leaveCode, submitRetCode = pHttpClient->GetHttpL( request, pResponse, pSD ); )
+            pHttpClient->DataTrafficDetails(iDictDetails);
+            if( submitRetCode && retVal == KErrNone )
+                {
+                // Store the error code from the 1st failing request 
+                retVal = submitRetCode;
+                }    
+            if( leaveCode && retVal == KErrNone )
+                {
+                retVal = leaveCode;
+                }    
+            if(pResponse && pResponse->Length() > 0)
+                {
+                CleanupStack::PushL(pResponse);            
+                TPtrC8 resPtr(pResponse->Des());
+                if(tempDict->SetDictContentsL(resPtr) == KErrNone)
+                {
+                    SaveFileL(endpoint, resPtr);
+                    
+                }
+                CleanupStack::PopAndDestroy();
+                }    
+            else // if(retVal == 404)    
+                {
+                delete pResponse;
+                }
+            }
+        } // for each request
+    CleanupStack::PopAndDestroy(pHttpClient); 
+    CleanupStack::PopAndDestroy(pInitializer);  
+    return retVal;
+}
+
+TInt CWSStarDictionary::LoadDictionariesL()
+{
+    
+    TFileName dictXml(iSavePath->Des());
+    dictXml.Append(KDictionaryFile);
+    
+    CDictXml* dict= CDictXml::NewL();
+    CleanupStack::PushL(dict);
+    TInt fileError = dict->ReadFileL(dictXml);
+    if(fileError == KErrNone)
+    {
+        CSenElement* dictEle = dict->XMLDocL();
+        if(dictEle)
+        {
+            LoadDictionariesL(dictEle);
+        }
+    
+    }
+    CleanupStack::PopAndDestroy(dict);
+    return fileError;    
+}
+//---------------------------------------------------------------------------
+// void CWSStarDictionary::LoadFileL
+// This method Loads the dictionaries from the files present in private folder.
+//---------------------------------------------------------------------------
+//
+void CWSStarDictionary::LoadFileL(CZlibDictionary* aDict)
+{
+    TFileName filepath(iSavePath->Des());
+    
+    TPtrC8 uri = aDict->DictUri();
+    TInt loc = uri.LocateReverse('/');
+    
+    if(loc != KErrNotFound)
+    {
+        TPtrC8 name = uri.Right(uri.Length() - loc - 1);
+        HBufC* nameBuf = HBufC::NewLC(name.Length());
+        TPtr nameBufPtr(nameBuf->Des());
+        TInt ret = CnvUtfConverter::ConvertToUnicodeFromUtf8(nameBufPtr, name);        
+        if(ret == KErrNone)
+        {
+            TFileName filename; 
+            filename.Append(nameBufPtr);
+            filepath.Append(filename);
+            {
+                RFs fss;
+                User::LeaveIfError(fss.Connect());
+                CleanupClosePushL(fss);
+                
+                RFile  dictFile;
+                TInt error = dictFile.Open(fss , filepath, EFileRead );
+                CleanupClosePushL(dictFile);                
+                if(error == KErrNone)
+                {
+                    TInt size;
+                    dictFile.Size(size);
+                    if(size > 0)
+                    {
+                        HBufC8 *iBuf=HBufC8::NewLC(size);
+                        TPtr8 buf8ptr(iBuf->Des());
+                        dictFile.Read(buf8ptr,size);
+                        aDict->SetDictContentsL(buf8ptr);
+                        aDict->DeleteDictContents();
+                        CleanupStack::PopAndDestroy(iBuf);
+                        
+                    }
+                }
+                CleanupStack::PopAndDestroy(2); //fss, dictFile
+            }
+        }
+        CleanupStack::PopAndDestroy(nameBuf);
+    }
+}
+
+//---------------------------------------------------------------------------
+// void CWSStarDictionary::LoadDictionariesLs
+// This method Loads the dictionaries from the private folder. It reads the 
+// policy file for the possible dictionaries and load those dictionaries from 
+// priavte folder.
+//---------------------------------------------------------------------------
+//
+TInt CWSStarDictionary::LoadDictionariesL(CSenElement*  aPolicy)
+{
+    if(aPolicy)
+    {
+        RPointerArray<CSenElement>& children = aPolicy->ElementsL();
+        TInt count = children.Count();
+        for (TInt i =0; i < count; i++)
+        {
+            CSenElement* ele = children[i];
+            if(ele)
+            {
+                const TDesC8* name = ele->AttrValue(KDictionaryId);
+                CreateZlibL(name,ele);
+                       
+            }
+        }
+        
+    }
+
+    TInt count(iDictionaires.Count());
+    for (TInt i = 0; i< count; i++)
+    {
+        CZlibDictionary* tempDict = iDictionaires[i];
+        if(tempDict)
+            LoadFileL(tempDict);
+    }
+
+    return KErrNone;
+}
+TInt CWSStarDictionary::SaveConfigurationL()
+{
+    TInt error(KErrNone);
+    HBufC8* ret = WriteAllAsXMlL();
+    CleanupStack::PushL(ret);
+    if(ret)
+    {
+        TPtrC filename(KDictionaryFile);
+        TPtrC8 dataptr(ret->Des());
+        error = SaveL(filename, dataptr);
+    }
+    CleanupStack::PopAndDestroy(ret);
+    return error;   
+}
+
+TPtrC8 CWSStarDictionary::WriteToBufL(CBufBase& aBuf)
+    {
+    RBufWriteStream bufWs(aBuf);
+    CleanupClosePushL(bufWs);
+    WriteL(bufWs);
+    CleanupStack::PopAndDestroy(); // bufWs.Close();
+    return aBuf.Ptr(0);
+    }
+HBufC8* CWSStarDictionary::WriteAllAsXMlL()
+{
+    CBufFlat *pBuf = CBufFlat::NewL(128);
+    CleanupStack::PushL(pBuf);
+    TPtrC8 p = WriteToBufL(*pBuf);
+    HBufC8* pRet = p.AllocL();
+    CleanupStack::PopAndDestroy(); // pBuf;
+    return pRet;    
+}
+         
+TInt CWSStarDictionary::WriteL(RWriteStream& aWriteStream)
+{
+    aWriteStream.WriteL(KSenLessThan);
+    aWriteStream.WriteL(KDictionaries);
+    aWriteStream.WriteL(KSenGreaterThan);
+    
+    TInt count(iDictionaires.Count());
+    for (TInt i = 0; i< count; i++)
+    {
+        CZlibDictionary* tempDict = iDictionaires[i];
+        TPtrC8 endpoint(tempDict->DictUri());
+        TPtrC8 type(tempDict->DictType());
+        TPtrC8 id(tempDict->DictName());
+        TPtrC8 chksum(tempDict->DictCheckSumPtr());
+          
+        if(id != KNullDesC8() && endpoint != KNullDesC8() && type != KNullDesC8() && chksum != KNullDesC8)
+        {
+            aWriteStream.WriteL(KSenLessThan);
+            aWriteStream.WriteL(KDictionary);
+            aWriteStream.WriteL(KSenSpace);
+            aWriteStream.WriteL(KDictionaryId);
+            aWriteStream.WriteL(KSenEqualsDblQuot);
+            aWriteStream.WriteL(id);
+            aWriteStream.WriteL(KSenDblQuot);
+            aWriteStream.WriteL(KSenSpace);            
+            aWriteStream.WriteL(KDictionaryType);
+            aWriteStream.WriteL(KSenEqualsDblQuot);
+            aWriteStream.WriteL(type);
+            aWriteStream.WriteL(KSenDblQuot);
+            aWriteStream.WriteL(KSenSpace);
+            aWriteStream.WriteL(KDictionaryChkSum);
+            aWriteStream.WriteL(KSenEqualsDblQuot);
+            aWriteStream.WriteL(chksum);
+            aWriteStream.WriteL(KSenDblQuot);
+            aWriteStream.WriteL(KSenSpace);
+            aWriteStream.WriteL(KSenGreaterThan);
+            aWriteStream.WriteL(endpoint);
+            
+            aWriteStream.WriteL(KSenLessThanSlash);
+            aWriteStream.WriteL(KDictionary);
+            aWriteStream.WriteL(KSenGreaterThan);
+
+        }
+    }
+
+    aWriteStream.WriteL(KSenLessThanSlash);
+    aWriteStream.WriteL(KDictionaries);
+	aWriteStream.WriteL(KSenGreaterThan);
+
+return KErrNone;    
+}
+void CWSStarDictionary::DataTrafficDetails(TSenDataTrafficDetails& aDetails) 		
+	{
+		aDetails = iDictDetails;
+	}
+//---------------------------------------------------------------------------
+// CWSStarDictionary::Log()
+//---------------------------------------------------------------------------
+//    
+RFileLogger* CWSStarDictionary::Log() const
+    {
+    return &iLog;
+//        return ((RFileLogger*)iHandlerContext.GetAny(HandlerContextKey::KLogger));
+    }
+
+
+//---------------------------------------------------------------------------
+// A simple Dictionary Object and its implementation
+//---------------------------------------------------------------------------
+//
+CZlibDictionary* CZlibDictionary::NewL( const TDesC8& aDictUri, 
+                                        const TDesC8* aDictName, 
+                                        const TDesC8* aDictType, 
+                                        const TDesC8* aDictCheckSum )
+{
+    CZlibDictionary* zlib   = CZlibDictionary::NewLC(aDictUri, aDictName, aDictType, aDictCheckSum);
+    CleanupStack::Pop();
+    return zlib;
+}
+                                
+CZlibDictionary* CZlibDictionary::NewLC( const TDesC8& aDictUri, 
+                                         const TDesC8* aDictName, 
+                                         const TDesC8* aDictType, 
+                                         const TDesC8* aDictCheckSum )
+{
+
+    CZlibDictionary* zlib   = new (ELeave) CZlibDictionary();
+    CleanupStack::PushL (zlib);
+    zlib->ConstructL(aDictUri, aDictName, aDictType, aDictCheckSum);
+    return zlib;
+    
+}
+
+CZlibDictionary::~CZlibDictionary()
+{
+    delete iDictUri; //uri to download
+    delete iDictName; //name or mws:Id tag
+    delete iDictType; //zlib or mws:type
+    delete iDictContents; //contents
+    delete iDictCheckSum; //provided checksum  
+}
+CZlibDictionary::CZlibDictionary()
+:iVerfied(EFalse)
+{
+}
+
+void CZlibDictionary::ConstructL( const TDesC8& aDictUri, 
+                                  const TDesC8* aDictName,
+                                  const TDesC8* aDictType, 
+                                  const TDesC8* aDictCheckSum )
+    {
+    iDictUri = aDictUri.AllocL();
+    iDictName = aDictName->AllocL(); 
+    iDictType = aDictType->AllocL();
+    iDictCheckSum = aDictCheckSum->AllocL();
+    }
+    
+TBool  CZlibDictionary::Verified()
+{
+    return iVerfied;
+}
+TPtrC8  CZlibDictionary::DictUri()
+{
+    return iDictUri->Des();    
+}
+TPtrC8  CZlibDictionary::DictName()
+{
+    return iDictName->Des();
+}
+TPtrC8  CZlibDictionary::DictType()
+{
+    return iDictType->Des();
+}
+TPtrC8  CZlibDictionary::DictContents()
+{
+    return iDictContents->Des();
+}
+
+TUint32 CZlibDictionary::DictCheckSum()
+    {
+    return iChkSum;
+    }
+
+TPtrC8 CZlibDictionary::DictCheckSumPtr()
+    {
+    return iDictCheckSum->Des();
+    }
+
+TInt CZlibDictionary::VerifyContentsL(const TDesC8& aDictContents)
+{
+    TPtrC8 dictChk(iDictCheckSum->Des());
+    
+    TLex8 lex(dictChk);
+    TUint32 givenChkSum = 0;
+    TInt error = lex.Val(givenChkSum, EDecimal);
+
+    if(error == KErrNone)
+    {
+        if(givenChkSum == 0)
+            return KErrArgument;
+        
+        iChkSum = givenChkSum;
+        TUint32 calc_chksum(0);
+        calc_chksum = adler32(calc_chksum,0,0);		// init Adler32 checksum
+        calc_chksum = adler32(calc_chksum,aDictContents.Ptr(),aDictContents.Length()); // compute Adler32 checksum
+        if(givenChkSum == calc_chksum) 
+        {
+            return KErrNone;
+        }        
+    }
+    return error;
+}
+TInt CZlibDictionary::DeleteDictContents()
+{
+    if(iDictContents)
+    {
+        delete iDictContents;
+        iDictContents = NULL;
+    }
+    return KErrNone;      
+}
+TInt CZlibDictionary::SetDictContentsL(const TDesC8& aDictContents)
+{
+    if(aDictContents == KNullDesC8())    
+        return KErrArgument;
+
+    if (VerifyContentsL(aDictContents) == KErrNone)
+    {
+        iVerfied = ETrue;
+        if(iDictContents)
+        {
+            delete iDictContents;
+            iDictContents = NULL;
+        }
+        
+        iDictContents = aDictContents.AllocL();
+        return KErrNone;
+    }
+    
+    return KErrGeneral;
+}
+
+TInt CZlibDictionary::ResetL(CZlibDictionary* aDict)
+{
+    delete iDictUri; 
+    iDictUri = NULL;
+    delete iDictName; 
+    iDictName = NULL;
+    delete iDictType; 
+    iDictType = NULL;
+    delete iDictContents;
+	iDictContents = NULL;
+    delete iDictCheckSum;
+    iDictCheckSum = NULL;
+    iDictUri = aDict->DictUri().AllocL();
+    iDictName = aDict->DictName().AllocL();
+    iDictType = aDict->DictType().AllocL();
+    iDictCheckSum = aDict->DictCheckSumPtr().AllocL();
+    iVerfied = EFalse;
+    iChkSum = 0;
+    return KErrNone;
+}
+
+CDictXml* CDictXml::NewL()
+{
+     CDictXml* pSelf = CDictXml::NewLC();
+    CleanupStack::Pop(pSelf);
+    return pSelf;
+}
+CDictXml* CDictXml::NewLC()
+{
+       CDictXml* pSelf = new (ELeave) CDictXml();
+    CleanupStack::PushL(pSelf);
+    pSelf->ConstructL();
+    return pSelf;
+  
+}
+CDictXml::~CDictXml()
+{
+  delete iXmlReader;
+}
+CDictXml::CDictXml() :iParsed(EFalse)
+{
+    
+}
+void CDictXml::ConstructL()
+{
+  iXmlReader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser
+}
+
+CSenElement* CDictXml::XMLDocL()
+{
+    if(iParsed)
+    {
+        CSenElement* ele = &AsElement();
+        if(ele)
+            return ele;
+    }
+    
+    return NULL;
+}
+TInt CDictXml::ReadFileL(TFileName aPath)
+{
+      RFs fss;
+       User::LeaveIfError(fss.Connect());
+        CleanupClosePushL(fss);
+
+    TFileName iFileName1(aPath);
+    RFile  xmlFile;
+    TInt error = xmlFile.Open(fss , iFileName1, EFileRead );
+    CleanupClosePushL(xmlFile);    
+
+    if(error == KErrNone)
+    {
+        error = KErrGeneral;
+                
+        TInt size;
+        xmlFile.Size(size);
+
+        HBufC8 *pBuf=HBufC8::NewL(size);	//CodeScannerWarnings
+        CleanupStack::PushL(pBuf);
+        TPtr8 buf8ptr(pBuf->Des());
+        xmlFile.Read(buf8ptr,size);
+        size = pBuf->Length();
+        if(size > 0)
+            {
+            TPtr8 buf8ptr(pBuf->Des());            
+            TRAP( error, ParseL(buf8ptr);)
+            if (error == KErrNone)
+                iParsed = ETrue;
+            }
+        CleanupStack::PopAndDestroy(pBuf);
+    }
+    CleanupStack::PopAndDestroy(2); // fss  , xmlFile  
+    return error;    
+} 
+
+// END OF FILE
+