diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/protocol/src/ncdrequestconfigurationdata.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ncdengine/provider/protocol/src/ncdrequestconfigurationdata.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,905 @@
+/*
+* Copyright (c) 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:   CNcdRequestConfigurationData implementation
+*
+*/
+
+
+#include "ncdrequestconfigurationdata.h"
+#include "ncdrequestconstants.h"
+#include "ncdprotocolutils.h"
+#include "ncdprotocolwords.h"
+#include "ncd_cp_cookie.h"
+#include "ncd_cp_detail.h"
+#include "catalogsutils.h"
+
+#include "catalogsdebug.h"
+
+void CloseStringArray( 
+    RArray< TXmlEngString >& aArray )
+    {
+    TInt count = aArray.Count();
+    for( TInt i = 0; i < count; i++ )
+        {
+        aArray[ i ].Free();
+        }
+    aArray.Close();
+    }
+
+
+
+TXmlEngElement GetDetailsElementL(
+    RXmlEngDocument& aDocument, 
+    const MNcdConfigurationProtocolDetail& aDetails,
+    const TXmlEngString& aPrefix )
+    {
+    DLTRACEIN((""));
+    TXmlEngElement detail = NcdProtocolUtils::NewElementL( 
+        aDocument, KTagDetail, aPrefix );
+
+    if ( aDetails.GroupId() != KNullDesC )
+        NcdProtocolUtils::NewAttributeL( detail, KAttrGroupId, 
+            aDetails.GroupId() );
+
+    if ( aDetails.Label() != KNullDesC )
+        NcdProtocolUtils::NewAttributeL( detail, KAttrLabel, 
+            aDetails.Label() );
+    
+    if ( aDetails.Id() != KNullDesC )    
+        NcdProtocolUtils::NewAttributeL( detail, KAttrId, 
+            aDetails.Id() );
+
+    if ( aDetails.Value() != KNullDesC )
+        NcdProtocolUtils::NewAttributeL( detail, KAttrValue, 
+            aDetails.Value() );
+        
+    for ( TInt j = 0; j < aDetails.Contents().Count(); ++j ) 
+        {
+        MNcdConfigurationProtocolContent* cont = aDetails.Contents()[j];
+        TXmlEngElement content = NcdProtocolUtils::NewElementL( 
+            aDocument, detail, KTagContent );
+        NcdProtocolUtils::NewAttributeL( content, KAttrKey, cont->Key() );
+        NcdProtocolUtils::NewAttributeL( content, KAttrValue, cont->Value() );
+        }
+
+    for ( TInt j = 0; j < aDetails.Details().Count(); ++j ) 
+        {
+        // get elements recursively
+        TXmlEngElement child = GetDetailsElementL( aDocument, 
+            *(aDetails.Details()[j]), aPrefix );
+        detail.AppendChildL(child);
+        }
+    /*
+    for ( TInt j = 0; j < aDetails.xmlFragment.Count(); ++j ) 
+        {
+        TNcdRequestCustomXmlFragment xmlFrag = aDetails.xmlFragment[j];
+        TXmlEngElement xmlFragment = detail.AddNewElementL(
+            NcdProtocolUtils::DesToStringL( KTagXmlFragment ) );
+        }
+    */
+    DLTRACEOUT((""));
+    return detail;
+    }
+
+
+/**
+ * Software-element for client-elements
+ */
+// ---------------------------------------------------------------------------
+// 
+// ---------------------------------------------------------------------------
+// 
+CNcdRequestConfigurationSoftware* CNcdRequestConfigurationSoftware::NewLC()
+    {
+    CNcdRequestConfigurationSoftware* self = new(ELeave) 
+        CNcdRequestConfigurationSoftware;
+    CleanupStack::PushL( self );
+    return self;
+    }
+    
+// ---------------------------------------------------------------------------
+// 
+// ---------------------------------------------------------------------------
+//    
+CNcdRequestConfigurationSoftware::~CNcdRequestConfigurationSoftware()
+    {
+    iSoftware.type.Free();
+    iSoftware.version.Free();
+    iSoftware.uid.Free();
+    iSoftware.id.Free();
+    iSoftware.ssid.Free();
+    iSoftware.language.Free();    
+    CloseStringArray( iSoftware.capabilities );
+    iSoftware.details.ResetAndDestroy();
+        
+    }
+
+void CNcdRequestConfigurationSoftware::SetSoftwareTypeL( 
+    const TDesC& aType )
+    {
+    iSoftware.type.SetL(aType);
+    }
+
+void CNcdRequestConfigurationSoftware::SetSoftwareVersionL( 
+    const TDesC& aVersion )
+    {
+    DLTRACEIN((""));
+    iSoftware.version.SetL(aVersion);
+    DLTRACEOUT((""));
+    }
+
+void CNcdRequestConfigurationSoftware::SetSoftwareIdsL( 
+    const TDesC& aUid, const TDesC& aId, const TDesC8& aSsid )
+    {
+    if (aUid != KNullDesC)
+        iSoftware.uid.SetL(aUid);
+    if (aId != KNullDesC)
+        iSoftware.id.SetL(aId);
+    if (aSsid != KNullDesC8)
+        iSoftware.ssid.SetL(aSsid);
+    }
+
+void CNcdRequestConfigurationSoftware::SetSoftwareLanguageL( 
+    const TDesC& aLanguage )
+    {
+    iSoftware.language.SetL(aLanguage);
+    }
+
+
+void CNcdRequestConfigurationSoftware::AddSoftwareCapabilityL( 
+    const TDesC& aCapability )
+    {
+    TXmlEngString capability;
+    capability.SetL(aCapability);
+    if ( iSoftware.capabilities.Append(capability) != KErrNone )
+        {
+        capability.Free();
+        }
+    }
+
+void CNcdRequestConfigurationSoftware::AddSoftwareDetailsL( 
+    MNcdConfigurationProtocolDetail* aDetail)
+    {
+    iSoftware.details.AppendL(aDetail);
+    }
+
+
+TXmlEngElement CNcdRequestConfigurationSoftware::GetSoftwareConfigurationElementL(
+    RXmlEngDocument& aDocument, const TXmlEngString& aPrefix )
+    {
+    DLTRACEIN((""));
+    TXmlEngElement software = NcdProtocolUtils::NewElementL( aDocument, 
+        KTagSoftware, aPrefix );
+        
+    // software/@version, required
+    NcdProtocolUtils::NewAttributeL(software, KAttrVersion, iSoftware.version);
+
+    NcdProtocolUtils::NewAttributeL(software, KAttrType, iSoftware.type);
+
+    if (iSoftware.uid.NotNull())
+        NcdProtocolUtils::NewAttributeL(software, KAttrUid, iSoftware.uid);
+
+    if (iSoftware.id.NotNull())
+        NcdProtocolUtils::NewAttributeL(software, KAttrId, iSoftware.id);
+
+    if (iSoftware.ssid.NotNull())
+        NcdProtocolUtils::NewAttributeL(software, KAttrSsid, iSoftware.ssid);
+        
+    if ( iSoftware.language.NotNull() ) 
+        {
+        TXmlEngElement language = NcdProtocolUtils::NewElementL( aDocument, 
+            software, KTagLanguage, aPrefix );
+#ifndef RD_XML_ENGINE_API_CHANGE
+        language.SetTextL( iSoftware.language );
+#else
+        language.SetTextL( iSoftware.language.PtrC8() );
+#endif
+        }
+
+
+    if ( iSoftware.capabilities.Count() > 0 ) 
+        {
+        TXmlEngElement capabilities = NcdProtocolUtils::NewElementL( 
+            aDocument, software, KTagCapabilities, aPrefix );
+            
+        for (TInt i = 0; i < iSoftware.capabilities.Count(); ++i)
+            {            
+            TXmlEngElement capability = NcdProtocolUtils::NewElementL( 
+                aDocument, capabilities, KTagCapability, aPrefix );
+
+#ifndef RD_XML_ENGINE_API_CHANGE            
+            capability.SetTextL( iSoftware.capabilities[i] );            
+#else
+            capability.SetTextL( iSoftware.capabilities[i].PtrC8() );
+#endif            
+            }
+        }
+
+    // details
+    if ( iSoftware.details.Count() > 0 ) 
+        {
+        TXmlEngElement details = 
+            NcdProtocolUtils::NewElementL( aDocument, software, 
+                KTagDetails, aPrefix );
+            
+        for ( TInt i = 0; i < iSoftware.details.Count(); ++i ) 
+            {
+            MNcdConfigurationProtocolDetail* det = iSoftware.details[i];
+            details.AppendChildL( GetDetailsElementL( aDocument, 
+                *det, aPrefix ) );
+            }
+        }
+
+    DLTRACEOUT((""));
+    return software;
+    }
+    
+
+/**
+ * Hardware-element for client-elements
+ */
+
+CNcdRequestConfigurationHardware* CNcdRequestConfigurationHardware::NewL()
+    {
+    CNcdRequestConfigurationHardware* self = new(ELeave) 
+        CNcdRequestConfigurationHardware;
+    return self;
+    }
+    
+    
+CNcdRequestConfigurationHardware::~CNcdRequestConfigurationHardware()
+    {
+    // Clean iHardware
+    iHardware.uaProfileUri.Free();
+    iHardware.identification.Free();
+    iHardware.manufacturer.Free();
+    iHardware.model.Free();
+    iHardware.language.Free();
+    iHardware.platform.Free();
+    iHardware.firmwareVersion.Free();
+    iHardware.displays.ResetAndDestroy();
+    iHardware.details.ResetAndDestroy();
+    
+    }
+
+
+void CNcdRequestConfigurationHardware::SetHardwareUaProfileUriL( 
+    const TDesC& aUaProfileUri )
+    {
+    iHardware.uaProfileUri.SetL(aUaProfileUri);
+    }
+
+void CNcdRequestConfigurationHardware::SetHardwareIdentificationL( 
+    const TDesC& aIdentification )
+    {
+    iHardware.identification.SetL(aIdentification);
+    }
+
+void CNcdRequestConfigurationHardware::SetHardwareManufacturerL( 
+    const TDesC& aManufacturer )
+    {
+    iHardware.manufacturer.SetL(aManufacturer);
+    }
+
+void CNcdRequestConfigurationHardware::SetHardwareModelL( 
+    const TDesC& aModel )
+    {
+    iHardware.model.SetL(aModel);
+    }
+
+void CNcdRequestConfigurationHardware::SetHardwareLanguageL( 
+    const TDesC& aLanguage )
+    {
+    iHardware.language.SetL(aLanguage);
+    }
+
+void CNcdRequestConfigurationHardware::SetHardwarePlatformL( 
+    const TDesC& aPlatform )
+    {
+    iHardware.platform.SetL(aPlatform);
+    }
+
+void CNcdRequestConfigurationHardware::SetHardwareFirmwareL( 
+    const TDesC& aFirmwareVersion )
+    {
+    iHardware.firmwareVersion.SetL(aFirmwareVersion);
+    }
+
+void CNcdRequestConfigurationHardware::AddHardwareDisplayL( 
+    TInt aColors, TInt aHeight, TInt aWidth )
+    {
+    CNcdConfigurationDisplay* disp = new (ELeave) CNcdConfigurationDisplay;
+    disp->iColors = aColors;
+    disp->iHeight = aHeight;
+    disp->iWidth = aWidth;
+    if ( iHardware.displays.Append(disp) != KErrNone ) 
+        {
+        delete disp;
+        }
+    }
+    
+
+void CNcdRequestConfigurationHardware::AddHardwareDetailsL( 
+    MNcdConfigurationProtocolDetail* aDetail )
+    {
+    iHardware.details.AppendL(aDetail);
+    }
+
+
+TXmlEngElement CNcdRequestConfigurationHardware::GetHardwareConfigurationElementL(
+    RXmlEngDocument& aDocument, const TXmlEngString& aPrefix )
+    {
+    DLTRACEIN((""));
+    TXmlEngElement hardware = NcdProtocolUtils::NewElementL( aDocument, 
+        KTagHardware, aPrefix );
+    
+    if (iHardware.uaProfileUri.NotNull()) 
+        {
+        TXmlEngElement uaProfileUri = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagUaProfileUri, aPrefix );
+            
+#ifndef RD_XML_ENGINE_API_CHANGE
+        uaProfileUri.SetTextL(iHardware.uaProfileUri);
+#else
+        uaProfileUri.SetTextL( iHardware.uaProfileUri.PtrC8() );
+#endif
+        }
+
+    if (iHardware.identification.NotNull())
+        {
+        TXmlEngElement identification = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagIdentification, aPrefix );
+            
+#ifndef RD_XML_ENGINE_API_CHANGE
+        identification.SetTextL(iHardware.identification);
+#else
+        identification.SetTextL( iHardware.identification.PtrC8() );
+#endif
+        }
+        
+    if (iHardware.manufacturer.NotNull())
+        {
+        TXmlEngElement manufacturer = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagManufacturer, aPrefix );
+#ifndef RD_XML_ENGINE_API_CHANGE
+        manufacturer.SetTextL(iHardware.manufacturer);
+#else
+        manufacturer.SetTextL( iHardware.manufacturer.PtrC8() );
+#endif
+        }
+    
+    if (iHardware.model.NotNull())
+        {
+        TXmlEngElement model = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagModel, aPrefix );
+#ifndef RD_XML_ENGINE_API_CHANGE
+        model.SetTextL(iHardware.model);
+#else
+        model.SetTextL( iHardware.model.PtrC8() );
+#endif
+        }
+
+    if (iHardware.language.NotNull())
+        {
+        TXmlEngElement language = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagLanguage, aPrefix );
+#ifndef RD_XML_ENGINE_API_CHANGE
+        language.SetTextL(iHardware.language);
+#else
+        language.SetTextL( iHardware.language.PtrC8() );
+#endif
+        }
+
+    if (iHardware.platform.NotNull())
+        {
+        TXmlEngElement platform = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagPlatform, aPrefix );
+            
+#ifndef RD_XML_ENGINE_API_CHANGE
+        platform.SetTextL(iHardware.platform);
+#else
+        platform.SetTextL( iHardware.platform.PtrC8() );
+#endif
+        }
+        
+    if (iHardware.firmwareVersion.NotNull())
+        {
+        TXmlEngElement firmwareVersion = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagFirmwareVersion, aPrefix );
+#ifndef RD_XML_ENGINE_API_CHANGE
+        firmwareVersion.SetTextL(iHardware.firmwareVersion);
+#else
+        firmwareVersion.SetTextL( iHardware.firmwareVersion.PtrC8() );
+#endif
+        }
+        
+    for (TInt i = 0; i < iHardware.displays.Count(); ++i)
+        {
+        CNcdConfigurationDisplay* disp = iHardware.displays[i];
+        TXmlEngElement display = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagDisplay, aPrefix );
+        NcdProtocolUtils::NewAttributeL( display, KAttrWidth, disp->iWidth );
+        NcdProtocolUtils::NewAttributeL( display, KAttrHeight, disp->iHeight );
+        NcdProtocolUtils::NewAttributeL( display, KAttrColors, disp->iColors );
+        }
+
+    // details
+    if ( iHardware.details.Count() > 0 ) 
+        {
+        TXmlEngElement details = NcdProtocolUtils::NewElementL( 
+            aDocument, hardware, KTagDetails, aPrefix );
+            
+        for ( TInt i = 0; i < iHardware.details.Count(); ++i ) 
+            {
+            MNcdConfigurationProtocolDetail* det = iHardware.details[i];
+            details.AppendChildL( GetDetailsElementL( aDocument, 
+                *det, aPrefix ) );
+            }
+        }
+
+    if (hardware.HasChildNodes())
+        {
+        DLTRACEOUT((""));
+        return hardware;        
+        }
+    DLTRACEOUT(("return null"));
+    return NULL;        
+    }
+
+
+
+/**
+ * Client-element for configuration requests
+ */
+CNcdRequestConfigurationClient* CNcdRequestConfigurationClient::NewLC()
+    {
+    CNcdRequestConfigurationClient* self = new(ELeave) 
+        CNcdRequestConfigurationClient;
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    return self;
+    }
+    
+    
+CNcdRequestConfigurationClient::~CNcdRequestConfigurationClient()
+    {
+    iSoftwares.ResetAndDestroy();
+    delete iHardware;
+    }
+    
+
+void CNcdRequestConfigurationClient::AddSoftwareL( 
+    CNcdRequestConfigurationSoftware* aSoftware )
+    {
+    iSoftwares.AppendL( aSoftware );
+    }
+    
+TInt CNcdRequestConfigurationClient::SoftwareCount() const
+    {
+    return iSoftwares.Count();
+    }
+    
+    
+CNcdRequestConfigurationSoftware& 
+    CNcdRequestConfigurationClient::Software( TInt aIndex )
+    {
+    return *(iSoftwares[ aIndex ]);
+    }
+            
+                  
+CNcdRequestConfigurationHardware& CNcdRequestConfigurationClient::Hardware()
+    {
+    DASSERT( iHardware );
+    return *iHardware;
+    }
+     
+
+CNcdRequestConfigurationClient::CNcdRequestConfigurationClient()
+    {
+    }
+    
+    
+void CNcdRequestConfigurationClient::ConstructL()
+    {
+    iHardware = CNcdRequestConfigurationHardware::NewL();
+    }
+    
+
+// ---------------------------------------------------------------------------
+// CNcdRequestConfigurationData
+// ---------------------------------------------------------------------------
+//
+
+CNcdRequestConfigurationData* CNcdRequestConfigurationData::NewLC()
+    {
+    CNcdRequestConfigurationData* self = 
+        new (ELeave) CNcdRequestConfigurationData();
+    CleanupStack::PushL(self);
+
+    return self;
+    }
+
+
+CNcdRequestConfigurationData::CNcdRequestConfigurationData()
+    {
+    }
+    
+
+CNcdRequestConfigurationData::~CNcdRequestConfigurationData()
+    {
+    DLTRACEIN((""));
+    /*
+    * @ TXmlEngString members need to be Freed!
+    */
+    
+    iQueryResponseId.Free();
+    iPrefix.Free();
+
+    iCookies.ResetAndDestroy();
+    ResetAndCloseArray( iQueryResponses );
+
+    // Clean iNetwork
+    iNetwork.mcc.Free();
+    iNetwork.mnc.Free();
+    iNetwork.currentMcc.Free();
+    iNetwork.currentMnc.Free();
+    iNetwork.gid1.Free();
+    iNetwork.gid2.Free();
+    iNetwork.smsc.Free();
+    iNetwork.imsi.Free();
+    iNetwork.msisdn.Free();
+    iNetwork.cellId.Free();
+    iNetwork.serviceProviderName.Free();
+    iNetwork.operatorName.Free();
+    iNetwork.details.ResetAndDestroy();
+
+    iClients.ResetAndDestroy();
+    DLTRACEOUT((""));
+    }
+
+
+void CNcdRequestConfigurationData::SetNamespacePrefixL(
+    const TDesC8& aPrefix) 
+    {
+    if ( aPrefix == KNullDesC8 ) 
+        {
+        iPrefix.Free();
+        iPrefix = TXmlEngString();
+        }
+    else 
+        {
+        iPrefix.SetL(aPrefix);
+        }
+    }
+
+void CNcdRequestConfigurationData::AddCookieL(
+    MNcdConfigurationProtocolCookie* aCookie) 
+    {
+    DLTRACEIN((""));
+    iCookies.AppendL(aCookie);
+    }
+
+void CNcdRequestConfigurationData::AddQueryResponseL(
+    TNcdConfigurationQueryResponse aQueryResponse) 
+    {
+    iQueryResponses.AppendL(aQueryResponse);
+    }
+
+
+void CNcdRequestConfigurationData::AddClientL(
+    CNcdRequestConfigurationClient* aClient )
+    {
+    DLTRACEIN((""));
+    iClients.AppendL( aClient );
+    }
+
+TXmlEngElement CNcdRequestConfigurationData::GetConfigurationElementL(
+    RXmlEngDocument& aDocument)
+    {
+    DLTRACEIN((""));
+    TXmlEngElement configRoot = NcdProtocolUtils::NewElementL( aDocument, KTagConfiguration );
+    
+    TXmlEngElement network = GetNetworkConfigurationElementL( aDocument );
+    if (network.NotNull())
+        configRoot.AppendChildL(network);
+    
+    DLTRACE(("Add %d client-infos", iClients.Count() ));
+    for ( TInt i = 0; i < iClients.Count(); ++i )
+        {        
+        TXmlEngElement client = GetClientConfigurationElementL( aDocument, i );
+        if ( client.NotNull() )
+            configRoot.AppendChildL( client );
+        }
+        
+    if (configRoot.HasChildNodes())
+        {
+        DLTRACEOUT((""));
+        return configRoot;
+        }
+    DLTRACEOUT(("return null"));
+    return NULL;
+    }
+    
+    
+TXmlEngElement CNcdRequestConfigurationData::GetCookiesElementL(
+    RXmlEngDocument& aDocument)
+    {
+    DLTRACEIN((""));
+    if (iCookies.Count() == 0) 
+        {
+        DLTRACEOUT(("no cookies"));
+        return NULL;
+        }
+    
+    TXmlEngElement cookies = NcdProtocolUtils::NewElementL( aDocument, KTagCookies, iPrefix );
+    
+    for (TInt i = 0; i < iCookies.Count(); ++i)
+        {
+        MNcdConfigurationProtocolCookie* cookie = iCookies[i];
+        TXmlEngElement cookieElem = 
+            NcdProtocolUtils::NewElementL( aDocument, cookies, KTagCookie, iPrefix );
+        
+        NcdProtocolUtils::NewAttributeL( cookieElem, KAttrKey,
+            cookie->Key() );
+        
+        // These are not supposed to be sent to the server
+        /*
+        NcdProtocolUtils::NewAttributeL( cookieElem, KAttrType,
+            cookie->Type() );
+        NcdProtocolUtils::NewAttributeL( cookieElem, KAttrExpirationDelta, cookie->ExpirationDelta() );
+        NcdProtocolUtils::NewAttributeL( cookieElem, KAttrScope,
+            cookie->Scope() );
+        */
+        
+        // Add cookie values    
+        for ( TInt j = 0; j < cookie->ValueCount(); ++j ) 
+            {
+            TXmlEngElement value = 
+                NcdProtocolUtils::NewElementL( aDocument, cookieElem, KTagValue, iPrefix );    
+#ifndef RD_XML_ENGINE_API_CHANGE
+                value.SetTextL( cookie->Value(j) );
+#else
+                HBufC8* tempBuf = NcdProtocolUtils::ConvertUnicodeToUtf8L( cookie->Value(j) );
+                CleanupStack::PushL( tempBuf );
+                value.SetTextL( *tempBuf );
+                CleanupStack::PopAndDestroy( tempBuf );
+#endif
+            }
+        }
+    
+    DLTRACEOUT((""));
+    return cookies;
+    }
+
+    
+TXmlEngElement CNcdRequestConfigurationData::GetQueryResponseElementL(
+    RXmlEngDocument& aDocument)
+    {
+    DLTRACEIN((""));
+    if (iQueryResponses.Count() == 0) 
+        {
+        DLTRACEOUT(("return null"));
+        return NULL;
+        }
+        
+    TXmlEngElement queryResponse = NcdProtocolUtils::NewElementL( aDocument, KTagQueryResponse, iPrefix );
+    NcdProtocolUtils::NewAttributeL( queryResponse, KAttrId,
+        iQueryResponseId );
+    
+    for (TInt i = 0; i < iQueryResponses.Count(); ++i)
+        {
+        TNcdConfigurationQueryResponse resp = iQueryResponses[i];
+        TXmlEngElement response = NcdProtocolUtils::NewElementL( aDocument, queryResponse, KTagResponse, iPrefix );
+        NcdProtocolUtils::NewAttributeL( response, KAttrId, resp.id);
+        TXmlEngElement value = NcdProtocolUtils::NewElementL( aDocument, response, KTagValue, iPrefix );            
+#ifndef RD_XML_ENGINE_API_CHANGE
+        value.SetTextL(resp.semantics);            
+#else
+        value.SetTextL( resp.semantics.PtrC8() );
+#endif
+        }
+    
+    DLTRACEOUT((""));
+    return queryResponse;
+    }
+    
+TXmlEngElement CNcdRequestConfigurationData::GetNetworkConfigurationElementL(
+    RXmlEngDocument& aDocument)
+    {
+    DLTRACEIN(( "" ));
+    TXmlEngElement network = NcdProtocolUtils::NewElementL( aDocument, KTagNetwork );
+            
+    // network configuration
+    if ( iNetwork.mcc.NotNull() ) 
+        NcdProtocolUtils::NewAttributeL( network, KAttrMcc, iNetwork.mcc );
+    
+    if ( iNetwork.mnc.NotNull() ) 
+        NcdProtocolUtils::NewAttributeL( network, KAttrMnc, iNetwork.mnc );
+    
+    if ( iNetwork.currentMcc.NotNull() ) 
+        NcdProtocolUtils::NewAttributeL( network, KAttrCurrentMcc, iNetwork.currentMcc );
+    
+    if ( iNetwork.currentMnc.NotNull() ) 
+        NcdProtocolUtils::NewAttributeL( network, KAttrCurrentMnc, iNetwork.currentMnc );
+    
+    if ( iNetwork.gid1.NotNull() ) 
+        NcdProtocolUtils::NewAttributeL( network, KAttrGid1, iNetwork.gid1 );
+    
+    if ( iNetwork.gid2.NotNull() ) 
+        NcdProtocolUtils::NewAttributeL( network, KAttrGid2, iNetwork.gid2 );
+    
+    if ( iNetwork.smsc.NotNull() ) 
+        NcdProtocolUtils::NewAttributeL( network, KAttrSmsc, iNetwork.smsc );
+    
+    if ( iNetwork.imsi.NotNull() ) 
+        NcdProtocolUtils::NewAttributeL( network, KAttrImsi, iNetwork.imsi );
+        
+    if ( iNetwork.serviceProviderName.NotNull() ) 
+        {
+        TXmlEngElement serviceProviderName = 
+            NcdProtocolUtils::NewElementL( aDocument, network, KTagServiceProviderName, iPrefix );
+#ifndef RD_XML_ENGINE_API_CHANGE
+        serviceProviderName.SetTextL( iNetwork.serviceProviderName );
+#else
+        serviceProviderName.SetTextL( iNetwork.serviceProviderName.PtrC8() );
+#endif
+        }
+
+    if ( iNetwork.operatorName.NotNull() )
+        {
+        TXmlEngElement operatorName = 
+            NcdProtocolUtils::NewElementL( aDocument, network, KTagOperatorName, iPrefix );
+#ifndef RD_XML_ENGINE_API_CHANGE
+        operatorName.SetTextL( iNetwork.operatorName );
+#else
+        operatorName.SetTextL( iNetwork.operatorName.PtrC8() );
+#endif
+        }
+
+    if ( iNetwork.details.Count() > 0 ) 
+        {
+        TXmlEngElement details = 
+            NcdProtocolUtils::NewElementL( aDocument, network, KTagDetails, iPrefix );
+            
+        for ( TInt i = 0; i < iNetwork.details.Count(); ++i ) 
+            {
+            MNcdConfigurationProtocolDetail* det = iNetwork.details[i];
+            details.AppendChildL( GetDetailsElementL( aDocument, 
+                *det, iPrefix ) );
+            }
+        }
+
+    if (network.HasChildNodes()) 
+        {
+        DLTRACEOUT(( "" ));
+        return network;
+        }
+    DLTRACEOUT(( "return null" ));
+    return NULL;
+    }
+    
+    
+TInt CNcdRequestConfigurationData::ClientConfigurationCount() const
+    {
+    return iClients.Count();
+    }
+
+
+TXmlEngElement CNcdRequestConfigurationData::GetClientConfigurationElementL(
+    RXmlEngDocument& aDocument, TInt aIndex )
+    {
+    DLTRACEIN((""));
+    // client, required
+    TXmlEngElement client = NcdProtocolUtils::NewElementL( aDocument, KTagClient );
+
+    CNcdRequestConfigurationClient& confClient( *iClients[aIndex] );
+    
+    DLTRACE(("Adding %d software-elements", confClient.SoftwareCount() ));
+    
+    for ( TInt i = 0; i < confClient.SoftwareCount(); ++i ) 
+        {        
+        TXmlEngElement software = confClient.Software( 
+            i ).GetSoftwareConfigurationElementL( aDocument, iPrefix );
+        client.AppendChildL(software);
+        }
+    
+    DLTRACE(("Adding hardware element"));
+    TXmlEngElement hardware = 
+        confClient.Hardware().GetHardwareConfigurationElementL( aDocument, 
+        iPrefix );
+        
+    if (hardware.NotNull())
+        client.AppendChildL(hardware);
+    
+    if (client.HasChildNodes())
+        {
+        DLTRACEOUT((""));
+        return client;
+        }
+    DLTRACEOUT(("return null"));
+    return NULL;
+    }
+    
+    
+    
+void CNcdRequestConfigurationData::SetNetworkMccL( 
+    const TDesC& aMcc, const TDesC& aCurrentMcc )
+    {
+    if (aMcc != KNullDesC)
+        iNetwork.mcc.SetL(aMcc);
+    if (aCurrentMcc != KNullDesC)
+        iNetwork.currentMcc.SetL(aCurrentMcc);
+    }
+    
+void CNcdRequestConfigurationData::SetNetworkMncL( 
+    const TDesC& aMnc, const TDesC& aCurrentMnc )
+    {
+    if (aMnc != KNullDesC)
+        iNetwork.mnc.SetL(aMnc);
+    if (aCurrentMnc != KNullDesC)
+        iNetwork.currentMnc.SetL(aCurrentMnc);
+    }
+    
+void CNcdRequestConfigurationData::SetNetworkGidL( 
+    const TDesC& aGid1, const TDesC& aGid2 )
+    {
+    if (aGid1 != KNullDesC)
+        iNetwork.gid1.SetL(aGid1);
+    if (aGid2 != KNullDesC)
+        iNetwork.gid2.SetL(aGid2);
+    }
+    
+void CNcdRequestConfigurationData::SetNetworkSmscL( 
+    const TDesC& aSmsc )
+    {
+    iNetwork.smsc.SetL(aSmsc);
+    }
+    
+void CNcdRequestConfigurationData::SetNetworkImsiL( 
+    const TDesC& aImsi )
+    {
+    iNetwork.imsi.SetL(aImsi);
+    }
+    
+void CNcdRequestConfigurationData::SetNetworkMsisdnL( 
+    const TDesC& aMsisdn )
+    {
+    iNetwork.msisdn.SetL(aMsisdn);
+    }
+    
+void CNcdRequestConfigurationData::SetNetworkCellIdL( 
+    const TDesC& aCellId )
+    {
+    iNetwork.cellId.SetL(aCellId);
+    }
+    
+void CNcdRequestConfigurationData::SetNetworkProviderL( 
+    const TDesC& aServiceProviderName )
+    {
+    iNetwork.serviceProviderName.SetL(aServiceProviderName);
+    }
+    
+void CNcdRequestConfigurationData::SetNetworkOperatorL( 
+    const TDesC& aOperatorName )
+    {
+    iNetwork.operatorName.SetL(aOperatorName);
+    }
+
+void CNcdRequestConfigurationData::AddNetworkDetailsL( 
+    MNcdConfigurationProtocolDetail* aDetail )
+    {
+    iNetwork.details.AppendL(aDetail);
+    }
+
+