diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericservices/httputils/AuthorityParser/CAuthority.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericservices/httputils/AuthorityParser/CAuthority.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,648 @@ +// Copyright (c) 2001-2009 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 +#include +#include "CAuthorityInternal.h" +#include +#include +#include + + +// +// +// Implementation of CAuthority8 +// +// + +/** + Static factory constructor. Uses two phase construction and leaves nothing on the + CleanupStack. Creates an authority object which is a copy of the input parameter + aAuthority. + + @since 6.0 + @param aAuthority A reference to a parsed authority object. + @return A pointer to the newly created CAuthority8 object. + @post A fully constructed and initialized CAuthority8 object. +*/ +EXPORT_C CAuthority8* CAuthority8::NewL(const TAuthorityC8& aAuthority) + { + CAuthority8* self = CAuthority8::NewLC(aAuthority); + CleanupStack::Pop(self); + return self; + } + +/** + Static factory constructor. Uses two phase construction and leaves a pointer to created + object on the CleanupStack. Creates an authority object which is a copy of the input + parameter aAuthority. + + @since 6.0 + @param aAuthority A reference to a parsed authority object. + @return A pointer to the newly created CAuthority8 object. + @post A fully constructed and initialized CAuthority8 object. + */ +EXPORT_C CAuthority8* CAuthority8::NewLC(const TAuthorityC8& aAuthority) + { + CAuthority8* self = new (ELeave) CAuthority8(aAuthority); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +/** + Static factory constructor. Uses two phase construction and leaves nothing on the CleanupStack. + Creates an authority object which is empty. + + @since 6.0 + @return A pointer to the newly created CAuthority8 object. + @post A fully constructed and initialized CAuthority8 object. + */ +EXPORT_C CAuthority8* CAuthority8::NewL() + { + CAuthority8* self = CAuthority8::NewLC(); + CleanupStack::Pop(self); + return self; + } + +/** + Static factory constructor. Uses two phase construction and leaves a pointer to created object on + the CleanupStack. Creates an authority object which is empty. + + @since 6.0 + @return A pointer to the newly created CAuthority8 object. + @post A fully constructed and initialized CAuthority8 object. + */ +EXPORT_C CAuthority8* CAuthority8::NewLC() + { + CAuthority8* self = new (ELeave) CAuthority8(TAuthorityC8()); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +/** + Destructor. + + @since 6.0 + */ +EXPORT_C CAuthority8::~CAuthority8() + { + delete iAuthorityBuf; + } + +/** + Provides a reference to the parsed authority. Allows access to the non-modifying API for TAuthorityC8. + + @since 6.0 + @return A const reference to the parsed authority object. + */ +EXPORT_C const TAuthorityC8& CAuthority8::Authority() const + { + return iAuthority; + } + +/** + Sets the specified component in the authority. The component is set to the value given in the argument + aData. If the specified component already exists then it is replaced with the new value. + + @since 6.0 + @param aData A descriptor pointer to the new value for the authority component. + @param aComponent An enum specifying the component to be set. + @pre Object is fully constructed. + @post The authority has the specified component set to the new value. + @Leave KErrArgument If aComponent goes out of range. + */ +EXPORT_C void CAuthority8::SetComponentL(const TDesC8& aData, TAuthorityComponent aComponent) + { + // Update the appropriate component table entry + iAuthority.iComponent[aComponent].Set(aData); + + // Copy to the buffer by forming the Authority + FormAuthorityL(); + } + +/** + Escape encodes the component then sets the specified component in the authority. The component is set to the + value given in the argument aData. If the specified component already exists then it is replaced with the new + value. + + @since 6.0 + @param aData A descriptor pointer to the new value for the authority component. + @param aComponent An enum specifying the component to be set. + @pre Object is fully constructed. + @post The authority has the specified component set to the new value. + */ +EXPORT_C void CAuthority8::SetAndEscapeComponentL(const TDesC8& aData, TAuthorityComponent aComponent) + { + // Create escaped version of component + HBufC8* escaped = EscapeUtils::EscapeEncodeL(aData, EscapeUtils::EEscapeAuth); + CleanupStack::PushL(escaped); + + // Set the component + if(aComponent=EAuthorityUserinfo ) + { + SetComponentL(*escaped, aComponent); + } + else + { + User::Leave(KErrArgument); + } + + // Cleanup + CleanupStack::PopAndDestroy(escaped); + } + +/** + Removes the specified component from the authority. If the component does not exist then this function does + nothing. + + @since 6.0 + @param aComponent An enum specifying the component to be removed. + @pre Object is fully constructed. + @post The authority is updated to exclude the specified component. + */ +EXPORT_C void CAuthority8::RemoveComponentL(TAuthorityComponent aComponent) + { + if( iAuthority.IsPresent(aComponent) ) + { + // Remove the component - set pointer to NULL and length to zero + iAuthority.iComponent[aComponent].Set(NULL,0); + + // Re-form buffer and component table + FormAuthorityL(); + } + } + +/** + Constructor. First phase of two-phase construction method. Does non-allocating construction. + + @param aNewAuthority The parsed authority component information from which + to create the authority. + @since 6.0 + */ +CAuthority8::CAuthority8(const TAuthorityC8& aNewAuthority) +: CBase(), iAuthority(aNewAuthority) + { + } + +/** + Second phase of two-phase construction method. Does any allocations required to fully construct + the object. + + @since 6.0 + @pre First phase of construction is complete. + @post The object is fully constructed and initialized. + */ +void CAuthority8::ConstructL() + { + // Create the HBufC8 + FormAuthorityL(); + } + +/** + Forms the authority from the parsed authority information. A copy of the parsed authority is created. + The parsed authority is changed to refer to the copy. + + @since 6.0 + @pre The parsed authority information is set. + @post The authority buffer is a copy of the parsed authority, and the + parsed authority now refers to the copy. + */ +void CAuthority8::FormAuthorityL() + { + TBool isIPv6Host; + + // Calculate length of of the Authority + TInt length = CalculateAuthorityLength(iAuthority.iComponent, isIPv6Host); + + // Create a temporary buffer and descriptor pointer to it + HBufC8* buf = HBufC8::NewL(length); + TPtr8 authority = buf->Des(); + + // Create the authority, updating the internal authority object + DoFormAuthority(authority, iAuthority.iComponent, isIPv6Host); + + // Update the internal buffer and descriptor pointer for the authority object + delete iAuthorityBuf; + iAuthorityBuf = buf; + iAuthority.iAuthorityDes.Set(iAuthorityBuf->Des()); + } + +// +// +// Implementation of CAuthority16 +// +// + +/** + Static factory constructor. Uses two phase construction and leaves nothing on the CleanupStack. + Creates an authority object which is a copy of the input parameter aAuthority. + + @since 6.0 + @deprecated Deprecated in 9.1 + @param aAuthority A reference to a parsed authority object. + @return A pointer to the newly created CAuthority16 object. + @post A fully constructed and initialized CAuthority16 object. + */ +EXPORT_C CAuthority16* CAuthority16::NewL(const TAuthorityC16& aAuthority) + { + CAuthority16* self = CAuthority16::NewLC(aAuthority); + CleanupStack::Pop(self); + return self; + } + +/** + Static factory constructor. Uses two phase construction and leaves a pointer to created object on + the CleanupStack. Creates an authority object which is a copy of the input parameter aAuthority. + + @since 6.0 + @deprecated Deprecated in 9.1 + @param aAuthority A reference to a parsed authority object. + @return A pointer to the newly created CAuthority16 object. + @post A fully constructed and initialized CAuthority16 object. + */ +EXPORT_C CAuthority16* CAuthority16::NewLC(const TAuthorityC16& aAuthority) + { + CAuthority16* self = new (ELeave) CAuthority16(aAuthority); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +/** + Static factory constructor. Uses two phase construction and leaves nothing on the CleanupStack. + Creates an authority object which is empty. + + @since 6.0 + @deprecated Deprecated in 9.1 + @return A pointer to the newly created CAuthority16 object. + @post A fully constructed and initialized CAuthority16 object. + */ +EXPORT_C CAuthority16* CAuthority16::NewL() + { + CAuthority16* self = CAuthority16::NewLC(); + CleanupStack::Pop(self); + return self; + } + +/** + Static factory constructor. Uses two phase construction and leaves a pointer to created object on the + CleanupStack. Creates an authority object which is empty. + + @since 6.0 + @deprecated Deprecated in 9.1 + @return A pointer to the newly created CAuthority16 object. + @post A fully constructed and initialized CAuthority16 object. + */ +EXPORT_C CAuthority16* CAuthority16::NewLC() + { + CAuthority16* self = new (ELeave) CAuthority16(TAuthorityC16()); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +/** + Destructor. + + @since 6.0 + @deprecated Deprecated in 9.1 + */ +EXPORT_C CAuthority16::~CAuthority16() + { + delete iAuthorityBuf; + } + +/** + Provides a reference to the parsed authority. Allows access to the non-modifying API for TAuthorityC. + + @since 6.0 + @deprecated Deprecated in 9.1 + @return A const reference to the parsed authority object. + */ +EXPORT_C const TAuthorityC16& CAuthority16::Authority() const + { + return iAuthority; + } + +/** + Sets the specified component in the authority. The component is set to the value given in the argument aData. + If the specified component already exists then it is replaced with the new value. + + @since 6.0 + @deprecated Deprecated in 9.1 + @param aData A descriptor pointer to the new value for the authority component. + @param aComponent An enum specifying the component to be set. + @pre Object is fully constructed. + @post The authority has the specified component set to the new value. + @Leave KErrArgument If aComponent goes out of range. + */ +EXPORT_C void CAuthority16::SetComponentL(const TDesC16& aData, TAuthorityComponent aComponent) + { + // Update the appropriate component table entry + iAuthority.iComponent[aComponent].Set(aData); + + // Copy to the buffer by forming the Authority + FormAuthorityL(); + } + +/** + Escape encodes the component then sets the specified component in the authority. The component is set to the + value given in the argument aData. If the specified component already exists then it is replaced with the new + value. + + @since 6.0 + @deprecated Deprecated in 9.1 + @param aData A descriptor pointer to the new value for the authority component. + @param aComponent An enum specifying the component to be set. + @pre Object is fully constructed. + @post The authority has the specified component set to the new value. + */ +EXPORT_C void CAuthority16::SetAndEscapeComponentL(const TDesC16& aData, TAuthorityComponent aComponent) + { + // Need to convert to utf8 first + HBufC8* utf8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aData); + CleanupStack::PushL(utf8); + + // Create escaped version of component + HBufC8* escaped = EscapeUtils::EscapeEncodeL(*utf8, EscapeUtils::EEscapeAuth); + CleanupStack::PushL(escaped); + + // Convert back to 16-bits + HBufC16* converted = HBufC16::NewLC(escaped->Length()); + converted->Des().Copy(*escaped); + + // Set the component + if(aComponent=EAuthorityUserinfo ) + { + SetComponentL(*converted, aComponent); + } + else + { + User::Leave(KErrArgument); + } + + // Cleanup + CleanupStack::PopAndDestroy(3, utf8); // utf8, escaped, converted + } + +/** + Removes the specified component from the authority. If the component does not exist then this + function does nothing. + + @since 6.0 + @deprecated Deprecated in 9.1 + @param aComponent An enum specifying the component to be removed. + @pre Object is fully constructed. + @post The authority is updated to exclude the specified component. + */ +EXPORT_C void CAuthority16::RemoveComponentL(TAuthorityComponent aComponent) + { + if( iAuthority.IsPresent(aComponent) ) + { + // Remove the component - set pointer to NULL and length to zero + iAuthority.iComponent[aComponent].Set(NULL,0); + + // Re-form buffer and component table + FormAuthorityL(); + } + } + +/** + Constructor. First phase of two-phase construction method. Does non-allocating construction. + + @since 6.0 + @param aNewAuthority The parsed authority component information from which + to create the authority. + */ +CAuthority16::CAuthority16(const TAuthorityC16& aNewAuthority) +: CBase(), iAuthority(aNewAuthority) + { + } + +/** + Second phase of two-phase construction method. Does any allocations required to fully construct + the object. + + @since 6.0 + @pre First phase of construction is complete. + @post The object is fully constructed and initialized. + */ +void CAuthority16::ConstructL() + { + // Create the HBufC16 + FormAuthorityL(); + } + +/** + Forms the authority from the parsed authority information. A copy of the parsed authority is created. + The parsed authority is changed to refer to the copy. + + @since 6.0 + @pre The parsed authority information is set. + @post The authority buffer is a copy of the parsed authority, and the + parsed authority now refers to the copy. + */ +void CAuthority16::FormAuthorityL() + { + TBool isIPv6Host; + + // Calculate length of of the Authority + TInt length = CalculateAuthorityLength(iAuthority.iComponent, isIPv6Host); + + // Create a temporary buffer and descriptor pointer to it + HBufC16* buf = HBufC16::NewL(length); + TPtr16 authority = buf->Des(); + + // Create the authority, updating the internal authority object + DoFormAuthority(authority, iAuthority.iComponent, isIPv6Host); + + // Update the internal buffer and descriptor pointer for the authority object + delete iAuthorityBuf; + iAuthorityBuf = buf; + iAuthority.iAuthorityDes.Set(iAuthorityBuf->Des()); + } + +// +// +// Implementation of templated LOCAL functions +// +// + +/** + Calculates the length of the authority from a list of the components. + + @since 6.0 + @param aComponent The array of descriptor pointers to the authority + components. + @param aIsIPv6Host Specifies ETrue or EFalse. + @return The length of the authority including the required delimiters. +*/ +template +TInt CalculateAuthorityLength(const TPtrCType aComponent[], TBool& aIsIPv6Host) + { + aIsIPv6Host = EFalse; + TInt length=0; + for( TInt i=0; i +void DoFormAuthority(TPtrType& aAuthority, TPtrCType aComponent[], const TBool& aIsIPv6Host) + { + if( aComponent[EAuthorityUserinfo].Ptr() ) + { + // Update the userinfo + SetUserinfo(aAuthority, aComponent[EAuthorityUserinfo]); + } + if( aComponent[EAuthorityHost].Ptr() ) + { + // Update the host + SetHost(aAuthority, aComponent[EAuthorityHost], aIsIPv6Host); + } + if( aComponent[EAuthorityPort].Ptr() ) + { + // Update the port + SetPort(aAuthority, aComponent[EAuthorityPort]); + } + } + +/** + Templated function to set the userinfo in an authority. The output argument aAuthority points to + the descriptor buffer into which aNewUserInfo will be copied. The argument aOldUserInfo is updated + to point to the copied version of aNewUserInfo in aAuthority. + + @warning This function will panic with KAuthorityErrBufferOverflow if there is not + enough space in the descriptor to append the component and any required delimiters. + @since 6.0 + @param aAuthority The descriptor pointer to buffer to be appended. + @param aUserinfo The descriptor pointer to the userinfo component to be copied + and then updated. + @pre The buffer pointed to by aAuthority should be large enough to have + aNewUserInfo appended to it with the required delimiter. + @post The authority buffer now includes aNewUserInfo and aOldUserInfo points + to the copy of the userinfo component in aAuthority. +*/ +template +void SetUserinfo(TPtrType& aAuthority, TPtrCType& aUserinfo) + { + // Append the userinfo and delimiter + aAuthority.Append(aUserinfo); + aAuthority.Append(KUserinfoDelimiter); + + // Update the component table + aUserinfo.Set(aAuthority.Left(aUserinfo.Length())); + } + +/** + Templated function to set the host in an authority. The output argument aAuthority points to the + descriptor buffer into which aNewHost will be copied. The argument aOldHost is updated to point to + the copied version of aNewHost in aAuthority. + + @warning This function will panic with KAuthorityErrBufferOverflow if there is not + enough space in the descriptor to append the component and any required delimiters. + @since 6.0 + @param aAuthority The descriptor pointer to buffer to appended. + @param aHost The descriptor pointer to the host component to be copied + and then updated. + @param aIsIPv6Host Specifies ETrue or EFalse. + @pre The buffer pointed to by aAuthority should be large enough to have + aNewHost appended to it with the required delimiter. + @post The authority buffer now includes aNewHost and aOldHost points to the + copy of the host component in aAuthority. +*/ +template +void SetHost(TPtrType& aAuthority, TPtrCType& aHost, const TBool& aIsIPv6Host) + { + if (aIsIPv6Host) + { + aAuthority.Append(KIPv6UriOpenBrace); + aAuthority.Append(aHost); + aAuthority.Append(KIPv6UriCloseBrace); + + // Position = (length of uri - length of host) - length of end brace + aHost.Set( aAuthority.Mid((aAuthority.Length()-aHost.Length())-1, aHost.Length()) ); + } + else + { + // Append the host + aAuthority.Append(aHost); + + // Update the component table + aHost.Set(aAuthority.Right(aHost.Length())); + } + } + +/** + Templated function to set the port in an authority. The output argument aAuthority points to the + descriptor buffer into which aNewPort will be copied. The argument aOldPort is updated to point to + the copied version of aNewPort in aAuthority. + + @warning This function will panic with KAuthorityErrBufferOverflow if there is not + enough space in the descriptor to append the component and any required delimiters. + @since 6.0 + @param aAuthority The descriptor pointer to buffer to appended. + @param aPort The descriptor pointer to the port component to be copied + and then updated. + @pre The buffer pointed to by aAuthority should be large enough to have aNewPort + appended to it with the required delimiter. + @post The authority buffer now includes aNewPort and aOldPort points to the + copy of the port component in aAuthority. +*/ +template +void SetPort(TPtrType& aAuthority, TPtrCType& aPort) + { + // Append delimiter and the port + aAuthority.Append(KPortDelimiter); + aAuthority.Append(aPort); + + // Update the component table + aPort.Set(aAuthority.Right(aPort.Length())); + }