--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/idwsfplugin/src/idwsfdiscoveryserviceclient.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,562 @@
+/*
+* Copyright (c) 2002-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 <s32mem.h>
+
+#include <SenFacet.h>
+#include <SenServiceConnection.h>
+#include <SenXmlReader.h>
+#include <SenXmlUtils.h>
+
+#include "msencoreservicemanager.h"
+#include "sendebug.h"
+
+#include "idwsfmessage.h" // for response parsing and request building
+#include "idwsfdsqueryresponse.h"
+#include "idwsfdiscoveryserviceclient.h"
+#include "idwsfservicesession.h"
+#include "idwsfdsqueryresponse.h"
+
+#include "senlogger.h"
+// for the parsing and the construction of outgoing DSLookups
+
+namespace
+ {
+ // 2004-07-21:
+ _LIT8(KDiscoReqStart1,"<Query xmlns=\"urn:liberty:disco:2003-08\" >");
+
+ // the resouse id element is not needed if no content is available
+ _LIT8(KDiscoReqResIdStart,"<ResourceID>");
+ _LIT8(KDiscoReqResIdEnd,"</ResourceID>");
+
+ _LIT8(KEncrStart,"<Encrypted");
+ _LIT8(KDiscoReqEncrResIdStart,"<EncryptedResourceID>");
+ _LIT8(KDiscoReqEncrResIdEnd,"</EncryptedResourceID>");
+
+ _LIT8(KDiscoReqStart2,"<RequestedServiceType><ServiceType>");
+ _LIT8(KDiscoReqEnd2,"</ServiceType>");
+ _LIT8(KDiscoOptionsStart,"<Options>");
+ _LIT8(KDiscoOptionsEnd,"</Options>");
+ _LIT8(KSenOption,"Option");
+ _LIT8(KDiscoReqEnd, " </RequestedServiceType> </Query>");
+
+ const TInt KFLATBUF_SIZE = 128;
+ }
+
+
+CIdWsfDiscoveryServiceClient* CIdWsfDiscoveryServiceClient::NewL(
+ CSIF& aSIF)//,
+ //RFileLogger& aLogger)
+ {
+ CIdWsfDiscoveryServiceClient* pNew = NewLC(aSIF);//, aLogger);
+ CleanupStack::Pop();
+ return pNew;
+ }
+
+CIdWsfDiscoveryServiceClient* CIdWsfDiscoveryServiceClient::NewLC(
+ CSIF& aSIF)//,
+ //RFileLogger& aLogger)
+ {
+ CIdWsfDiscoveryServiceClient* pNew =
+ new (ELeave) CIdWsfDiscoveryServiceClient(
+ aSIF,
+ MSenServiceDescription::EIdWsfDiscoveryServiceClient);//,
+ //aLogger);
+
+ CleanupStack::PushL(pNew);
+ pNew->BaseConstructL();
+ return pNew;
+ }
+
+CIdWsfDiscoveryServiceClient::CIdWsfDiscoveryServiceClient(CSIF& aSIF,
+ TDescriptionClassType aType)//,
+ //RFileLogger& aLogger)
+ : CIdWsfCoreServiceConsumer(aSIF, aType),
+ iCState(ENotInitialized),
+ iSession(NULL)//,
+ //iLog(aLogger)
+ {
+ }
+
+// returns KErrNotFound, if no matching security mechanism was found
+// in ProcessResponce() call
+// returns KErrNotReady, if no service session has been initilized
+TInt CIdWsfDiscoveryServiceClient::FindServiceL(
+ RPointerArray<CSenWSDescription>& aServiceArray,
+ MSenServiceDescription& aPattern,
+ MSenRemoteServiceConsumer& aRemoteConsumer)
+ {
+ CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfDiscoveryServiceClient::FindServiceL()");
+
+ // keep this line first
+ iServedConsumer = &aRemoteConsumer;
+
+ iResults.ResetAndDestroy(); // clear array and destroy its contents
+ iCState = EHasResults;
+
+ HBufC8* pLookupReq = NULL;
+ TPtrC8 contract = aPattern.Contract();
+
+ TInt retVal(KErrNone);
+ if(contract.Length()>0)
+ {
+ // DsLookupRequestL never returns NULL
+ pLookupReq = DsLookupRequestL(aPattern);
+
+ CleanupStack::PushL(pLookupReq);
+
+ if(iService)
+ {
+ HBufC8* pResponse = NULL;
+ #ifdef _SENDEBUG
+ TPtr8 lookupRequest = pLookupReq->Des();
+//wslog FILELOGALL(_L("SenCoreServiceManager"), _L("DS_lookup_req.xml"), lookupRequest);
+ #endif // _SENDEBUG
+
+ retVal = iService->SubmitL(*pLookupReq, KNullDesC8, *this, pResponse);
+ aRemoteConsumer.SetDataTrafficDetails(iDiscDetails);
+
+
+
+ CleanupStack::PushL(pResponse);
+ if(retVal == KErrNone && pResponse)
+ {
+ #ifdef _SENDEBUG
+ TPtr8 lookupResponse= pResponse->Des();
+//wslog FILELOGALL(_L("SenCoreServiceManager"), _L("DS_lookup_rsp.xml"), lookupResponse);
+ #endif // _SENDEBUG
+
+ CIdWsfDsQueryResponse* pDsQueryResponse =
+ ParseResponseLC(*pResponse); // push #3
+
+ retVal = ProcessResponseL(pDsQueryResponse);
+
+ CleanupStack::PopAndDestroy(1); // pDsQueryResponse
+
+ TInt count(iResults.Count());
+ for(TInt i=0; i<count; i++)
+ {
+ #ifdef _SENDEBUG
+ if(iResults[0])
+ {
+ HBufC* pAsXml = iResults[0]->AsXmlUnicodeL();
+ if(pAsXml)
+ {
+ CleanupStack::PushL(pAsXml);
+ CSLOG_FORMAT((aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("Result (%d):"), i));
+ CSLOG_ALL(aRemoteConsumer.ConnectionId(), KMaxLogLevel ,(*pAsXml));
+ CleanupStack::PopAndDestroy(); // pAsXml
+ }
+
+ }
+ #endif
+ // we now could annotate any new service (session) with
+ // relevant facets from the input ServiceDescription,
+ // but not with disco_options!
+ ((CIdWsfServiceSession*)iResults[0])->CopyFacetsFromL(
+ aPattern);
+ ((CIdWsfServiceSession*)iResults[0])->SetValidator(this);
+ TInt appendRetVal = aServiceArray.Append(
+ (CSenWSDescription*)iResults[0]);
+ if(appendRetVal!=KErrNone)
+ {
+ // out of memory, free orphan
+ delete iResults[0];
+ }
+ iResults.Remove(0);
+ }
+ }
+ CleanupStack::PopAndDestroy(); // pResponse
+ }
+ else
+ {
+ retVal = KErrNotReady;
+ }
+ CleanupStack::PopAndDestroy(); // pLookupReq
+ }
+ else
+ {
+ retVal = KErrSenNoContract;
+ }
+ return retVal;
+ }
+
+
+
+void CIdWsfDiscoveryServiceClient::BaseConstructL()
+ {
+ CIdWsfCoreServiceConsumer::BaseConstructL();
+
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(_L("CIdWsfDiscoveryServiceClient::BaseConstructL()")));
+ }
+
+TInt CIdWsfDiscoveryServiceClient::ValidateL(
+ CIdWsfServiceSession& aSession,
+ MSenRemoteServiceConsumer& aRemoteConsumer)
+ {
+ CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfDiscoveryServiceClient::ValidateL");
+
+ // keep this line first
+ iServedConsumer = &aRemoteConsumer;
+ iSession = &aSession; // iSession == Java's stateObject !!!
+
+ iCState = EHasSession;
+ CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"- creating discovery lookup request.");
+
+
+ HBufC8* pLookupReqUtf8 = DsLookupRequestL(aSession);
+ CleanupStack::PushL(pLookupReqUtf8);
+
+ HBufC8* pSubmitResponse = NULL; // for ref-to-ptr
+
+#ifdef _SENDEBUG
+ TPtr8 lookupRequest= pLookupReqUtf8->Des();
+//wslog FILELOGALL(_L("SenCoreServiceManager"), _L("DS_lookup_req.xml"), lookupRequest);
+#endif // _SENDEBUG
+
+ TInt retVal = iService->SubmitL(*pLookupReqUtf8, KNullDesC8, *this, pSubmitResponse);
+ CleanupStack::PopAndDestroy(); // pLookupReqUtf8
+
+ CleanupStack::PushL(pSubmitResponse);
+ aRemoteConsumer.SetDataTrafficDetails(iDiscDetails);
+
+ if(retVal == KErrNone && pSubmitResponse)
+ {
+ // submit ok
+#ifdef _SENDEBUG
+ TPtr8 lookupResponse = pSubmitResponse->Des();
+//wslog FILELOGALL(_L("SenCoreServiceManager"), _L("DS_lookup_rsp.xml"), lookupResponse);
+#endif // _SENDEBUG
+ CIdWsfDsQueryResponse* theResponse = ParseResponseLC(*pSubmitResponse);
+ retVal = ProcessResponseL(theResponse);
+ CleanupStack::PopAndDestroy(); // theResponse
+ }
+#ifdef _SENDEBUG
+ else
+ {
+ CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfDiscoveryServiceClient::ValidateL");
+ CSLOG_FORMAT((aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("- SubmitL failed: %d"), retVal));
+ }
+#endif // _SENDEBUG
+ CleanupStack::PopAndDestroy(); // pSubmitResponse
+
+ if ((retVal == KErrNone) && iSession->IsReadyL())
+ {
+ CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"- setting this DS client as validator for ID-WFS session.");
+ iSession->SetValidator(this);
+ }
+
+ return retVal;
+ }
+
+CIdWsfDsQueryResponse* CIdWsfDiscoveryServiceClient::ParseResponseLC(
+ TDesC8& aMessage)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(_L("CIdWsfDiscoveryServiceClient::ParseResponseLC")));
+ TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel ,(aMessage));
+
+ // must be first, if we promise LC in this method..
+ CIdWsfDsQueryResponse* pResponse = CIdWsfDsQueryResponse::NewLC();
+
+
+ pResponse->SetReader(*Framework().Manager().XMLReader());
+ pResponse->ParseL(aMessage);
+ return pResponse; // item resides in cleanupstack
+ }
+
+// returns KErrNotFound, if no matching security mechanism was found
+TInt CIdWsfDiscoveryServiceClient::ProcessResponseL(
+ CIdWsfDsQueryResponse* aResponse)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(_L("CIdWsfDiscoveryServiceClient::ProcessResponseL")));
+
+ TInt retVal(KErrNone);
+
+ RPointerArray<CIdWsfServiceInstance> services; // 2004-08-09, bugfix
+
+ CleanupClosePushL(services);
+ aResponse->GetAllServicesL(services);
+
+ CIdWsfServiceSession* pTempSession = NULL; // session in Java!
+
+ switch(iCState)
+ {
+ case EHasSession:
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(_L(" State: EHasSession")));
+ pTempSession = iSession; // iSession == stateObject in Java!
+ if (pTempSession)
+ {
+#ifdef _SENDEBUG
+ if(pTempSession->IsReadyL())
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ," Current session is valid.");
+ }
+ else
+ {
+ TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ," Current session is expired.");
+ }
+#endif
+
+ if (iService)
+ {
+ pTempSession->SetClientServerIntervalL(
+ iService->ClientServerInterval());// codescannerwarnings
+ }
+
+ TInt count(services.Count());
+ for(TInt i=0; !pTempSession->IsReadyL()
+ && i<count; i++) // not-operation bugfix, 2004-07-20
+ {
+ if(services[i])
+ {
+ retVal = pTempSession->InitializeFromL(*services[i]);
+ }
+ }
+
+ if(pTempSession->IsReadyL() && iService)
+ {
+ pTempSession->SetTrustAnchorL(iService->TrustAnchor());
+ }
+ }
+ iCState = ENotInitialized;
+ }
+ break;
+
+ case EHasResults:
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,(_L(" State: EHasResults")));
+ TInt count(services.Count());
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,_L("Response included %d services."),count));
+ for (TInt i=0; i<count; i++)
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,_L("Trying to initialize service number %d "),i));
+ pTempSession =
+ (CIdWsfServiceSession*)Framework().NewServiceDescriptionL();
+ CleanupStack::PushL(pTempSession);
+
+ if (iService)
+ {
+ pTempSession->SetClientServerIntervalL(
+ iService->ClientServerInterval()); //codescannerwarnings
+ }
+
+ for(TInt j=i; j<count && !pTempSession->IsReadyL(); j++)
+ {
+ retVal = pTempSession->InitializeFromL(*services[j]);
+ if(!pTempSession->IsReadyL())
+ {
+ i++;
+ }
+ }
+
+
+ if(pTempSession->IsReadyL())
+ {
+ if(iService)
+ {
+ pTempSession->SetTrustAnchorL(iService->TrustAnchor());
+ }
+ TInt appendRetVal = iResults.Append(pTempSession); // only ready ones goto list
+ if(appendRetVal == KErrNone)
+ {
+ CleanupStack::Pop(); //pTempSession
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // pTempSession
+ }
+ }
+ else
+ {
+ // No ready Session found
+ CleanupStack::PopAndDestroy(); //pTempSession
+ }
+ }
+ }
+ break;
+
+ default:
+ // do nothing
+ break;
+ }
+
+ CleanupStack::PopAndDestroy(); // close services, // 2004-08-09, bugfix
+ return retVal;
+ }
+
+void CIdWsfDiscoveryServiceClient::SetStatusL(const TInt /* aStatus */ )
+ {
+ }
+
+
+
+CIdWsfDiscoveryServiceClient::~CIdWsfDiscoveryServiceClient()
+ {
+ iResults.ResetAndDestroy();
+ }
+
+
+// overrides the internalserviceconsumer.log() function
+// to enable using the log delivered as constructor arg.
+/*RFileLogger* CIdWsfDiscoveryServiceClient::Log() const
+ {
+ return (RFileLogger*) &iLog;
+ }
+*/
+
+
+HBufC8* CIdWsfDiscoveryServiceClient::DsLookupRequestL(
+ MSenServiceDescription& aPattern)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KNormalLogLevel ,(_L("CIdWsfDiscoveryServiceClient::DsLookupRequestL")));
+
+ RFacetArray options;
+ CleanupClosePushL(options);
+
+ CIdWsfDiscoveryServiceClient::DSOptionsL(options, aPattern);
+
+ CBufFlat* pFlat = CBufFlat::NewL(KFLATBUF_SIZE);
+ CleanupStack::PushL(pFlat);
+
+ RBufWriteStream ws;
+ ws.Open(*pFlat);
+ CleanupClosePushL(ws);
+
+ // create the disco lookup query and fill it with the passed service type
+ ws.WriteL(KDiscoReqStart1);
+ TPtrC8 resourceId = iService->ResourceId();
+ if(resourceId.Length()>0)
+ {
+ if(resourceId.Find(KEncrStart) == 0)
+ {
+ ws.WriteL(KDiscoReqEncrResIdStart);
+ ws.WriteL(resourceId);
+ ws.WriteL(KDiscoReqEncrResIdEnd);
+ }
+ else
+ {
+ ws.WriteL(KDiscoReqResIdStart);
+ ws.WriteL(resourceId);
+ ws.WriteL(KDiscoReqResIdEnd);
+ }
+ }
+ ws.WriteL(KDiscoReqStart2);
+ ws.WriteL(aPattern.Contract());
+ ws.WriteL(KDiscoReqEnd2);
+
+ if (options.Count())
+ {
+ ws.WriteL(KDiscoOptionsStart);
+
+ CSenXmlElement* pOption = NULL;
+ HBufC8* pOptionAsXml = NULL;
+
+ TInt count(options.Count());
+ for (TInt i=0; i<count; i++)
+ {
+ pOption = CSenXmlElement::NewL(KSenOption);
+ CleanupStack::PushL(pOption);
+ pOption->CopyFromL(*options[i]);
+ pOptionAsXml = pOption->AsXmlL();
+ CleanupStack::PushL(pOptionAsXml);
+ ws.WriteL(*pOptionAsXml);
+ CleanupStack::PopAndDestroy(2); // pOptionAsXml, pOption
+ }
+ ws.WriteL(KDiscoOptionsEnd);
+ }
+
+ ws.WriteL(KDiscoReqEnd);
+
+ CleanupStack::PopAndDestroy(); // ws.Close();
+
+ TPtr8 p8 = pFlat->Ptr(0);
+ HBufC8* pReq8 = p8.AllocL();
+ CleanupStack::PopAndDestroy( pFlat );
+
+#ifdef _SENDEBUG
+ CleanupStack::PushL( pReq8 );
+ if( pReq8 )
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel ,(_L8("Returning Discovery Service Lookup Request:")));
+ TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel ,(*pReq8));
+
+ }
+ CleanupStack::Pop( pReq8 ); // pReq8 == return value
+#endif // _SENDEBUG
+ options.ResetAndDestroy();
+ CleanupStack::Pop(); // options
+ return pReq8;
+ }
+
+TInt CIdWsfDiscoveryServiceClient::DSOptionsL(
+ RFacetArray& aOptionArray,
+ MSenServiceDescription& aServiceDescription)
+ {
+ TInt retVal = KErrNone;
+
+ RFacetArray facets;
+ CleanupClosePushL(facets);
+ aServiceDescription.FacetsL(facets);
+
+ CSenFacet* pFacet = NULL;
+ TInt count(facets.Count());
+ for (TInt i=0; i<count && retVal == KErrNone; i++)
+ {
+ if (facets[i]->Type() == KDiscoOption)
+ {
+ pFacet = CSenFacet::NewL(*facets[i]);
+ retVal = aOptionArray.Append(pFacet);
+ }
+ }
+ facets.ResetAndDestroy();
+ CleanupStack::Pop(); //facets
+
+ return retVal;
+ }
+
+
+
+
+TBool CIdWsfDiscoveryServiceClient::HasSuperClass( TDescriptionClassType aType )
+ {
+ if( aType == MSenServiceDescription::ECoreServiceConsumer ) // direct superclass!
+ {
+ // If asked type is the know *direct* father/mother, return true:
+ return ETrue;
+ }
+ else
+ {
+ // Otherwise, ask from superclass (chain, recursively)
+ return CIdWsfCoreServiceConsumer::HasSuperClass( aType );
+ }
+ }
+
+void CIdWsfDiscoveryServiceClient::SetDataTrafficDetails( TSenDataTrafficDetails& aDetails)
+ {
+ iDiscDetails = aDetails;
+ }
+// End of File
+