diff -r 000000000000 -r f5a58ecadc66 upnp/upnpstack/serviceframework/src/upnpargument.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/upnp/upnpstack/serviceframework/src/upnpargument.cpp Tue Feb 02 01:12:20 2010 +0200 @@ -0,0 +1,465 @@ +/** @file +* Copyright (c) 2005-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: Defines the CUpnpargument class +* +*/ + + +// INCLUDE FILES + +#include +#include "upnpargument.h" +#include "upnpservice.h" +#include "upnpstring.h" +#define KLogFile _L("UPnPStack.txt") +#include "upnpcustomlog.h" + +// logs +#include "f32file.h" +#include "s32file.h" + + + + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CUpnpArgument::CUpnpArgument +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CUpnpArgument::CUpnpArgument( CUpnpService& aParentService ) +: iParentService( aParentService ) +{ + +} + +void CUpnpArgument::ConstructL() + { + iName = HBufC8::NewL(0); + iValue = HBufC8::NewL(0); + iRelatedStateVariable = HBufC8::NewL(0); + } + + +// ----------------------------------------------------------------------------- +// CUpnpArgument::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +//. +void CUpnpArgument::ConstructL( CUpnpArgument& aArgument ) +{ + + + iName = aArgument.Name().AllocL(); + + iValue = HBufC8::NewL(0); + + iDirection = aArgument.Direction(); + + iRelatedStateVariable = aArgument.RelatedStateVariable().AllocL(); + + + CUpnpStateVariable* var = iParentService.StateVariable( *iRelatedStateVariable ); + + if ( var ) + { + iType = var->Type(); + } + else + { + iType = EUndefined; + } +} + +// ----------------------------------------------------------------------------- +// CUpnpArgument::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CUpnpArgument* CUpnpArgument::NewL( CUpnpService& aParentService ) + { + CUpnpArgument* self = new(ELeave) CUpnpArgument(aParentService); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CUpnpArgument::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CUpnpArgument* CUpnpArgument::NewL( CUpnpArgument& aArgument, + CUpnpService& aParentService ) +{ + CUpnpArgument* self = new (ELeave) CUpnpArgument( aParentService ); + CleanupStack::PushL( self ); + self->ConstructL( aArgument ); + CleanupStack::Pop( self ); + + return self; +} + +// ----------------------------------------------------------------------------- +// CUpnpArgument::~CUpnpArgument +// Destructor +// ----------------------------------------------------------------------------- +// +CUpnpArgument::~CUpnpArgument() +{ + delete iName; + delete iValue; + delete iRelatedStateVariable; +} + +// ----------------------------------------------------------------------------- +// CUpnpArgument::Name +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TDesC8& CUpnpArgument::Name() +{ + return *iName; +} + +void CUpnpArgument::SetNameL(const TDesC8& aName) + { + HBufC8* tmp = aName.AllocL(); + delete iName; + iName = tmp; + } +// ----------------------------------------------------------------------------- +// CUpnpArgument::SetValueL +// If the value is inproper, the method leaves with EInvalidArgs, +// which is the internal upnp error code used by UPnP Stack +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void CUpnpArgument::SetValueL( const TDesC8& aValue ) +{ + LOGS("CUpnpArgument::SetValueL(TDesC8&) [Name/Value]"); + + + // Dates, times, URIs and UUIDs are not validated to save process time. + // These must be validated if used in actual service, + // which uses these arguments. + TArgumentType type = Type(); + LOGS1( "type: %i", type ); + TLex8 lex(aValue); + switch ( type ) + { + + case EUi1: + { + TUint8 tryVal; + CheckErrorL( ( lex.Val(tryVal, EDecimal) ), aValue ); + break; + } + case EUi2: + { + TUint16 tryVal; + CheckErrorL ( lex.Val(tryVal, EDecimal), aValue ); + break; + } + case EUi4: + { + TUint32 tryVal; + CheckErrorL( lex.Val(tryVal, EDecimal), aValue ); + break; + } + case EI1: + { + TInt8 tryVal; + CheckErrorL( lex.Val(tryVal), aValue ); + break; + } + case EI2: + { + TInt16 tryVal; + CheckErrorL( lex.Val(tryVal), aValue ); + break; + } + case EI4: + { + TInt32 tryVal; + CheckErrorL( lex.Val(tryVal), aValue ); + break; + } + case EInt: + { + TInt64 tryVal; + CheckErrorL( lex.Val(tryVal), aValue ); + break; + } + case ER4: + { + TReal32 tryVal; + CheckErrorL( lex.Val(tryVal), aValue ); + break; + } + case ER8: + case EFloat: + case ENumber: + { + TReal64 tryVal; + CheckErrorL( ( lex.Val(tryVal) ), aValue ); + break; + } + case EFixed144: + { + TReal64 tryVal; + switch ( lex.Val(tryVal) ) + { + case KErrOverflow: + { + // sizeof argument + User::Leave(EInvalidArgs); + break; + } + case KErrGeneral: + { + // bad argument + User::Leave(EInvalidArgs); + break; + } + default: + { + + TInt left = aValue.Find(UpnpString::KDot8); + TInt right; + //only decimal part exists + if ( left == KErrNotFound ) + { + left = aValue.Length(); + right = left; + //occurances of minus are not counted as a seprate digit positions + TInt minus = aValue.Find(UpnpString::KMinus); + + if (minus > KErrNone) + { + left --; + } + else if(minus == KErrNone) + { + left--; + if(aValue.Find(UpnpString::KMinus)>=KErrNone) + { + left--; + } + } + } + else //fractional part exists + { + right = left+1; + if(tryVal<0) + { + left--; + } + + if (aValue.Mid(right).Find(UpnpString::KMinus) >= KErrNone) + { + right++; + } + } + + //checking decimal digits + if ( left > KMaxFixed144Left ) + { + User::Leave(EInvalidArgs); + } + //checking fractal digits + right = (aValue.Length() - right ); + if ( right > KMaxFixed144Right ) + { + User::Leave(EInvalidArgs); + } + + // NULL value, if AllocL leaves then the pointer is invalid + DeleteAndNullValue(); + iValue = aValue.AllocL(); + } + } + break; + } + case EBinBase64: + { + // NULL value, if AllocL leaves then the pointer is invalid + DeleteAndNullValue(); + iValue = aValue.AllocL(); + + break; + } + case EBinHex: + { + TInt64 tryVal; + CheckErrorL( lex.Val(tryVal, EHex), aValue ); + break; + } + case EChar: + { + // just one character allowed + if (aValue.Length() > 1) + { + User::Leave(EInvalidArgs); + } + // NULL value, if AllocL leaves then the pointer is invalid + DeleteAndNullValue(); + iValue = aValue.AllocL(); + + break; + } + case EDate: + case EDateTime: + case EDateTimeTz: + case ETime: + case ETimeTz: + case EUri: + case EUuid: + case EString: + { + // NULL value, if AllocL leaves then the pointer is invalid + DeleteAndNullValue(); + iValue = aValue.AllocL(); + + break; + } + default: + { + // unknown + // must be tolerant + // NULL value, if AllocL leaves then the pointer is invalid + DeleteAndNullValue(); + iValue = aValue.AllocL(); + + break; + } + } + + +} + +// ----------------------------------------------------------------------------- +// CUpnpArgument::Value +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TDesC8& CUpnpArgument::Value() +{ + LOGS("CUpnpArgument::Value() [Name/Value]"); + return *iValue; +} + +// ----------------------------------------------------------------------------- +// CUpnpArgument::RelatedStateVariable +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TDesC8& CUpnpArgument::RelatedStateVariable() +{ + return *iRelatedStateVariable; +} + +void CUpnpArgument::SetRelatedStateVarL(const TDesC8& aRelatedStateVar) + { + HBufC8* tmp = aRelatedStateVar.AllocL(); + delete iRelatedStateVariable; + iRelatedStateVariable = tmp; + } +// ----------------------------------------------------------------------------- +// CUpnpArgument::Direction +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CUpnpArgument::Direction() const +{ + return iDirection; +} + +void CUpnpArgument::SetDirectionL( TInt aDirection ) + { + iDirection = aDirection; + } + +// ----------------------------------------------------------------------------- +// CUpnpArgument::Type +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TArgumentType CUpnpArgument::Type() +{ + CUpnpStateVariable* var = iParentService.StateVariable( *iRelatedStateVariable ); + if( var ) + { + return var->Type(); + } + else + { + return EUnknown; + } +} + +// ----------------------------------------------------------------------------- +// CUpnpArgument::DeleteAndNullValue +// Delete and NULL iValue. +// ----------------------------------------------------------------------------- +// +void CUpnpArgument::DeleteAndNullValue() +{ + delete iValue; + iValue = NULL; +} + +// ----------------------------------------------------------------------------- +// CUpnpArgument::CheckErrorL +// Checks the error code for the SetValue method and leaves if needed. +// ----------------------------------------------------------------------------- +// +void CUpnpArgument::CheckErrorL(TInt aError, const TDesC8& aValue) +{ + switch ( aError ) + { + case KErrOverflow: + { + // sizeof argument + User::Leave(EInvalidArgs); + break; + } + case KErrGeneral: + { + // bad argument + User::Leave(EInvalidArgs); + break; + } + default: + { + // NULL value, if AllocL leaves then the pointer is invalid + DeleteAndNullValue(); + iValue = aValue.AllocL(); + } + } +} + +void CUpnpArgument::SetType(TInt aType) + { + iType = aType; + } + +// End of File