diff -r 000000000000 -r 62f9d29f7211 webservices/wsutils/src/senhttptransportproperties.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsutils/src/senhttptransportproperties.cpp Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,606 @@ +/* +* Copyright (c) 2005 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 // RWriteStream +#include +#include +#include +#include + +#include "senlogger.h" +#include "SenHttpTransportProperties.h" +#include "senpropertiesfragment.h" +#include "MSenProperty.h" + +EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewL() + { + CSenHttpTransportProperties* pNew = NewLC(); + CleanupStack::Pop(); // pNew + return pNew; + } + +EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewLC() + { + CSenHttpTransportProperties* pNew = new (ELeave) CSenHttpTransportProperties; + CleanupStack::PushL(pNew); + + // omit parsing by passing zero-length descriptor + pNew->BaseConstructL(KSenXmlPropertiesLocalname, + KNullDesC8, + NULL); + return pNew; + } + +EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewL(const TDesC8& aXmlUtf8, + CSenXmlReader& aParser) + { + CSenHttpTransportProperties* pNew = NewLC(aXmlUtf8, aParser); + CleanupStack::Pop(); // pNew + return pNew; + } + +EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewLC(const TDesC8& aXmlUtf8, + CSenXmlReader& aParser) + { + CSenHttpTransportProperties* pNew = new (ELeave) CSenHttpTransportProperties; + CleanupStack::PushL(pNew); + + // parse the XML document descriptor into DOM fragment + pNew->BaseConstructL(KSenXmlPropertiesLocalname, + aXmlUtf8, + &aParser); + return pNew; + } + +EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewL(const CSenElement& aElement) + { + CSenHttpTransportProperties* pNew = NewLC(aElement); + CleanupStack::Pop(); // pNew + return pNew; + } + +EXPORT_C CSenHttpTransportProperties* CSenHttpTransportProperties::NewLC(const CSenElement& aElement) + { + CSenHttpTransportProperties* pNew = new (ELeave) CSenHttpTransportProperties; + CleanupStack::PushL(pNew); + + // parse the XML document descriptor into DOM fragment + pNew->BaseConstructL(aElement); + return pNew; + } + +void CSenHttpTransportProperties::SetReader(CSenXmlReader& aReader) + { + CSenTransportProperties::SetReader(aReader); + } + +MSenProperties::TSenPropertiesClassType CSenHttpTransportProperties::PropertiesClassType() + { + return ESenHttpTransportProperties; + } + +void CSenHttpTransportProperties::WriteToL(RWriteStream& aWriteStream) + { + CSenTransportProperties::WriteToL(aWriteStream); + } + +void CSenHttpTransportProperties::ReadFromL(const TDesC8& aBuffer) + { + CSenTransportProperties::ReadFromL(aBuffer); + } + +HBufC8* CSenHttpTransportProperties::AsUtf8L() + { + return CSenTransportProperties::AsUtf8L(); + } + +HBufC8* CSenHttpTransportProperties::AsUtf8LC() + { + return CSenTransportProperties::AsUtf8LC(); + } + +TBool CSenHttpTransportProperties::IsSafeToCast(TSenPropertiesClassType aClass) + { + if ( aClass == MSenProperties::ESenHttpTransportProperties ) + { + return ETrue; + } + else + { + return CSenTransportProperties::IsSafeToCast(aClass); + } + } + + +TInt CSenHttpTransportProperties::SetPropertyL(const TDesC8& aName, + const TDesC8& aValue) + { + return CSenTransportProperties::SetPropertyL(aName, aValue); + } + +TInt CSenHttpTransportProperties::PropertyL(const TDesC8& aName, + TPtrC8& aValue) + { + return CSenTransportProperties::PropertyL(aName, aValue); + } + +TInt CSenHttpTransportProperties::SetIntPropertyL(const TDesC8& aName, + const TInt aValue) + { + return CSenTransportProperties::SetIntPropertyL(aName, aValue); + } + +TInt CSenHttpTransportProperties::IntPropertyL(const TDesC8& aName, + TInt& aValue) + { + return CSenTransportProperties::IntPropertyL(aName, aValue); + } + +TInt CSenHttpTransportProperties::SetBoolPropertyL(const TDesC8& aName, + const TBool aValue) + { + return CSenTransportProperties::SetBoolPropertyL(aName, aValue); + } + +TInt CSenHttpTransportProperties::BoolPropertyL(const TDesC8& aName, + TBool& aValue) + { + return CSenTransportProperties::BoolPropertyL(aName, aValue); + } + +TInt CSenHttpTransportProperties::SetOmittedL(const TDesC8& aName, TBool aValue) + { + return CSenTransportProperties::SetOmittedL(aName, aValue); + } + +TInt CSenHttpTransportProperties::RemovePropertyL(const TDesC8& aName) + { + return CSenTransportProperties::RemovePropertyL(aName); + } + +CSenHttpTransportProperties::~CSenHttpTransportProperties() + { + } + +void CSenHttpTransportProperties::BaseConstructL(const TDesC8& aLocalname, + const TDesC8& aXml, + CSenXmlReader* aParser) + { + CSenTransportProperties::BaseConstructL(aLocalname, aXml, aParser); + } + +void CSenHttpTransportProperties::BaseConstructL(const TDesC8& aNamespace, + const TDesC8& aLocalname, + const TDesC8& aXml, + CSenXmlReader* aParser) + { + CSenTransportProperties::BaseConstructL(aNamespace, aLocalname, aXml, aParser); + } + +void CSenHttpTransportProperties::BaseConstructL(const TDesC8& aNamespace, + const TDesC8& aLocalname, + const TDesC8& aQualifiedName, + const TDesC8& aXml, + CSenXmlReader* aParser) + { + CSenTransportProperties::BaseConstructL(aNamespace, aLocalname, aQualifiedName, aXml, aParser); + } + +void CSenHttpTransportProperties::BaseConstructL(const CSenElement& aElement) + { + CSenTransportProperties::BaseConstructL(aElement); + } + +CSenHttpTransportProperties::CSenHttpTransportProperties() + { + } + + +TInt CSenHttpTransportProperties::ContentTypeL(TPtrC8& aContentType) + { + return HttpHeaderL(KContentTypeLocalName, aContentType); + } + +void CSenHttpTransportProperties::SetContentTypeL(const TDesC8& aContentType) + { + SetPropertyL(KContentTypeLocalName, aContentType, KHttpHeaderType); + } + +TInt CSenHttpTransportProperties::UserAgentL(TPtrC8& aUserAgent) + { + return HttpHeaderL(KUserAgentLocalName, aUserAgent); + } + +void CSenHttpTransportProperties::SetUserAgentL(const TDesC8& aUserAgent) + { + SetPropertyL(KUserAgentLocalName, aUserAgent, KHttpHeaderType); + } + + +TInt CSenHttpTransportProperties::SoapActionL(TPtrC8& aSoapAction) + { + return CSenTransportProperties::SoapActionL(aSoapAction); + } + +void CSenHttpTransportProperties::SetSoapActionL(const TDesC8& aSoapAction) + { + _LIT8(KQuote, "\""); + HBufC8* pTemp = HBufC8::NewLC(aSoapAction.Length()+(2*KQuote().Length())); + + TPtr8 temp = pTemp->Des(); + + if(!SenXmlUtils::StartsWith(aSoapAction, KQuote)) + { + temp.Append(KQuote); + } + temp.Append(aSoapAction); + + if(!SenXmlUtils::EndsWith(*pTemp, KQuote)) + { + temp.Append(KQuote); + } + + SetPropertyL(KSoapActionLocalName, *pTemp, KHttpHeaderType); + + CleanupStack::PopAndDestroy(pTemp); // Destroy temporary SoapAction + } + +TInt CSenHttpTransportProperties::AcceptL(TPtrC8& aAccept) + { + return HttpHeaderL(KAcceptLocalName, aAccept); + } + +void CSenHttpTransportProperties::SetAcceptL(const TDesC8& aAccept) + { + SetPropertyL(KAcceptLocalName, aAccept, KHttpHeaderType); + } + +TInt CSenHttpTransportProperties::HttpMethodL(TSenHttpMethod& aMethod) + { + TPtrC8 method; + TInt retVal = PropertyL(KHttpMethodLocalName, method); + if (retVal == KErrNone) + { + if (method == KHttpGet) + { + aMethod = ESenHttpGet; + return KErrNone; + } + else if (method == KHttpPost) + { + aMethod = ESenHttpPost; + return KErrNone; + } + else if (method == KHttpPut) + { + aMethod = ESenHttpPut; + return KErrNone; + } + else if (method == KHttpDelete) + { + aMethod = ESenHttpDelete; + return KErrNone; + } + else + { + return KErrUnknown; + } + } + else + { + return retVal; + } + } + +void CSenHttpTransportProperties::SetHttpMethodL(TSenHttpMethod aHttpMethod) + { + switch ( aHttpMethod ) + { + case ESenHttpGet: + SetPropertyL(KHttpMethodLocalName, KHttpGet); + break; + case ESenHttpPost: + SetPropertyL(KHttpMethodLocalName, KHttpPost); + break; + case ESenHttpPut: + SetPropertyL(KHttpMethodLocalName, KHttpPut); + break; + case ESenHttpDelete: + SetPropertyL(KHttpMethodLocalName, KHttpDelete); + break; + default: + // Not possible + break; + } + } + +TInt CSenHttpTransportProperties::HttpVersionL(TSenHttpVersion& aHttpVersion) + { + TPtrC8 method; + TInt retVal = PropertyL(KHttpVersionLocalName, method); + if (retVal == KErrNone) + { + if (method == KHttp10) + { + aHttpVersion = ESenHttp10; + return KErrNone; + } + else if (method == KHttp11) + { + aHttpVersion = ESenHttp11; + return KErrNone; + } + else + { + return KErrUnknown; + } + } + else + { + return retVal; + } + } + +void CSenHttpTransportProperties::SetHttpVersionL(TSenHttpVersion aHttpVersion) + { + switch ( aHttpVersion ) + { + case ESenHttp10: + SetPropertyL(KHttpVersionLocalName, KHttp10); + break; + case ESenHttp11: + SetPropertyL(KHttpVersionLocalName, KHttp11); + break; + default: + // Not possible + break; + } + } + +TInt CSenHttpTransportProperties::HttpHeaderL(const TDesC8& aHeaderName, + TPtrC8& aValue) + { + TPtrC8 value; + TPtrC8 type; + TInt retVal = PropertyL(aHeaderName, value, type); + if ( retVal == KErrNone ) + { + if ( type == KHttpHeaderType ) + { + aValue.Set(value); + } + else + { + retVal = KErrNotFound; + } + } + return retVal; + } + +void CSenHttpTransportProperties::SetHttpHeaderL(const TDesC8& aHeaderName, const TDesC8& aValue) + { + SetPropertyL(aHeaderName, aValue, KHttpHeaderType); + } + +TInt CSenHttpTransportProperties::SetPropertyL(const TDesC8& aName, + const TDesC8& aValue, + const TDesC8& aType) + { + return CSenTransportProperties::SetPropertyL(aName, aValue, aType); + } + +TInt CSenHttpTransportProperties::PropertyL(const TDesC8& aName, + TPtrC8& aValue, + TPtrC8& aType) + { + return CSenTransportProperties::PropertyL(aName, aValue, aType); + } + +TInt CSenHttpTransportProperties::IapIdL(TUint32& aCurrentIapId) + { + return CSenTransportProperties::IapIdL(aCurrentIapId); + } + +void CSenHttpTransportProperties::SetIapIdL(TUint32 aIapId) + { + CSenTransportProperties::SetIapIdL(aIapId); + } + +void CSenHttpTransportProperties::SetSnapIdL(TUint32 aSnapId) + { + CSenTransportProperties::SetSnapIdL(aSnapId); + } + + +TInt CSenHttpTransportProperties::SnapIdL(TUint32& aCurrentSnapId) + { + return CSenTransportProperties::SnapIdL(aCurrentSnapId); + } +TInt CSenHttpTransportProperties::ProxyPortL(TInt& aProxyPort) + { + return CSenTransportProperties::ProxyPortL(aProxyPort); + } + +void CSenHttpTransportProperties::SetProxyPortL(TInt aProxyPort) + { + CSenTransportProperties::SetProxyPortL(aProxyPort); + } + +TInt CSenHttpTransportProperties::ProxyHostL(TPtrC8& aProxyHost) + { + return CSenTransportProperties::ProxyHostL(aProxyHost); + } + +void CSenHttpTransportProperties::SetProxyHostL(const TDesC8& aProxyHost) + { + CSenTransportProperties::SetProxyHostL(aProxyHost); + } + +TInt CSenHttpTransportProperties::ProxyUsageL(TBool& aValue) + { + return CSenTransportProperties::ProxyUsageL(aValue); + } + +void CSenHttpTransportProperties::SetProxyUsageL(TBool aProxyUsage) + { + CSenTransportProperties::SetProxyUsageL(aProxyUsage); + } + +TInt CSenHttpTransportProperties::SecureDialogL(TBool& aValue) + { + return CSenTransportProperties::SecureDialogL(aValue); + } + +void CSenHttpTransportProperties::SetSecureDialogL(TBool aSecureDialog) + { + CSenTransportProperties::SetSecureDialogL(aSecureDialog); + } +/* +TInt CSenHttpTransportProperties::IAPDialogL(TBool& aValue) + { + return CSenTransportProperties::IAPDialogL(aValue); + } + +void CSenHttpTransportProperties::SetIAPDialogL(TBool aIAPDialog) + { + CSenTransportProperties::SetIAPDialogL(aIAPDialog); + } +*/ +TInt CSenHttpTransportProperties::DeviceIDL(TPtrC8& aDeviceID) + { + return CSenTransportProperties::DeviceIDL(aDeviceID); + } + +void CSenHttpTransportProperties::SetDeviceIDL(const TDesC8& aDeviceID) + { + CSenTransportProperties::SetDeviceIDL(aDeviceID); + } +TInt CSenHttpTransportProperties::DownloadFolderL(TPtrC8& aDownloadFolder) + { + return CSenTransportProperties::DownloadFolderL(aDownloadFolder); + } + +void CSenHttpTransportProperties::SetDownloadFolderL(const TDesC8& aDownloadFolder) + { + CSenTransportProperties::SetDownloadFolderL(aDownloadFolder); + } + +TInt CSenHttpTransportProperties::FileAttachmentL(const TDesC8& aCid, HBufC8*& aFileName) + { + return CSenTransportProperties::FileAttachmentL(aCid, aFileName); + } + +TInt CSenHttpTransportProperties::SetFileAttachmentL(const TDesC8& aCid, const TDesC8& aFileName) + { + return CSenTransportProperties::SetFileAttachmentL(aCid, aFileName); + } + +void CSenHttpTransportProperties::ApplyBindingL(TSOAPVersion aSoapVersion) + { + + TLSLOG_FORMAT((KSenUtilsLogChannel, KMinLogLevel, _L("CSenHttpTransportProperties::ApplyBindingL(SOAP1.%d)"), aSoapVersion==ESOAP11?1:2)); + //TLSLOG_L(KSenUtilsLogChannel, KSenUtilsLogLevel, "CSenHttpTransportProperties::ApplyBindingL"); + TPtrC8 value; + SoapActionL(value); + if ( aSoapVersion == ESOAP11 ) + { + TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "- Applying SOAP 1.1 binding."); + HBufC8* dblQutoedValue = AdaptDblQutesLC(value); + SetSoapActionL(*dblQutoedValue); + CleanupStack::PopAndDestroy(dblQutoedValue); + } + else + { + TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "- Applying SOAP 1.2 binding."); + const TInt KActionLength = 11; // comes from chars: '; action=""' + CSenElement* pElement = ipFragment->AsElement().Element(KSoapActionLocalName); + if ( pElement ) + { + // Remove the type attribute, to prevent HTTP header to be added in HTTP transport plug-in(s) + CSenBaseAttribute* attr = SenXmlUtils::RemoveAttributeL(*pElement, KSenTypeAttributeName); + delete attr; + attr = NULL; + } +// // (Re-)setting empty (zero-length) value for type attribute should do the same trick: +// SetPropertyL(KSoapActionLocalName, value, KNullDesC8); + + HBufC8* dblQutoedValue = AdaptDblQutesLC(value); + HBufC8* buf = HBufC8::NewLC(dblQutoedValue->Length() + KSenSoap12ContentTypeHeaderValue().Length() + + KActionLength); + TPtr8 ptr = buf->Des(); + ptr.Append(KSenSoap12ContentTypeHeaderValue); + if ( ptr.Length() ) + { + _LIT8(KColonSpace,"; "); + ptr.Append(KColonSpace); //CodeScannerWarnings + } + _LIT8(KAction,"action="); + ptr.Append(KAction); //CodeScannerWarnings + ptr.Append( *dblQutoedValue ); + SetContentTypeL( *buf ); + CleanupStack::PopAndDestroy( buf ); + CleanupStack::PopAndDestroy( dblQutoedValue ); + SetAcceptL( KSenSoap12AcceptHeaderValue ); + } + } +HBufC8* CSenHttpTransportProperties::AdaptDblQutesLC(const TDesC8& aValue) + { + if((!SenXmlUtils::StartsWith(aValue, KSenDblQuot())) + && (!SenXmlUtils::EndsWith(aValue, KSenDblQuot())) + && (aValue.Length() >= 2 * KSenDblQuot().Length())) + { + HBufC8* buf = HBufC8::NewLC(aValue.Length() + 2 * KSenDblQuot().Length()); + TPtr8 ptr = buf->Des(); + ptr.Append( KSenDblQuot); + ptr.Append( aValue ); + ptr.Append( KSenDblQuot); + return buf; + } + else + { + return aValue.AllocLC(); + } + } +MSenProperties* CSenHttpTransportProperties::CloneL() const + { + CSenElement& element = ipFragment->AsElement(); + + CSenHttpTransportProperties* pProperties = this->NewLC(element); + CleanupStack::Pop(pProperties); + return pProperties; + } + +TInt CSenHttpTransportProperties::MwsNamespaceL(TPtrC8& aMwsNamespace) + { + return CSenTransportProperties::MwsNamespaceL(aMwsNamespace); + } + +void CSenHttpTransportProperties::SetMwsNamespaceL(const TDesC8& aMwsNamespace) + { + CSenTransportProperties::SetMwsNamespaceL(aMwsNamespace); + } + +// END OF FILE + +