--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/natfw/natfwturnplugin/tsrc/ut_cnatfwturnplugin/stubs/cnatsettingsstub.cpp Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,1294 @@
+/*
+* 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:
+*
+*/
+
+
+
+
+#include "cnatsettings.h"
+//#include <unsafprotocolscrkeys.h>
+//#include "tnatportpool.h"
+#include "tnatserversettings.h"
+
+// CONSTANTS
+const TInt KDefaultUDPRefreshInterval = 28;
+const TInt KDefaultTCPRefreshInterval = 1200;
+const TInt KDefaultSTUNRetransmitTimer = 250; // milliseconds
+const TInt KDefaultTURNBandwidth = 0; // KB/s
+const TInt KDefaultRequestedTransport = 0; //UDP
+const TInt KDefaultRequestedPortProps = 0; //no specific port alignment and
+ //special behavior requested
+const TInt KDefaultTURNLifeTime = 0;
+//const TInt KDefaultTURNRetryTime = 500; //milliseconds
+const TInt KDefaultTURNServerTimerVal = 0; //milliseconds
+const TInt KDefaultTransitioningStateTime = 0; //seconds
+const TInt KDefaultICECanditateTimer = 0;
+
+const TInt KDefaultSTUNServerPort = 3478;
+const TInt KDefaultTURNServerPort = 0;
+const TInt KDefaultTCPTimeout = 1200;
+const TInt KDefaultUDPTimeout = 28;
+const TInt KDefaultConnectivityCheckTimeout = 2;
+
+const TInt KDefaultPortFieldLength = 25;
+const TInt KDefaultPortPoolStarPort = 25000;
+const TInt KDefaultPortPoolEndPort = 50000;
+
+const TInt KLatestConnectedStunServerPort = 10;
+const TInt KLatestConnectedTurnServerPort = 20;
+
+_LIT8( KStunServer, "0.0.0.0");
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::NewL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CNATFWNATSettings* CNATFWNATSettings::NewL( const TDesC8& aDomain,
+ TNATFWNATSettings aSettings)
+ {
+ CNATFWNATSettings* self = CNATFWNATSettings::NewLC(aDomain,aSettings);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::NewLC
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CNATFWNATSettings* CNATFWNATSettings::NewLC( const TDesC8& aDomain,
+ TNATFWNATSettings aSettings)
+ {
+ CNATFWNATSettings* self = new(ELeave)CNATFWNATSettings(aSettings);
+ CleanupStack::PushL(self);
+ self->ConstructL(aDomain);
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::CNATFWNATSettings
+// -----------------------------------------------------------------------------
+//
+CNATFWNATSettings::CNATFWNATSettings(TNATFWNATSettings aSettings) :
+ iSettings(aSettings)
+ {
+ iSettings = aSettings;
+ iLatestConnectedSTUNServerPort = KLatestConnectedStunServerPort;
+ iLatestConnectedTURNServerPort = KLatestConnectedTurnServerPort;
+ iUDPRefreshInterval = KDefaultUDPRefreshInterval;
+ iTCPRefreshInterval = KDefaultTCPRefreshInterval;
+ iSTUNRetransmitTimer = KDefaultSTUNRetransmitTimer;
+ iTURNBandwidth = KDefaultTURNBandwidth;
+ iRequestedTransport = KDefaultRequestedTransport;
+ iRequestedPortProps = KDefaultRequestedPortProps;
+ iTURNLifeTime = KDefaultTURNLifeTime;
+// iICECanditateTimer = KDefaultICECanditateTimer;
+ iUseSharedSecret = EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CNATFWNATSettings::ConstructL(const TDesC8& aDomain)
+ {
+ __ASSERT_ALWAYS(aDomain.Length() > 0, User::Leave(KErrArgument));
+
+// iCenRep = CRepository::NewL(KCRUidUNSAFProtocols);
+ iLatestConnectedSTUNServerAddress = KNullDesC8().AllocL();
+ iLatestConnectedTURNServerAddress = KNullDesC8().AllocL();
+ iRequestedAddress = KNullDesC8().AllocL();
+
+ iSTUNServerSettingsArray =
+ new( ELeave ) CArrayFixFlat<TNATServerSettings> ( 1 );
+ iTURNServerSettingsArray =
+ new( ELeave ) CArrayFixFlat<TNATServerSettings> ( 1 );
+
+ iDomain = aDomain.AllocL();
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::~CNATFWNATSettings
+//---------------------------------------------------------------------------
+//
+CNATFWNATSettings::~CNATFWNATSettings()
+ {
+ delete iRequestedAddress;
+ delete iDomain;
+ delete iLatestConnectedSTUNServerAddress;
+ delete iLatestConnectedTURNServerAddress;
+
+ delete iSTUNServerSettingsArray;
+ delete iTURNServerSettingsArray;
+
+/* if (iDomainKey)
+ {
+ // Remove settings added during runtime
+ if(iCenRep) iCenRep->Delete(KUNSAFProtocolsSharedSecretMask|iDomainKey);
+ }
+ if(iPortField.KeyMaskForCR() != 0)
+ {
+ // remove if added during runtime
+ iCenRep->Delete(iPortField.KeyMaskForCR()|KUNSAFProtocolsStartPortMask);
+ iCenRep->Delete(iPortField.KeyMaskForCR()|KUNSAFProtocolsEndPortMask);
+ }
+ delete iCenRep;*/
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::RetrieveIapSettings
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CNATFWNATSettings::RetrieveIapSettingsL(const TUint /*aIapId*/ )
+ {
+ //iIapId = aIapId;
+ //return ReadIapSettingsL(*iCenRep, aIapId);
+ return KErrNone;
+ }
+/*
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::UpdateL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CNATFWNATSettings::UpdateL()
+ {
+ UpdateL(iSettings);
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::UpdateL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CNATFWNATSettings::UpdateL(TNATFWNATSettings aSettings)
+ {
+ TInt err = ReadDomainSettingsKeyL(*iCenRep, *iDomain, iDomainKey);
+ if(err == KErrNone)
+ {
+ if((aSettings&ESTUNSettings) == ESTUNSettings)
+ {
+ ReadSTUNSettingsL(*iCenRep, iDomainKey);
+ }
+ if((aSettings&ETURNSettings) == ETURNSettings)
+ {
+ ReadTURNSettingsL(*iCenRep, iDomainKey);
+ }
+ if((aSettings&EICESettings) == EICESettings)
+ {
+ ReadICESettings(*iCenRep, iDomainKey);
+ }
+ if((aSettings&ESTUNSettings) == ESTUNSettings ||
+ (aSettings&ETURNSettings) == ETURNSettings)
+ {
+ ReadGeneralSettingsL(*iCenRep, iDomainKey);
+ }
+ }
+ ReadIapSettingsL(*iCenRep,iIapId);
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::IapId
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint32 CNATFWNATSettings::IapId() const
+ {
+ return iIapId;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::Domain
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CNATFWNATSettings::Domain() const
+ {
+ return *iDomain;
+ }*/
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::GetSTUNServerArrayL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CArrayFix<TNATServerSettings>*
+ CNATFWNATSettings::GetSTUNServerArrayL() const
+ {
+ CArrayFix<TNATServerSettings>* StunServerSettingsArray =
+ new( ELeave ) CArrayFixFlat<TNATServerSettings> ( 1 );
+ TInt count = iSTUNServerSettingsArray->Count();
+
+ for ( TInt i(0); i < count; i++ )
+ {
+ StunServerSettingsArray->AppendL( iSTUNServerSettingsArray->At( i ) );
+ }
+
+ return StunServerSettingsArray;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::GetTURNServerArrayL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CArrayFix<TNATServerSettings>*
+ CNATFWNATSettings::GetTURNServerArrayL() const
+ {
+ CArrayFix<TNATServerSettings>* TURNServerSettingsArray =
+ new( ELeave ) CArrayFixFlat<TNATServerSettings> ( 1 );
+ TInt count = iTURNServerSettingsArray->Count();
+
+ for ( TInt i(0); i < count; i++ )
+ {
+ TURNServerSettingsArray->AppendL( iTURNServerSettingsArray->At( i ) );
+ }
+
+ return TURNServerSettingsArray;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::LatestConnectedSTUNServerAddress
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CNATFWNATSettings::LatestConnectedSTUNServerAddress() const
+ {
+ return *iLatestConnectedSTUNServerAddress;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::LatestConnectedSTUNServerPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::LatestConnectedSTUNServerPort() const
+ {
+ return iLatestConnectedSTUNServerPort;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::LatestConnectedTURNServerAddress
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CNATFWNATSettings::LatestConnectedTURNServerAddress() const
+ {
+ return *iLatestConnectedTURNServerAddress;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::LatestConnectedTURNServerPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::LatestConnectedTURNServerPort() const
+ {
+ return iLatestConnectedTURNServerPort;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::UDPRefreshInterval
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CNATFWNATSettings::UDPRefreshInterval() const
+ {
+ return iUDPRefreshInterval;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::TCPRefreshInterval
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CNATFWNATSettings::TCPRefreshInterval() const
+ {
+ return iTCPRefreshInterval;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::STUNRetransmitTimer
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CNATFWNATSettings::STUNRetransmitTimer() const
+ {
+ return iSTUNRetransmitTimer;
+ }
+/*
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::CRLFRefreshEnabledToProxy
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CNATFWNATSettings::CRLFRefreshEnabledToProxy() const
+ {
+ return iCRLFRefreshEnabled;
+ }
+*/
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::SharedSecretNotSupported
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CNATFWNATSettings::UseSharedSecret() const
+ {
+ return iUseSharedSecret;
+ }
+/*
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::BindingRequestFailed
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CNATFWNATSettings::BindingRequestFailed() const
+ {
+ return iBindingRequestFailed;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::STUNUsed
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CNATFWNATSettings::STUNUsed() const
+ {
+ return iSTUNUsed;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::TURNUsed
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CNATFWNATSettings::TURNUsed() const
+ {
+ return iTURNUsed;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ICEUsed
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CNATFWNATSettings::ICEUsed() const
+ {
+ return iOfferICE;
+ }
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::TURNBandwidth
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::TURNBandwidth() const
+ {
+ return iTURNBandwidth;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::RequestedTransport
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::RequestedTransport() const
+ {
+ return iRequestedTransport;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::RequestedIPAddress
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CNATFWNATSettings::RequestedAddress() const
+ {
+ return *iRequestedAddress;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::RequestedPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::RequestedPort() const
+ {
+ return iRequestedPort;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::RequestedPortProps
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::RequestedPortProps() const
+ {
+ return iRequestedPortProps;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::TURNLifetime
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::TURNLifetime() const
+ {
+ return iTURNLifeTime;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::TURNRequestRetryTime
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::TURNRequestRetryTime() const
+ {
+ return iTURNRetryTime;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::TURNServerTimerVal
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::TURNServerTimerVal() const
+ {
+ return iTURNServerTimerVal;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::TransitioningStateTime
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::TransitioningStateTime() const
+ {
+ return iTransitioningStateTime;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::SharedSecret
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CNATFWNATSettings::SharedSecret() const
+ {
+ return *iSharedSecret;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ActiveDestinationAddress
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CNATFWNATSettings::ActiveDestinationAddress() const
+ {
+ return *iActiveDestinationAddress;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ActiveDestinationPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::ActiveDestinationPort() const
+ {
+ return iActiveDestinationPort;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::RelayedTransportAddress
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CNATFWNATSettings::RelayedTransportAddress() const
+ {
+ return *iRelayedAddress;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::RelayedTransportPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::RelayedTransportPort() const
+ {
+ return iRelayedPort;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReflexiveTransportAddress
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC8& CNATFWNATSettings::ReflexiveTransportAddress() const
+ {
+ return *iReflexiveAddress;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReflexiveTransportPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::ReflexiveTransportPort() const
+ {
+ return iReflexivePort;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::TransitioningStateTimer
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::TransitioningStateTimer() const
+ {
+ return iTransitioningStateTime;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::SetSharedSecretL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CNATFWNATSettings::SetSharedSecretL(const TDesC8& aValue)
+ {
+ WriteL(KUNSAFProtocolsSharedSecretMask|iDomainKey,aValue);
+ if(iSharedSecret)
+ {
+ delete iSharedSecret;
+ iSharedSecret = 0;
+ }
+ iSharedSecret = aValue.AllocL();
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::PlugInParams
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TNATFWPlugInParams CNATFWNATSettings::PlugInParams() const
+ {
+ return iPlugInParams;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::UsedNATProtocol
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CNATFWNATSettings::UsedNATProtocol() const
+ {
+ return iUsedNATProtocol;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::GetPortAreaL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CNATFWNATSettings::GetPortAreaL(TUint& aStartPort, TUint& aEndPort)
+ {
+ TUint portpoolStart;
+ TUint portpoolEnd;
+ TUint portFieldLength;
+
+ if(iPortField.KeyMaskForCR() == 0)
+ {
+ //read port pool settings
+ if(Read(*iCenRep, KUNSAFProtocolsPortPoolStartPortMask|iDomainKey, portpoolStart)==EFalse)
+ {
+ portpoolStart = KDefaultPortPoolStarPort;
+ }
+ if(Read(*iCenRep, KUNSAFProtocolsPortPoolEndPortMask|iDomainKey, portpoolEnd)==EFalse)
+ {
+ portpoolEnd = KDefaultPortPoolEndPort;
+ }
+ if(Read(*iCenRep, KUNSAFProtocolsPortFieldLengthMask|iDomainKey, portFieldLength)==EFalse)
+ {
+ portFieldLength = KDefaultPortFieldLength;
+ }
+ TNATPortPool portPool(portpoolStart, portpoolEnd);
+ iPortField.SetLength(portFieldLength);
+
+ //read reserved port fields to PortPool
+ RArray<TUint32> keys;
+ CleanupClosePushL(keys);
+ TInt error = iCenRep->FindL(KUNSAFProtocolsStartPortMask,
+ KUNSAFProtocolsPortFieldFieldTypeMask,
+ keys);
+ TUint keyCount = keys.Count();
+
+ if (error == KErrNone && keyCount > 0)
+ {
+ for(TUint i=0; i<keyCount; i++)
+ {
+ TUint32 key = keys[i]^KUNSAFProtocolsStartPortMask;
+ TUint start = 0;
+ TUint end = 0;
+ //Start port
+ Read(*iCenRep, KUNSAFProtocolsStartPortMask|key, start);
+ //End port
+ Read(*iCenRep, KUNSAFProtocolsEndPortMask|key, end);
+
+ TNATPortField field;
+ field.SetStartPort(start);
+ field.SetEndPort(end);
+
+ User::LeaveIfError(portPool.AppendPortField(field));
+ }
+ }
+ else if(error != KErrNotFound)
+ {
+ User::LeaveIfError(error);
+ }
+ CleanupStack::PopAndDestroy(&keys);
+
+ //reserve port field
+ if(portPool.ReserveNewPortArea(iPortField))
+ {
+ //new key
+ TUint32 newKey = CreateNewKeyL(*iCenRep,
+ KUNSAFProtocolsStartPortMask,
+ KUNSAFProtocolsPortFieldFieldTypeMask);
+ //write to cr
+ WriteL(KUNSAFProtocolsStartPortMask|newKey, iPortField.StartPort());
+ WriteL(KUNSAFProtocolsEndPortMask|newKey, iPortField.EndPort());
+ iPortField.SetKeyMask(newKey);
+ }
+ else
+ {
+ User::Leave(KErrOverflow );
+ }
+ }
+ aStartPort = iPortField.StartPort();
+ aEndPort = iPortField.EndPort();
+ }
+
+// Private Functions
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReadDomainSettingsKeyL
+// -----------------------------------------------------------------------------
+//
+TInt CNATFWNATSettings::ReadDomainSettingsKeyL(
+ CRepository& aRepository,
+ const TDesC8& aDomain,
+ TUint32& aDomainKey)
+ {
+ RArray<TUint32> keys;
+ CleanupClosePushL(keys);
+ TInt err = aRepository.FindEqL( KUNSAFProtocolsDomainMask,
+ KUNSAFProtocolsFieldTypeMask,
+ aDomain,
+ keys);
+ TInt count = keys.Count();
+ if (err == KErrNone && count == 1)
+ {
+ aDomainKey = (KUNSAFProtocolsDomainMask^(keys[0]));
+ }
+ if(count > 1)
+ {
+ err = KErrCorrupt;
+ }
+ CleanupStack::PopAndDestroy(&keys);
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReadGeneralSettingsL
+// -----------------------------------------------------------------------------
+//
+void CNATFWNATSettings::ReadGeneralSettingsL(
+ CRepository& aRepository,
+ TUint32 aDomainKey)
+{
+ HBufC8* tempBuf = NULL;
+
+ //Plug-in params
+ RArray<TUint32> plugInkeys;
+ CleanupClosePushL(plugInkeys);
+ TInt error = aRepository.FindL(KUNSAFProtocolsPlugInIdMask|aDomainKey,
+ KUNSAFProtocolsSubTableFieldTypeMask,
+ plugInkeys);
+ TUint keyCount = plugInkeys.Count();
+ if (error == KErrNone && keyCount > 0)
+ {
+ for(TUint i=0; i<keyCount; i++)
+ {
+ TUint32 key = plugInkeys[i]^KUNSAFProtocolsPlugInIdMask;
+ //Plug-in id
+ if(Read(aRepository, KUNSAFProtocolsPlugInIdMask|key, iPlugInParams.iPlugInId))
+ {
+ iPlugInParams.iPlugInId = 0;
+ }
+ //Plug-in service id
+ if(Read(aRepository,
+ KUNSAFProtocolsPlugInServiceIdMask|key,
+ iPlugInParams.iPlugInServiceId))
+ {
+ iPlugInParams.iPlugInServiceId = 0;
+ }
+ }
+ }
+ else if(error == KErrNotFound)
+ {
+ iPlugInParams.iPlugInId = 0;
+ iPlugInParams.iPlugInServiceId = 0;
+ }
+ else
+ {
+ User::LeaveIfError(error);
+ }
+ CleanupStack::PopAndDestroy(&plugInkeys);
+
+
+ // TURNUsed
+ ReadBoolValue(aRepository,
+ KUNSAFProtocolsTURNUsedMask|aDomainKey,
+ iTURNUsed);
+ // STUNUsed
+ ReadBoolValue(aRepository,
+ KUNSAFProtocolsSTUNUsedMask|aDomainKey,
+ iSTUNUsed);
+ // OfferIce
+ ReadBoolValue(aRepository,
+ KUNSAFProtocolsOfferICEMask|aDomainKey,
+ iOfferICE);
+
+ // Shared secret support
+ ReadBoolValue(aRepository,
+ KUNSAFProtocolsDomainSharedSecretNotSupportedMask|aDomainKey,
+ iSharedSecretNotSupported);
+ // Latest binding request status
+ ReadBoolValue(aRepository,
+ KUNSAFProtocolsDomainBindingRequestFailedMask|aDomainKey,
+ iBindingRequestFailed);
+ // Shared secret
+ if(ReadL(aRepository, KUNSAFProtocolsSharedSecretMask|aDomainKey, &tempBuf))
+ {
+ if(iSharedSecret) delete iSharedSecret;
+ iSharedSecret = tempBuf;
+ }
+ else{ delete tempBuf; }
+}
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReadServerSettingsL
+// -----------------------------------------------------------------------------
+//
+void CNATFWNATSettings::ReadServerSettingsL(
+ CRepository& aRepository,
+ const TUint32 aServerKeyMask,
+ TServerSettings aDefaultSettings,
+ RPointerArray<CNATServerSettings>& aServerSettingsArray )
+ {
+ RArray<TUint32> serverKeys;
+ CleanupClosePushL(serverKeys);
+ aServerSettingsArray.ResetAndDestroy();
+ TServerSettings settings;
+
+ //finding server keys by using address
+ TInt error = aRepository.FindL(
+ KUNSAFProtocolsSTUNAddressMask^KUNSAFProtocolsSTUNServerTableMask|aServerKeyMask,
+ KUNSAFProtocolsSubTableFieldTypeMask,
+ serverKeys);
+ //read server settings
+ TUint keyCount = serverKeys.Count();
+ if (error == KErrNone && keyCount > 0)
+ {
+ for(TUint i=0; i<keyCount; i++)
+ {
+ HBufC8* address = NULL;
+ //address
+ ReadL(
+ aRepository,
+ KUNSAFProtocolsSTUNAddressMask^KUNSAFProtocolsSTUNServerTableMask|serverKeys[i],
+ &address);
+ //port
+ if(Read(
+ aRepository,
+ KUNSAFProtocolsSTUNPortMask^KUNSAFProtocolsSTUNServerTableMask|serverKeys[i],
+ settings.iPort) == EFalse)
+ {
+ settings.iPort = aDefaultSettings.iPort;
+ }
+ //TCPTimeout
+ if(Read(
+ aRepository,
+ KUNSAFProtocolsSTNUTCPTimeoutMask^KUNSAFProtocolsSTUNServerTableMask|serverKeys[i],
+ settings.iTCPTimeout) == EFalse)
+ {
+ settings.iTCPTimeout = aDefaultSettings.iTCPTimeout;
+ }
+ //UDPTimeout
+ if(Read(
+ aRepository,
+ KUNSAFProtocolsSTUNUDPTimeoutMask^KUNSAFProtocolsSTUNServerTableMask|serverKeys[i],
+ settings.iUDPTimeout) == EFalse)
+ {
+ settings.iUDPTimeout = aDefaultSettings.iUDPTimeout;
+ }
+ //ConnectivityCheckTimeout
+ if(Read(
+ aRepository,
+ KUNSAFProtocolsSTUNConnectivityCheckTimeoutMask^KUNSAFProtocolsSTUNServerTableMask|
+ serverKeys[i],
+ settings.iConnectivityCheckTimeout) == EFalse)
+ {
+ settings.iConnectivityCheckTimeout = aDefaultSettings.iConnectivityCheckTimeout;
+ }
+ //CRLFRefreshEnabled
+ if(ReadBoolValue(
+ aRepository,
+ KUNSAFProtocolsSTUNEnableCRLFRefreshMask^KUNSAFProtocolsSTUNServerTableMask|
+ serverKeys[i],
+ settings.iCRLFRefreshEnabled) == EFalse)
+ {
+ settings.iCRLFRefreshEnabled = aDefaultSettings.iCRLFRefreshEnabled;
+ }
+
+ CNATServerSettings* serverSettings = CNATServerSettings::NewLC(
+ *address,
+ settings.iPort,
+ settings.iTCPTimeout,
+ settings.iUDPTimeout,
+ settings.iConnectivityCheckTimeout,
+ settings.iCRLFRefreshEnabled
+ );
+ aServerSettingsArray.AppendL(serverSettings);
+ CleanupStack::Pop(serverSettings);
+ delete address;
+ }
+ }
+ else if(error != KErrNotFound)
+ {
+ User::Leave(error);
+ }
+ CleanupStack::PopAndDestroy(&serverKeys);
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReadSTUNSettingsL
+// -----------------------------------------------------------------------------
+//
+void CNATFWNATSettings::ReadSTUNSettingsL(
+ CRepository& aRepository,
+ TUint32 aDomainKey)
+{
+ RArray<TUint32> addressKeys;
+ HBufC8* tempBufPointer = NULL;
+ CleanupClosePushL(addressKeys);
+
+ // STUN Servers
+ TServerSettings stunSettings;
+ stunSettings.iPort = KDefaultSTUNServerPort;
+ stunSettings.iTCPTimeout = KDefaultTCPTimeout;
+ stunSettings.iUDPTimeout = KDefaultUDPTimeout;
+ stunSettings.iConnectivityCheckTimeout = KDefaultConnectivityCheckTimeout;
+ stunSettings.iCRLFRefreshEnabled = EFalse;
+
+ ReadServerSettingsL(
+ aRepository,
+ KUNSAFProtocolsSTUNServerTableMask|aDomainKey,
+ stunSettings,
+ iSTUNServerSettingsArray
+ );
+
+ //LatestConnectedStunServerAddress
+ if(ReadL(aRepository,
+ KUNSAFProtocolsLatestConnectedSTUNServerAddressMask|aDomainKey,
+ &tempBufPointer))
+ {
+ if(iLatestConnectedSTUNServerAddress) delete iLatestConnectedSTUNServerAddress;
+ iLatestConnectedSTUNServerAddress = tempBufPointer;
+ }
+ else{ delete tempBufPointer; }
+ //LatestConnectedStunServerPort
+ if(Read(aRepository, KUNSAFProtocolsLatestConnectedSTUNServerPortMask|aDomainKey,
+ iLatestConnectedSTUNServerPort)==EFalse)
+ {
+ iLatestConnectedSTUNServerPort = 0;
+ }
+ // STUN retransmit timer
+ if(Read(aRepository,
+ KUNSAFProtocolsSTUNRetransmitTimerMask|aDomainKey,
+ iSTUNRetransmitTimer)==EFalse)
+ {
+ iSTUNRetransmitTimer = KDefaultSTUNRetransmitTimer;
+ }
+ else
+ {
+ }
+ CleanupStack::PopAndDestroy(&addressKeys);
+}
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReadTURNSettingsL
+// -----------------------------------------------------------------------------
+//
+void CNATFWNATSettings::ReadTURNSettingsL(
+ CRepository& aRepository,
+ TUint32 aDomainKey)
+{
+ RArray<TUint32> addressKeys;
+ HBufC8* tempBufPointer = NULL;
+ CleanupClosePushL(addressKeys);
+
+ //TURN Servers
+ TServerSettings turnSettings;
+ turnSettings.iPort = KDefaultTURNServerPort;
+ turnSettings.iTCPTimeout = KDefaultTCPTimeout;
+ turnSettings.iUDPTimeout = KDefaultUDPTimeout;
+ turnSettings.iConnectivityCheckTimeout = KDefaultConnectivityCheckTimeout;
+ turnSettings.iCRLFRefreshEnabled = EFalse;
+
+
+ ReadServerSettingsL(
+ aRepository,
+ KUNSAFProtocolsTURNServerTableMask|aDomainKey,
+ turnSettings,
+ iTURNServerSettingsArray
+ );
+
+ //TURNBandwidth
+ if(Read(aRepository,
+ KUNSAFProtocolsTURNBandwidthMask|aDomainKey, iTURNBandwidth)==EFalse)
+ {
+ iTURNBandwidth = KDefaultTURNBandwidth;
+ }
+ //RequestedTransport
+ if(Read(aRepository, KUNSAFProtocolsRequestedTransportMask|aDomainKey,
+ iRequestedTransport)==EFalse)
+ {
+ iRequestedTransport = KDefaultRequestedTransport;
+ }
+ //RequestedPortProps
+ if(Read(aRepository, KUNSAFProtocolsRequestedPortPropsMask|aDomainKey,
+ iRequestedPortProps)==EFalse)
+ {
+ iRequestedPortProps = KDefaultRequestedPortProps;
+ }
+ //TURNLifeTime
+ if(Read(aRepository,
+ KUNSAFProtocolsTURNLifeTimeMask|aDomainKey, iTURNLifeTime)==EFalse)
+ {
+ iTURNLifeTime = KDefaultTURNLifeTime;
+ }
+ //TURNRetryTime
+ if (Read(aRepository,
+ KUNSAFProtocolsTURNRetryTimeMask|aDomainKey, iTURNRetryTime)==EFalse)
+ {
+ iTURNRetryTime = KDefaultTURNRetryTime;
+ }
+ //TURNServerTimerVal
+ if(Read(aRepository, KUNSAFProtocolsTURNServerTimerValMask|aDomainKey,
+ iTURNServerTimerVal)==EFalse)
+ {
+ iTURNServerTimerVal = KDefaultTURNServerTimerVal;
+ }
+ //TransitioningStateTime
+ if(Read(aRepository, KUNSAFProtocolsTransitioningStateTimeMask|aDomainKey,
+ iTransitioningStateTime)==EFalse)
+ {
+ iTransitioningStateTime = KDefaultTransitioningStateTime;
+ }
+ //RequestedAddress
+ if(ReadL(aRepository,
+ KUNSAFProtocolsRequestedAdressMask|aDomainKey, &tempBufPointer))
+ {
+ if(iRequestedAddress) delete iRequestedAddress;
+ iRequestedAddress = tempBufPointer;
+ }
+ else{ delete tempBufPointer; }
+ //RequestedPort
+ if(Read(aRepository,
+ KUNSAFProtocolsRequestedPortMask|aDomainKey, iRequestedPort)==EFalse)
+ {
+ iRequestedPort = 0;
+ }
+ //ActiveDestinationAddress
+ if(ReadL(aRepository,
+ KUNSAFProtocolsActiveDestinationAddressMask|aDomainKey, &tempBufPointer))
+ {
+ if(iActiveDestinationAddress) delete iActiveDestinationAddress;
+ iActiveDestinationAddress = tempBufPointer;
+ }
+ else{ delete tempBufPointer; }
+ //ActiveDestinationPort
+ if (Read(aRepository,
+ KUNSAFProtocolsActiveDestinationPortMask|aDomainKey,
+ iActiveDestinationPort)==EFalse)
+ {
+ iActiveDestinationPort = 0;
+ }
+ //RelayedAddress
+ if(ReadL(aRepository, KUNSAFProtocolsRelayedAddressMask|aDomainKey, &tempBufPointer))
+ {
+ if(iRelayedAddress) delete iRelayedAddress;
+ iRelayedAddress = tempBufPointer;
+ }
+ else{ delete tempBufPointer; }
+ //RelayedPort
+ if(Read(aRepository, KUNSAFProtocolsRelayedPortMask|aDomainKey, iRelayedPort)==EFalse)
+ {
+ iRelayedPort = 0;
+ }
+ //ReflexiveAddress
+ if(ReadL(aRepository, KUNSAFProtocolsReflexiveAddressMask|aDomainKey, &tempBufPointer))
+ {
+ if(iReflexiveAddress) delete iReflexiveAddress;
+ iReflexiveAddress = tempBufPointer;
+ }
+ else{ delete tempBufPointer; }
+ //ReflexivePort
+ if(Read(aRepository, KUNSAFProtocolsReflexivePorMask|aDomainKey, iReflexivePort)==EFalse)
+ {
+ iReflexivePort = 0;
+ }
+ //LatestConnectedTURNServerAddress
+ if(ReadL(aRepository,
+ KUNSAFProtocolsLatestConnectedTURNServerAddressMask|aDomainKey,
+ &tempBufPointer))
+ {
+ if(iLatestConnectedTURNServerAddress) delete iLatestConnectedTURNServerAddress;
+ iLatestConnectedTURNServerAddress = tempBufPointer;
+ }
+ else{ delete tempBufPointer; }
+ //LatestConnectedTURNServerPort
+ if(Read(aRepository, KUNSAFProtocolsLatestConnectedTURNServerPortMask|aDomainKey,
+ iLatestConnectedTURNServerPort)==EFalse)
+ {
+ iLatestConnectedTURNServerPort = 0;
+ }
+ else
+ {
+ }
+ CleanupStack::PopAndDestroy(&addressKeys);
+}
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReadICESettingsL
+// -----------------------------------------------------------------------------
+//
+void CNATFWNATSettings::ReadICESettings(
+ CRepository& aRepository,
+ TUint32 aDomainKey)
+ {
+ // ICEMode setting
+ ReadBoolValue(aRepository,KUNSAFProtocolsICEFullModeUsedMask|aDomainKey,
+ iICEFullModeUsed);
+ // ChooseAnotherCandidateTimer
+ if(Read(aRepository,
+ KUNSAFProtocolsICECandidateTimerMask|aDomainKey, iICECanditateTimer)==EFalse)
+ {
+ iICECanditateTimer = KDefaultICECanditateTimer;
+ }
+ //UsedNATProtocol
+ if(Read(aRepository,
+ KUNSAFProtocolsUsedNATProtocolMask|aDomainKey, iUsedNATProtocol)==EFalse)
+ {
+ iUsedNATProtocol = KDefaultUsedNATProtocol;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReadIapSettingsL
+// -----------------------------------------------------------------------------
+//
+TInt CNATFWNATSettings::ReadIapSettingsL(
+ CRepository& aRepository,
+ TUint32 aIapId)
+ {
+ RArray<TUint32> keys;
+ CleanupClosePushL(keys);
+ TInt err = aRepository.FindEqL(KUNSAFProtocolsIAPIdMask,
+ KUNSAFProtocolsFieldTypeMask,
+ static_cast<TInt>(aIapId),
+ keys);
+
+ if (err == KErrNone)
+ {
+ if(keys.Count() > 1)
+ {
+ err = KErrCorrupt;
+ }
+ else
+ {
+ TUint32 key = (KUNSAFProtocolsIAPIdMask^(keys[0]));
+ key |= KUNSAFProtocolsIAPTableMask;
+ // read UDP refresh interval
+ Read(aRepository,KUNSAFProtocolsIntervalUDPMask|key,
+ iUDPRefreshInterval);
+ // read TCP refresh interval
+ Read(aRepository,KUNSAFProtocolsIntervalTCPMask|key,
+ iTCPRefreshInterval);
+ // read Retransmit interval
+ Read(aRepository,KUNSAFProtocolsSTUNRetransmitTimerMask|key,
+ iSTUNRetransmitTimer);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&keys);
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::Read
+// -----------------------------------------------------------------------------
+//
+TBool CNATFWNATSettings::ReadL(
+ CRepository& aRepository,
+ const TUint32& aKey,
+ HBufC8** aBuf)
+ {
+ TBool found = EFalse;
+ TBuf8<1> tmp;
+ TInt actualLength = 0;
+ TInt status = aRepository.Get(aKey,tmp,actualLength);
+
+ if ((status == KErrNone || status == KErrOverflow) && (actualLength > 0))
+ {
+ found = ETrue;
+ HBufC8* buf = HBufC8::NewL(actualLength);
+ CleanupStack::PushL(buf);
+ TPtr8 ptr(buf->Des());
+ User::LeaveIfError(aRepository.Get(aKey,ptr));
+ *aBuf = buf;
+ CleanupStack::Pop(buf);
+ }
+ else
+ {
+ *aBuf = KNullDesC8().AllocL();
+ }
+ return found;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::ReadBoolValue
+// -----------------------------------------------------------------------------
+//
+TBool CNATFWNATSettings::ReadBoolValue(
+ CRepository& aRepository,
+ const TUint32& aKey,
+ TBool& aKeyValue)
+ {
+ TBool found = EFalse;
+ TInt tmp = 0;
+ if (aRepository.Get(aKey,tmp) == KErrNone)
+ {
+ aKeyValue = (tmp != 0);
+ found = ETrue;
+ }
+ return found;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::Read
+// -----------------------------------------------------------------------------
+//
+TBool CNATFWNATSettings::Read(
+ CRepository& aRepository,
+ const TUint32& aKey,
+ TUint& aKeyValue)
+ {
+ TBool found = EFalse;
+ TInt tmp;
+ if (aRepository.Get(aKey,tmp) == KErrNone)
+ {
+ aKeyValue = static_cast<TUint>(tmp);
+ found = ETrue;
+ }
+ return found;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::CreateNewKeyL
+// -----------------------------------------------------------------------------
+//
+TUint32 CNATFWNATSettings::CreateNewKeyL(
+ CRepository& aRepository,
+ const TUint32 aSettingKeyMask,
+ const TUint32 aField) const
+ {
+ TUint32 newKey = 0;
+ RArray<TUint32> keys;
+ CleanupClosePushL( keys );
+ TInt err = aRepository.FindL( aSettingKeyMask,
+ aField,
+ keys );
+ TInt keyCount = keys.Count();
+
+ if ( err == KErrNotFound )
+ {
+ newKey = aField+1;
+ }
+ else
+ {
+ User::LeaveIfError( err );
+ if ( keyCount == 0 )
+ {
+ newKey = aField+1;
+ }
+ else
+ {
+ // Find the biggest key and increment it by one
+ keys.SortUnsigned();
+ TUint32 maxKey = aSettingKeyMask^keys[ keyCount - 1 ];
+ newKey = aField + 1 + maxKey;
+ }
+ }
+ newKey |= aField;
+ newKey ^= aField;
+ CleanupStack::PopAndDestroy( &keys );
+ return newKey;
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::WriteL
+// -----------------------------------------------------------------------------
+//
+void CNATFWNATSettings::WriteL(
+ TUint32 aFieldMask,
+ TInt aValue)
+ {
+ User::LeaveIfError(
+ iCenRep->StartTransaction(
+ CRepository::EConcurrentReadWriteTransaction));
+ iCenRep->CleanupCancelTransactionPushL();
+
+ TInt tmp = 0;
+ if (iCenRep->Get(aFieldMask,tmp) == KErrNone)
+ {
+ // Update existing value
+ User::LeaveIfError(iCenRep->Set(aFieldMask,aValue));
+ }
+ else
+ {
+ // Create new value
+ User::LeaveIfError(iCenRep->Create(aFieldMask,aValue));
+ }
+ TUint32 dummy;
+ User::LeaveIfError(iCenRep->CommitTransaction(dummy));
+ CleanupStack::Pop(); // transaction
+ }
+
+// -----------------------------------------------------------------------------
+// CNATFWNATSettings::WriteL
+// -----------------------------------------------------------------------------
+//
+void CNATFWNATSettings::WriteL(
+ TUint32 aFieldMask,
+ const TDesC8& aValue)
+ {
+ if(aFieldMask == KUNSAFProtocolsDomainMask)
+ {
+ User::Leave(KErrArgument);
+ }
+ User::LeaveIfError(
+ iCenRep->StartTransaction(
+ CRepository::EConcurrentReadWriteTransaction));
+
+ iCenRep->CleanupCancelTransactionPushL();
+
+ TBuf8<1> tmp;
+ TInt err = iCenRep->Get(aFieldMask,tmp);
+ if ( err == KErrNone || err == KErrOverflow)
+ {
+ // Update existing value
+ User::LeaveIfError(iCenRep->Set(aFieldMask,aValue));
+ }
+ else
+ {
+ // Create new value
+ User::LeaveIfError(iCenRep->Create(aFieldMask,aValue));
+ }
+ TUint32 dummy;
+ User::LeaveIfError(iCenRep->CommitTransaction(dummy));
+ CleanupStack::Pop(); // transaction
+ }*/
+
+// -----------------------------------------------------------------------------
+// TNATPortField::TNATPortField
+// -----------------------------------------------------------------------------
+//
+/*
+TNATPortField::TNATPortField()
+ {
+ iCRKeyMask = 0;
+ iLength = 0;
+ iStartPort = 0;
+ iEndPort = 0;
+ }
+*/
+//End of file