1 /*

     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:           

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include "senwebservicesession.h"

    22 

    23 #include <SenServiceConnection.h> // error codes etc

    24 

    25 #include "senservicesession.h"

    26 #include "SenServiceConnection.h" // session status constants

    27 #include "SenSoapMessage.h"

    28 #include "senwsdescription.h"

    29 #include "msencoreservicemanager.h"

    30 #include "msenremoteserviceconsumer.h"

    31 #include "SenXmlUtils.h"

    32 #include "SenDateUtils.h"

    33 #include "msentransport.h"

    34 #include "SenCredential.h"

    35 //#include "SenPolicy.h"

    36 #include "SenSoapFault.h"

    37 #include "sendebug.h"

    38 #include "senservicemanagerdefines.h"

    39 #include "senservicepolicy.h"

    40 #include "seninternalcredential.h"

    41 #include "sensaxutils.h"

    42 #include <xmlengnodelist.h>

    43 #include <SenIdentityProvider.h>

    44 #include "senlogger.h"

    45 #include <SenXmlConstants.h>

    46 

    47 #include <SenTransportProperties.h>

    48 // CONSTANTS

    49 

    50 namespace

    51     {

    52     _LIT8(KServiceInterval1,"ServiceInterval");

    53     _LIT(KInvalideDate,"19000101:");

    54     /* microseconds before actual notOnOrAfter time

    55      * when credentials are treated

    56      * as expired.

    57      */

    58     const TInt KClockSlipMicroSeconds = 3*60*1000*1000;

    59 

    60     // constants for parsing

    61     _LIT8(KSDFramework,"<ServiceDescription framework=\"");

    62     _LIT8(KContractStart, "<Contract>");

    63     _LIT8(KContractEnd, "</Contract>");

    64     _LIT8(KTagWithAttrEnd, "\">");

    65     _LIT8(KEndPointStart, "<Endpoint>");

    66     _LIT8(KEndPointStartWithCue, "<Endpoint cue=\"");   

    67     _LIT8(KTagWithAttrClose, "\"/>"); 

    68     _LIT8(KEndPointEnd, "</Endpoint>");

    69     _LIT8(KCredentialsStart, "<Credentials");

    70     _LIT8(KCredentialsEnd, "</Credentials>");

    71     _LIT8(KNotOnOrAfterFormat, " notOnOrAfter=\"%S\" >");

    72     _LIT8(KEmptyTagEnd, " >");

    73     _LIT8(KSDEnd, "</ServiceDescription>");

    74     // localnames for element(s)

    75     _LIT8(KProviderPolicyLocalName, "ProviderPolicy");

    76     _LIT8(KNewLine, "\n");

    77     

    78     const TInt KCredIdBufSize           = 128;

    79     _LIT8(KCredentialIdLocalName,       "SenCredentialId");

    80     _LIT8(KCredentialIdStart,           "<SenCredentialId>");

    81     _LIT8(KCredentialIdEnd,             "</SenCredentialId>");

    82     _LIT8(KEndpointLocalname,           "Endpoint");

    83 //    _LIT8(KContractLocalname,           "Contract");

    84     }

    85 

    86 EXPORT_C CSenWebServiceSession::CSenWebServiceSession(TDescriptionClassType aType,

    87                                                       MSIF& aFramework)

    88 :   CSenServiceSession(aType, aFramework)

    89     {

    90     }

    91 

    92 EXPORT_C void CSenWebServiceSession::ConstructL()

    93     {

    94 

    95     // Sets the local name to "ServiceDescription"

    96     // and initiates the inner ipElement

    97     CSenServiceSession::BaseConstructL();

    98     // Init member variables

    99     iClientServerInterval = 0;

   100     iValidUntil = Time::NullTTime();

   101     iFrameworkId = iFramework.Id().AllocL();

   102     }

   103 

   104 EXPORT_C CSenWebServiceSession::~CSenWebServiceSession()

   105     {

   106     delete iSecurity;

   107     delete iContract;

   108     delete iEndpoint;

   109     delete iFrameworkId;

   110     iFrameworkId = NULL;

   111     delete iTransportCue;

   112     iTransportCue = NULL;

   113     iCredentialPtr.RemoveCredentialObserver(*this);

   114     iCredentialPtr.Close();

   115     }

   116 

   117 EXPORT_C TPtrC8 CSenWebServiceSession::TransportCue()

   118     {

   119     if( iTransportCue )

   120         {

   121         return *iTransportCue;

   122         }

   123     else 

   124         {

   125         return CSenServiceSession::TransportCue();

   126         }

   127     }

   128 

   129 EXPORT_C TInt CSenWebServiceSession::InitializeFromL(MSenServiceDescription& aServiceDescription)

   130     {

   131    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,_L("Zapping filelogged messages (.xml)"));

   132     

   133     // Call superclass method to initialize facets, transport (endpoint) cue, etc..

   134 	CSenServiceSession::InitializeFromL(aServiceDescription);

   135 

   136     HBufC8* pContract = aServiceDescription.Contract().AllocL();

   137     delete iContract;

   138     iContract = pContract;

   139     

   140     HBufC8* pEndpoint = aServiceDescription.Endpoint().AllocL();

   141     delete iEndpoint;

   142     iEndpoint = pEndpoint;

   143 

   144     if(aServiceDescription.DescriptionClassType()

   145                         ==

   146         MSenServiceDescription::EWSDescription

   147                         ||

   148         aServiceDescription.DescriptionClassType()

   149                         ==

   150         MSenServiceDescription::EWSPattern

   151                         ||

   152         aServiceDescription.DescriptionClassType()

   153                         ==

   154         MSenServiceDescription::EIdentityProvider

   155         )

   156         {

   157 

   158         CSenWSDescription& xmlDesc =

   159                             (CSenWSDescription&)aServiceDescription;

   160 

   161         CSenElement* pElement =

   162                     (xmlDesc.AsElement()).Element(KServiceInterval1);

   163         if(pElement)

   164             {

   165             TLex8 lex(pElement->Content());

   166             TInt64 val;

   167             User::LeaveIfError(lex.Val(val));

   168             iClientServerInterval = val;

   169 			TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase, KNormalLogLevel , _L8("Interval in microseconds (from file): %d"),

   170                                 iClientServerInterval.Int64()));

   171             }

   172 

   173         RCredentialList& credentials = xmlDesc.Credentials();

   174         TInt count(credentials.Count());

   175         for(TInt i=0; i<count; i++)

   176             {

   177             CSenCredential* pCredential = credentials[i];

   178             if(pCredential)

   179                 {

   180                 // note: errors while adding single credential must ignored:

   181                 // - the remaining credentials (array) must be processed..

   182 

   183                 //CSenCredential* pCopy = CSenCredential::NewL(*pCredential);

   184                 //CleanupStack::PushL(pCopy);

   185                 AddCredentialL(*pCredential);

   186                 //CleanupStack::Pop(); // pCopy

   187                 }

   188             }

   189         // rebuild provider policy definition

   190         RebuildFrom(xmlDesc);

   191         // update provider policy information (new feature)

   192 

   193         MSenServicePolicy* servicePolicy = ServicePolicy();

   194         if(servicePolicy)

   195             {

   196             MSenServicePolicy* givenServicePolicy = xmlDesc.ServicePolicy();

   197             if(givenServicePolicy)

   198                 (CSenServicePolicy*)servicePolicy->RebuildServicePolicyFrom(*givenServicePolicy);

   199             }            

   200         }

   201     SetStatusL();

   202     return KErrNone; // err value not currently in use

   203     }

   204 

   205 EXPORT_C TInt CSenWebServiceSession::ComputeStatusL()

   206     {

   207     TInt retVal = CSenServiceSession::ComputeStatusL();

   208 

   209     if (retVal == KSenConnectionStatusReady)

   210         {

   211         TTime now;

   212         now.UniversalTime();

   213         now += iClientServerInterval;

   214 

   215 #ifdef _SENDEBUG

   216             if (iValidUntil != Time::NullTTime())

   217                 {

   218 			TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase, KNormalLogLevel , _L8("Client-Server Interval in microseconds: %d"),

   219                                     iClientServerInterval.Int64()));

   220                 

   221                 TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts;

   222                 TInt leaveCode(KErrNone);

   223                 TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts, now);)

   224                 if (leaveCode == KErrNone)

   225                     {

   226                     

   227 					TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Fixed client time : %S"), &ts));

   228                 

   229                     TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts2;

   230                     TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts2, iValidUntil);)

   231 			     TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Credential time : %S, clockslip: %d micros"), &ts2, KClockSlipMicroSeconds));

   232                     }

   233                 leaveCode = 0; // not used

   234                 }

   235 #endif // _SENDEBUG

   236 

   237         if ((iValidUntil != Time::NullTTime() ) &&

   238             now >

   239             (iValidUntil-TTimeIntervalMicroSeconds(KClockSlipMicroSeconds)))

   240             {

   241 			TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,_L("Credential is expired."));

   242             retVal = KSenConnectionStatusExpired;

   243             }

   244         }

   245     return retVal;

   246     }

   247 

   248 EXPORT_C TBool CSenWebServiceSession::IsExpiredL()

   249     {

   250     ComputeStatusL();

   251     return (CSenServiceSession::StatusL() == KSenConnectionStatusExpired);

   252     }

   253 

   254 EXPORT_C TInt CSenWebServiceSession::AddCredentialL(

   255                                                 CSenCredential& aCredential)

   256     {

   257     if ( aCredential.AsElement().LocalName() == KCredentialIdLocalName )

   258         {

   259         delete iSecurity;

   260         iSecurity = NULL;

   261         iSecurity = aCredential.AsXmlL();

   262         

   263         TInt credentialId;

   264         TLex8 lex;

   265         lex.Assign(aCredential.AsElement().Content());

   266         lex.Val(credentialId);                        

   267 

   268         TInt error(KErrNone);

   269         RSenCredentialPtr credentialPtr;

   270         credentialPtr = ((MSenServiceManager&)iFramework.Manager()).CredentialL(credentialId,

   271                                                                                 error);

   272         if ( error == KErrNone )

   273             {

   274             iCredentialPtr = credentialPtr.Clone();

   275             iCredentialPtr.AddCredentialObserverL(*this);		//codescannerwarnings

   276             iValidUntil = iCredentialPtr.Credential()->ValidUntil();

   277             if ( iClientServerInterval == 0 )

   278                 {

   279                 TPtrC8 value;

   280                 TInt ret = iCredentialPtr.Credential()->PropertiesL().PropertyL( KServiceInterval1,

   281                                                                                  value );

   282                 if ( ret == KErrNone )

   283                     {

   284                     TLex8 lex(value);

   285                     TInt64 val;

   286                     ret = lex.Val(val);

   287                     if ( ret == KErrNone )

   288                         {

   289                         iClientServerInterval = val;

   290                         }

   291                     }

   292                 }

   293             }

   294         else

   295             {

   296             // invalidate the session, because we have no credential 

   297             iValidUntil.Set(KInvalideDate); // way back in history: January 1st 1900

   298 

   299             iCredentialPtr.RemoveCredentialObserver(*this);

   300             iCredentialPtr.Close();

   301 

   302             delete iSecurity;

   303             iSecurity = NULL;

   304 

   305             TBuf8<KCredIdBufSize> buffer;

   306             buffer.Num(KErrNotFound);

   307 

   308             iSecurity = HBufC8::NewL(buffer.Length()+KCredentialIdStart().Length()+KCredentialIdEnd().Length());

   309             TPtr8 sec = iSecurity->Des();

   310             sec.Append(KCredentialIdStart);

   311             sec.Append(buffer);

   312             sec.Append(KCredentialIdEnd);

   313             }

   314         }

   315     else

   316         {

   317         TInt retVal(KErrNone);

   318 

   319         delete iSecurity;

   320         iSecurity = NULL;

   321         HBufC8* pSecurityToken = 0;

   322         retVal = ConstructSecurityTokenL(aCredential, pSecurityToken);

   323         if (KErrNone != retVal)

   324             {

   325             if ( pSecurityToken != NULL )

   326                 {

   327                 delete pSecurityToken;

   328                 pSecurityToken = NULL;

   329                 iCredentialPtr.RemoveCredentialObserver(*this);

   330                 iCredentialPtr.Close();

   331                 }

   332             return retVal;

   333             }

   334             

   335         iValidUntil = aCredential.ValidUntil(); // SetSecurityL needs up-to-date iValidUntil(!)

   336 

   337         CleanupStack::PushL(pSecurityToken);

   338         SetSecurityL(*pSecurityToken);

   339         CleanupStack::PopAndDestroy(pSecurityToken);

   340         }

   341         

   342     SetStatusL();

   343     

   344     return KErrNone;

   345     }

   346 

   347 EXPORT_C TInt CSenWebServiceSession::ConstructSecurityTokenL( CSenCredential& aCredential,

   348                                                               HBufC8*& aToken )

   349     {

   350     aToken = aCredential.AsXmlL();

   351     return KErrNone;

   352     }

   353 

   354 EXPORT_C TInt CSenWebServiceSession::NewMessageL( CSenSoapMessage*& aMessage )

   355     {

   356     aMessage = CSenSoapMessage::NewL();

   357     return KErrNone;

   358     }

   359 

   360 EXPORT_C TInt CSenWebServiceSession::MessageForSendingL( const TDesC8& aBody,

   361                                                          const TDesC8& /* aSenderID */,

   362                                                          CSenSoapMessage*& aMessage )

   363     {

   364     TInt retVal(KErrNone);

   365     aMessage = CSenSoapMessage::NewL();

   366     CleanupStack::PushL(aMessage);

   367     SetFrameworkHeadersL(*aMessage); 

   368     aMessage->SetBodyL(aBody);

   369     CleanupStack::Pop(); // aMessage

   370     return retVal;

   371     }

   372 

   373 EXPORT_C TInt CSenWebServiceSession::ParseResponseL( const TDesC8& aResponse,

   374                                                      HBufC8*& aParsed )

   375     {

   376 		TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenWebServiceSession::ParseResponseL(const TDesC8&, HBufC8*&)");

   377     // this called only from the synchronous submit(..) methods

   378     TInt retVal(KErrNone);

   379     CSenSoapMessage* pSoapMessage = NULL;

   380     retVal = ParseResponseL(aResponse, pSoapMessage);

   381     if(retVal!=KErrNone)

   382         {

   383         delete pSoapMessage;

   384         return retVal;

   385         }

   386 

   387     CleanupStack::PushL(pSoapMessage);

   388 

   389     // Check for completeMessages

   390     TBool completeServerMessages;

   391     HasFacetL(KCompleteMessagesFacet,completeServerMessages);

   392     if (completeServerMessages)

   393         {

   394         aParsed = pSoapMessage->AsXmlL();

   395         }

   396     else

   397         {

   398         // If the message contained SOAP fault it will be in the body.

   399         // It's up to the client to check for a Fault.

   400         aParsed = pSoapMessage->BodyAsStringL();

   401         if (!aParsed)

   402             {

   403             retVal = KErrSenNoSoapBody; 

   404 						TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenWebServiceSession::ParseResponseL - NULL from BodyAsStringL - return KErrSenNoSoapBody");

   405             }

   406         }

   407 

   408     CleanupStack::PopAndDestroy(); // pSoapMessage

   409     return retVal;

   410     }

   411 

   412 

   413 EXPORT_C TInt CSenWebServiceSession::SendSoapMessageToConsumerL( CSenSoapMessage* apMessage,

   414                                                                  const TInt aTxnId,

   415                                                                  MSenRemoteServiceConsumer& aConsumer,

   416                                                                  MSenProperties* aResponseTransportProperties )

   417     {

   418     if ( !apMessage )

   419         {

   420         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SendSoapMessageToConsumerL");

   421         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"Fatal()!: NULL argument passed instead of valid pointer to CSenSoapMessage");

   422         return HandleErrorL( KErrSenInternal, NULL, aTxnId, aConsumer, aResponseTransportProperties );

   423         }

   424 

   425     CleanupStack::PushL(apMessage);

   426     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SendSoapMessageToConsumerL");

   427     TInt retVal(KErrNone);

   428     // Check if consumer wishes to receive complete server messages:

   429     TBool completeServerMessages;

   430     HasFacetL(KCompleteMessagesFacet, completeServerMessages);

   431     if(completeServerMessages)

   432         {

   433         HBufC8* pMessageAsXML = apMessage->AsXmlL();

   434         CleanupStack::PopAndDestroy(apMessage);

   435         if (pMessageAsXML)

   436             {

   437             retVal = aConsumer.HandleMessageL( pMessageAsXML, aTxnId, aResponseTransportProperties );

   438             }

   439         }

   440     else

   441         {

   442         //HBufC8* pBody = apMessage->BodyL().Content().AllocL(); 

   443         HBufC8* pBody = apMessage->BodyAsStringL();

   444         CleanupStack::PopAndDestroy(apMessage);

   445         retVal = aConsumer.HandleMessageL( pBody, aTxnId, aResponseTransportProperties );

   446         }    

   447     return retVal;

   448     }

   449 

   450 // SYNC, takes ownership of apSoapMessage

   451 EXPORT_C TInt CSenWebServiceSession::HandleSoapFaultL( CSenSoapMessage* apSoapMessage,

   452                                                        HBufC8*& aResponse /*,

   453                                                        CSenTransportProperties*& aResponseTransportProperties */) 

   454     {

   455     if( apSoapMessage )

   456         {

   457         CleanupStack::PushL(apSoapMessage);

   458         CSenSoapFault* pDetached = apSoapMessage->DetachFaultL();

   459         CleanupStack::PopAndDestroy( apSoapMessage );

   460         TBool completeServerMessages(ETrue);

   461         HasFacetL(KCompleteMessagesFacet, completeServerMessages);

   462         if(pDetached)

   463             {

   464             CleanupStack::PushL(pDetached);

   465             // Response contains only soapfault in case no completeServerMessages facet 

   466             // otherwise it should be left empty

   467             // aResponse is updated only when detached soap fault is required.

   468             if(completeServerMessages == EFalse)

   469             	{

   470             	aResponse = pDetached->AsXmlL();	

   471             	}

   472 						TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenWebServiceSession::HandleErrorL:");

   473 						TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"- successfully detached SOAP fault:");

   474             CleanupStack::PopAndDestroy(pDetached); // pDetached

   475             // From *this* method, KErrSenSoapFault is *OK return code*, 

   476             // just like KErrNone generally is..

   477             return KErrSenSoapFault; 

   478             }

   479         }

   480     return KErrNotFound; // SOAP fault not found

   481     }

   482 

   483 // ASYNC, takes ownership of apSoapMessage

   484 EXPORT_C TInt CSenWebServiceSession::HandleSoapFaultL( CSenSoapMessage* apSoapMessage,

   485                                                        const TInt aErrorCode,

   486                                                        const TInt aTxnId,

   487                                                        MSenRemoteServiceConsumer& aConsumer,

   488                                                        MSenProperties* aResponseTransportProperties )

   489     {

   490     TInt retVal( KErrSenInternal );

   491     if ( apSoapMessage ) 

   492         {

   493         CleanupStack::PushL(apSoapMessage); // ownership is here

   494     

   495         CSenSoapFault* pDetached = apSoapMessage->DetachFaultL();

   496         if(pDetached)

   497             {

   498             CleanupStack::PopAndDestroy( apSoapMessage ); // de-alloc msg, detach OK

   499             

   500             CleanupStack::PushL(pDetached);

   501             HBufC8* pAsXml = pDetached->AsXmlL();

   502             CleanupStack::PopAndDestroy(pDetached);

   503             

   504             retVal = aConsumer.HandleErrorL(pAsXml, aErrorCode, aTxnId, aResponseTransportProperties);

   505             }

   506         else

   507             {

   508             // Could not detach Soap fault (this method was called, but aSoapMessage did not include fault!)

   509             HBufC8* pAsXml = apSoapMessage->AsXmlL();

   510             CleanupStack::PopAndDestroy( apSoapMessage ); // de-alloc, serialization ok

   511             retVal = aConsumer.HandleErrorL(pAsXml, aErrorCode, aTxnId, aResponseTransportProperties);

   512             }

   513         }

   514     else

   515         {

   516         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"Fatal(!): CSenWebServiceSession::HandleSoapFaultL - apSoapMessage arg is NULL. ");

   517             retVal = aConsumer.HandleErrorL(NULL, aErrorCode, aTxnId, aResponseTransportProperties);

   518         }        

   519     return retVal;

   520     }

   521 

   522 EXPORT_C TInt CSenWebServiceSession::SendToConsumerL( HBufC8* apMessage,

   523                                                       const TInt aTxnId,

   524                                                       MSenRemoteServiceConsumer& aConsumer,

   525                                                       MSenProperties* aResponseTransportProperties )

   526     {

   527     CleanupStack::PushL( apMessage );

   528     CSLOG_L( aConsumer.ConnectionId(), KMinLogLevel,"CSenWebServiceSession::SendToConsumerL - begin" );

   529     TInt retVal(KErrNone);

   530 

   531     // Check whether this is a response to one-way request; in such case, 

   532     // there is no body to validate (but only few response properties):

   533     if ( aResponseTransportProperties )

   534         {

   535         TBool isOnewayMsgRsp(EFalse);

   536         aResponseTransportProperties->BoolPropertyL( KSenOnewayMessageOnOff, isOnewayMsgRsp );

   537         if ( isOnewayMsgRsp )

   538             {

   539             // There is no response body to process, halt the execution of this method in here,

   540             // and invoke the consumer immediately:

   541             CSLOG_L( aConsumer.ConnectionId(), KMinLogLevel,"-- About to invoke MSenRemoteServiceConsumer::HandleMessageL" );

   542             CleanupStack::Pop( apMessage );

   543             retVal = aConsumer.HandleMessageL( apMessage, aTxnId, aResponseTransportProperties );

   544             CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("CSenWebServiceSession::SendToConsumerL - end: HandleMessageL returned: %d"), retVal));

   545             return retVal; // skip the SOAP validation, response carries no body

   546             }

   547         }

   548 

   549     

   550     // SOAP orientated implementation:

   551     CSenSoapMessage* pSoapMessage = NULL;

   552     TInt leaveCode(KErrNone); 

   553     

   554     if( apMessage && apMessage->Length() > 0 )

   555         {

   556         TRAP( leaveCode, retVal = ParseResponseL( *apMessage, pSoapMessage ); )

   557         }

   558     else // apMessage == NULL or descriptor is of zero-length

   559         {

   560         if ( !apMessage )

   561             {

   562             CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Note: apMessage argument is NULL => response is treated through KErrSenNoSoapBody");

   563             }    

   564         retVal = KErrSenNoSoapBody; // clearly, WSS assumes that all messages are SOAP!

   565         }

   566         

   567     if( leaveCode != KErrNone )

   568         {

   569         // Parsing WAS attempted, but it failed(!)  

   570         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SendToConsumerL");

   571         CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- Error: response could not be parsed into SOAP msg, leave code from parse: %d"), leaveCode));

   572         pSoapMessage = NULL;

   573         if( retVal==KErrNone )

   574             {

   575             // indicate with return value, that response is

   576             // invalid - even though submit was ok, the

   577             // response could NOT be parsed!

   578             retVal = leaveCode;

   579             }

   580         }

   581         

   582     if(retVal == KErrNone)

   583         {

   584         CleanupStack::PopAndDestroy(apMessage);

   585         CleanupStack::PushL( pSoapMessage );

   586         // Response was parsed OK, now check whether it is a SOAP fault:

   587         if (pSoapMessage->IsFault())

   588             {

   589             CleanupStack::Pop(pSoapMessage); // next method takes the ownership:

   590             retVal = HandleSoapFaultL(pSoapMessage, KErrSenSoapFault, aTxnId, aConsumer, aResponseTransportProperties);

   591             if( retVal == KErrSenSoapFault )

   592                 {

   593                 // SOAP fault response is treated as "OK"

   594                 retVal = KErrNone;

   595                 }

   596             }

   597         else

   598             {

   599             // Response is a valid SOAP envelope

   600             CSLOG_L(aConsumer.ConnectionId()  ,  KMinLogLevel ,"CSenWebServiceSession::SendToConsumerL:");

   601             CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel ,"- Sending SOAP message to consumer.");

   602             CleanupStack::Pop(pSoapMessage); // next method takes the ownership:

   603             retVal = SendSoapMessageToConsumerL( pSoapMessage, aTxnId, aConsumer, aResponseTransportProperties );

   604 #ifdef _SENDEBUG

   605             if( retVal!=KErrNone )

   606                 {

   607                 CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SendToConsumerL:");

   608                 CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- SendSoapMessageToConsumerL failed: %d"), retVal ));

   609                 }

   610 #endif

   611             }

   612         }

   613     else // error recognized

   614         {

   615         delete pSoapMessage;

   616         pSoapMessage = NULL;

   617         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SendToConsumerL");

   618         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Error: response is not a SOAP message!");

   619         

   620         CleanupStack::Pop(apMessage);

   621         retVal = HandleErrorL(retVal, apMessage, aTxnId, aConsumer, aResponseTransportProperties);

   622         }

   623     CSLOG_L( aConsumer.ConnectionId(), KMinLogLevel,"CSenWebServiceSession::SendToConsumerL - end" );        

   624     return retVal;

   625     }

   626 

   627 // THIS IS WHAT TRANSPORT SEES:

   628 EXPORT_C TInt CSenWebServiceSession::SendErrorToConsumerL( const TInt aErrorCode,

   629                                                            HBufC8* apError,

   630                                                            const TInt aTxnId,

   631                                                            MSenRemoteServiceConsumer& aConsumer,

   632                                                            MSenProperties* aResponseTransportProperties )

   633     {

   634     CleanupStack::PushL(apError);

   635     TInt retVal(KErrNone);

   636 

   637     // Check whether this is a response to one-way request; in such case, 

   638     // there is no body to validate (but only few response properties):

   639     if ( aResponseTransportProperties )

   640         {

   641         TBool isOnewayMsgRsp(EFalse);

   642         aResponseTransportProperties->BoolPropertyL( KSenOnewayMessageOnOff, isOnewayMsgRsp );

   643         if ( isOnewayMsgRsp )

   644             {

   645             // There is no response body to process, halt the execution of this method in here,

   646             // and invoke the consumer immediately:

   647             CSLOG_L( aConsumer.ConnectionId(), KMinLogLevel,"-- About to invoke MSenRemoteServiceConsumer::HandleMessageL" );

   648             CleanupStack::Pop( apError );

   649             retVal = aConsumer.HandleErrorL( apError, aErrorCode, aTxnId, aResponseTransportProperties );

   650             CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("CSenWebServiceSession::SendToConsumerL - end: HandleMessageL returned: %d"), retVal));

   651             return retVal; // skip the SOAP validation, response carries no body

   652             }

   653         }

   654     

   655     // SOAP orientated implementation:

   656     CSenSoapMessage* pSoapMessage = NULL;

   657     

   658         TInt leaveCode(KErrNone); 

   659     

   660     if( apError && apError->Length() > 0 )

   661         {

   662         TRAP( leaveCode, retVal = ParseResponseL( *apError, pSoapMessage ); )

   663         }

   664     else // apMessage == NULL or descriptor is of zero-length

   665         {

   666         if ( !apError )

   667             {

   668             CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Note: apError argument is NULL => response is treated through KErrSenNoSoapBody");

   669             }    

   670         retVal = KErrSenNoSoapBody; // clearly, WSS assumes that all messages are SOAP!

   671         }

   672     

   673     if( leaveCode != KErrNone )

   674         {

   675         // Parsing WAS attempted, but it failed(!)

   676         pSoapMessage = NULL;

   677         

   678         // THE RESPONSE IS NOT SOAP

   679         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SendErrorToConsumerL");

   680         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Error: response could not be parsed into SOAP msg!");

   681         CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- ParseResponseL leaved: %d"), leaveCode ));

   682         if( aErrorCode == KErrNone )

   683             {

   684             // In this rare case, indicate that SOAP envelope was broken!

   685             // So, return KErrSenBrokenSoapEnvelope in here.

   686             CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- aErrorCode==KErrNone, but SOAP env is broken!");

   687             

   688             CleanupStack::Pop(apError);

   689             retVal = HandleErrorL(KErrSenBrokenSoapEnvelope, apError, aTxnId, aConsumer, aResponseTransportProperties);

   690             }

   691         else

   692             {

   693             CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- Returning error code received from transport: %d"), 

   694                 aErrorCode));

   695 

   696             CleanupStack::Pop(apError);

   697             retVal = HandleErrorL(aErrorCode, apError, aTxnId, aConsumer, aResponseTransportProperties);

   698             }

   699         }

   700     else // ParseResponseL did not leave 

   701         {

   702         if (retVal == KErrNone )

   703             {

   704             CleanupStack::PopAndDestroy(apError);

   705             // ParseResponseL OK

   706             // Call for functionality which checks certain, "recoverable" SOAP errors:

   707             // Some frameworks might be able to handle certain SOAP faults themselves

   708             retVal = HandleSoapFaultL(pSoapMessage, aErrorCode, aTxnId, aConsumer, aResponseTransportProperties);

   709             }

   710         else // parsing failed or apError == NULL

   711             {

   712             delete pSoapMessage;

   713             // ParseResponseL NOT ok!

   714             CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SendErrorToConsumerL");

   715             CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Error: response is not a SOAP message!");

   716             if ( aErrorCode == KErrNone )

   717                 {

   718                 // Rare case: for some odd reason transport did not return error code:

   719                 // - return the error code from ParseResponseL

   720                 CSLOG_L(aConsumer.ConnectionId()  , KNormalLogLevel,"- Transport did not return error code.");

   721                 CleanupStack::Pop(apError);

   722                 retVal = HandleErrorL(retVal, apError, aTxnId, aConsumer, aResponseTransportProperties);

   723                 }

   724             else

   725                 {

   726                 // Just pass forward the error code received from transport:

   727                 CSLOG_L(aConsumer.ConnectionId()  , KNormalLogLevel,"- Just pass forward error code from transport.");

   728                 CleanupStack::Pop(apError);

   729                 retVal = HandleErrorL(aErrorCode, apError, aTxnId, aConsumer, aResponseTransportProperties);

   730                 }

   731             }

   732         }

   733     return retVal;

   734     }

   735 

   736 EXPORT_C TInt CSenWebServiceSession::HandleErrorL( const TInt aErrorCode,

   737                                                    HBufC8* apError,

   738                                                    const TInt aTxnId,

   739                                                    MSenRemoteServiceConsumer& aConsumer,

   740                                                    MSenProperties* aResponseTransportProperties )

   741     {

   742     // Current implementation does not handle non-SOAP errors 

   743     // that occured at transport layer. Instead, the error is

   744     // simply passed to consumer:

   745     return aConsumer.HandleErrorL(apError, aErrorCode, aTxnId, aResponseTransportProperties); 

   746     // Frameworks should override this method in order to recover

   747     // from specific errors/faults

   748     }

   749 

   750 

   751 EXPORT_C CSenXmlReader* CSenWebServiceSession::XmlReader()

   752     {

   753     return iFramework.Manager().XMLReader();

   754     }

   755 

   756 EXPORT_C TInt CSenWebServiceSession::ParseResponseL(const TDesC8& aResponse,

   757                                                     CSenSoapMessage*& aMessage)

   758     {

   759 		TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenWebServiceSession::ParseResponseL(TDesC8&, CSenSoapMessage*&");

   760 

   761     TInt retVal(KErrNone);

   762     retVal = NewMessageL(aMessage);

   763 

   764     CleanupStack::PushL(aMessage);

   765 

   766     if (retVal != KErrNone)

   767         {

   768         return retVal;

   769         }

   770 

   771     //////////////////////////////////////////////////////////////////////////

   772 		TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,(_L("******************************************************")));

   773 		TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KMaxLogLevel  , _L("Response to be parsed (%d bytes):"), aResponse.Length()));

   774         {

   775 				TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,aResponse);

   776         //FILELOGALL(_L("WsLog"), _L("last_rsp.xml"), aResponse);

   777         }

   778 		TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,(_L("******************************************************")));

   779     //////////////////////////////////////////////////////////////////////////

   780 

   781     aMessage->SetReader(*XmlReader());

   782     TInt leaveCode(KErrNone);

   783 		TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"- Parsing response into SOAP message object:");

   784     TBool normalParsing(ETrue);

   785     if ( aResponse.Size() > KSenMaxLengthSaxParsingSoapMsg )

   786         {

   787         TInt ret(KErrNotFound);

   788         TRAP(leaveCode, ret = HandleBodyWithoutParsingL(*aMessage, aResponse);)

   789         if (leaveCode == KErrNone && ret == KErrNone)

   790             {

   791             normalParsing = EFalse;

   792             }

   793         }

   794     

   795     if ( normalParsing )

   796         {

   797         TRAP(leaveCode, aMessage->ParseL(aResponse));

   798         }

   799     

   800     if(leaveCode==KErrNone)

   801         {

   802 #ifdef _SENDEBUG

   803         ///////////////////////////////////////////////////////////////////////

   804         TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,(_L("---------------------------------------------------")));

   805         HBufC8* pAsXml = aMessage->AsXmlL();

   806         if(pAsXml)

   807             {

   808             CleanupStack::PushL(pAsXml);

   809 						TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"CSenWebServiceSession::ParseResponseL: OK!");

   810 						TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KMaxLogLevel  , _L(" SOAP message (%d bytes)"),

   811                                 pAsXml->Length()));

   812 						TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,(*pAsXml));

   813             CleanupStack::PopAndDestroy(); //pAsXml

   814             }

   815 				TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel ,(_L("---------------------------------------------------")));

   816         ///////////////////////////////////////////////////////////////////////

   817 #endif // _SENDEBUG

   818         retVal = ParseMessageL(*aMessage);

   819         }

   820     else

   821         {

   822 				TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel ,"- Response is not SOAP message!");

   823         retVal = leaveCode;

   824         }

   825     CleanupStack::Pop(); // aMessage

   826     return retVal;

   827     }

   828 

   829 EXPORT_C TInt CSenWebServiceSession::ParseMessageL(CSenSoapMessage& aSoapMessage)

   830     {

   831     // We can verify, that SOAP message has Body:

   832     if(!aSoapMessage.HasBody())

   833         {

   834         return KErrSenNoSoapBody;

   835         }

   836     else

   837         {

   838         return KErrNone;

   839         }

   840     /**

   841      * We could verify wsse:Security headers

   842      * but we don't have a need for that right now.

   843      */

   844     }

   845 

   846 EXPORT_C TInt CSenWebServiceSession::AddConsumerL(MSenRemoteServiceConsumer& aConsumer)

   847     {

   848     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::AddConsumerL");

   849     iConsumerList.Reset(); 

   850     TInt retVal = iConsumerList.Append(&aConsumer);

   851     return retVal;

   852     }

   853 

   854 // 2005: refactored GetConsumer() to Consumer()

   855 // Note: Same as client() in Java Ref. Impl.

   856 EXPORT_C MSenRemoteServiceConsumer* CSenWebServiceSession::Consumer()

   857     {

   858     TInt count(iConsumerList.Count());

   859     if(count>0)

   860         {

   861         return iConsumerList[0];

   862         }

   863     else

   864         {

   865         return NULL;

   866         }

   867     }

   868 

   869 EXPORT_C TBool CSenWebServiceSession::IsReadyL()

   870     {

   871     return (CSenServiceSession::StatusL() == KSenConnectionStatusReady);

   872     }

   873 

   874 EXPORT_C TInt CSenWebServiceSession::SubmitL(const TDesC8& aMessage,

   875                                              const TDesC8& aTransportProperties,

   876                                              MSenRemoteServiceConsumer& aConsumer,

   877                                              HBufC8*& aResponse /*,

   878                                              CSenTransportProperities*& apResponseTransportProperties */)

   879     {

   880     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL");

   881 

   882     CSenSoapMessage* pMsg = NULL;

   883     TInt retVal( MessageForSendingL(aMessage, aConsumer.Id(), pMsg) ); 

   884     CleanupStack::PushL(pMsg);

   885 

   886     if(retVal!=KErrNone)

   887         {

   888          CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- MessageForSendingL returned an error: %d"), retVal));

   889         CleanupStack::PopAndDestroy(); // pMsg

   890         return retVal;

   891         }

   892 

   893     HBufC8* pHttpBody = pMsg->AsXmlL();

   894     if ( pHttpBody )

   895         {

   896         TPtrC8 endpoint = Endpoint();

   897         CleanupStack::PushL(pHttpBody);

   898         TPtr8 httpBody = pHttpBody->Des();

   899         CSLOG_L(aConsumer.ConnectionId()  , KMaxLogLevel,"////////////////////////////////////////////////////////");

   900         CSLOG_FORMAT((aConsumer.ConnectionId() , KMaxLogLevel, _L8("- Endpoint: %S"), &endpoint));

   901         CSLOG_FORMAT((aConsumer.ConnectionId() , KMaxLogLevel, _L8("- Message (%d) about to submit:"),

   902                             httpBody.Length()));

   903         //CSLOG_ALL(aConsumer.ConnectionId()  , KMaxLogLevel,(httpBody));

   904 //wslog        FILELOGALL(_L("WsLog"), _L("last_req.xml"), httpBody);

   905         CSLOG_L(aConsumer.ConnectionId()  , KMaxLogLevel,"////////////////////////////////////////////////////////");

   906 

   907 

   908         MSenTransport& transport = aConsumer.TransportL();

   909         retVal = transport.SubmitL(endpoint, httpBody, aTransportProperties, aResponse, aConsumer);

   910 

   911         CleanupStack::PopAndDestroy(); // pHttpBody

   912         }

   913 

   914     CleanupStack::PopAndDestroy(); //  pMsg

   915 

   916     if ( !aResponse )

   917         {

   918         // Response was NULL: probably either out

   919         // of heap or some transport malfunction.

   920         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL:");

   921         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Received NULL from transport.");

   922         return retVal;

   923         }

   924 

   925     else if( aResponse->Length() < KSenSoapEnvelopeName().Length()*2 )

   926         {

   927         // No use parsing, Envelope -root element not there

   928 

   929         // deliver non-soap body to consumer

   930         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL:");

   931         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- response is not a SOAP envelope.");

   932         return retVal;

   933         }

   934 

   935     CSenSoapMessage* pResponseSoapMsg = NULL;

   936     TInt leaveCode(KErrNone);

   937     TInt parseRetVal(KErrNone);

   938     TRAP( leaveCode, parseRetVal = ParseResponseL(*aResponse, pResponseSoapMsg));

   939 

   940     if( leaveCode!=KErrNone ) // parsing leaved!

   941         {

   942 

   943         pResponseSoapMsg = NULL; 

   944 

   945         // Return directly the response, which was received from

   946         // transport. Note that pResponseSoapMsg has already

   947         // been deleted because of leave

   948         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel , "CSenWebServiceSession::SubmitL:");

   949        CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel , "- Error: response could not be parsed into SOAP msg!");

   950         

   951         CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- ParseResponseL leaved: %d"), leaveCode ));

   952 

   953         retVal = leaveCode;

   954         // else return the error code received from transport (retVal)

   955         }

   956     else // parsing did not leave..

   957         {

   958         if ( parseRetVal != KErrNone ) // .. but parsing failed

   959             {

   960             // Not mandatory, ParseResponseL should take 

   961             // care of gc, if it returns an error:

   962             delete pResponseSoapMsg; 

   963 

   964             // NOTE - 2005 change: now the body of such

   965             // response will be returned to the caller

   966             // (with the error code).

   967 

   968             // Response could not be parsed into SOAP message(!)

   969             CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- Response could not be parsed, error: (%d)"),

   970                 parseRetVal));

   971 

   972             if(retVal==KErrNone)

   973                 {

   974                 CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Returning error code from ParseResponseL");

   975                 // transport did not return error, return error from ParseResponseL

   976                 retVal = parseRetVal;

   977                 }

   978             // else: return the error code received from transport

   979             }

   980         else // .. and parsing went ok

   981             {

   982             CleanupStack::PushL( pResponseSoapMsg );

   983             CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Response is a SOAP message");

   984 

   985             // Check whether "complete server messages" is on or off

   986             TBool completeServerMessages(EFalse);

   987             HasFacetL(KCompleteMessagesFacet, completeServerMessages);

   988 

   989             // Response is OK and SOAP message. 

   990             if( pResponseSoapMsg->IsFault() )

   991                 {

   992                 // Response is a SOAP fault

   993                 retVal = KErrSenSoapFault; // might change, if framework handles this fault

   994                 CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"Response is a SOAP fault. Calling HandleErrorL.");

   995 

   996                 // Check if SOAP fault could be handled by the framework:

   997                 HBufC8* pResponse = NULL;

   998 

   999                 // Note that HandleSoapFaultL -method normally detaches any SOAP fault:

  1000                 CleanupStack::Pop(pResponseSoapMsg);

  1001                 retVal = HandleSoapFaultL(pResponseSoapMsg, pResponse);

  1002                 if(retVal == KErrSenSoapFault)

  1003                     {

  1004                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL:");

  1005                     if( completeServerMessages )

  1006                         {

  1007                         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Returning SOAP envelope with fault");

  1008                         // The following lines are important when there is a resending

  1009                         // the new response is copied to aResponse.

  1010                         // When there is no resend, then pResponse = NULL no copy happens                     

  1011                         if(pResponse)

  1012                         	{

  1013                         	delete aResponse;

  1014                         	aResponse = pResponse;

  1015                         	}

  1016                         // aResponse will be returned (original response from transport)

  1017                         }

  1018                     else // we can pass the detached fault

  1019                         {

  1020                         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Returning detached a SOAP fault.");

  1021                         // Destroy the original response buffer received from transport,

  1022                         // since now the parsed SOAP envelope can be returned

  1023                         delete aResponse;

  1024                         aResponse = pResponse;

  1025                         }

  1026                     }

  1027                 else if ( retVal == KErrNone )

  1028                     {

  1029                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL:");

  1030                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Framework handled this SOAP fault.");

  1031                     // KErrNone means that fault was handled

  1032                     // properly (by framework spesific code)

  1033                     // and consumer may receive the response 

  1034                     // it requested.

  1035 

  1036                     // Currently there are no SOAP faults handled

  1037                     // in WebServiceSession class, so KErrNone is

  1038                     // never returned. This if -section is here 

  1039                     // only for *frameworks to extend*.

  1040 

  1041                     // Destroy the original response buffer received from transport,

  1042                     // since now the parsed SOAP envelope can be returned

  1043                     delete aResponse;

  1044                     aResponse = pResponse;

  1045                     }

  1046                 else if ( retVal == KErrNotFound )

  1047                     {

  1048                     // SOAP fault element  could not be found

  1049                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL - MAJOR:");

  1050                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"-IsFault()==true BUT fault element NOT found!");

  1051                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"-returning KErrSenBrokenSoapFault");

  1052                     retVal = KErrSenBrokenSoapFault;

  1053                     // Note: 2005 change: now the broken (original) response

  1054                     // from the transport is returned, instead of NULL

  1055                     }

  1056 #ifdef _SENDEBUG

  1057                 else 

  1058                     {

  1059                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL:");

  1060                     CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- HandleErrorL failed: %d"), retVal));

  1061                     }

  1062 #endif // _SENDEBUG

  1063 

  1064                 }

  1065             else // This SOAP envelope is NOT a fault

  1066                 {

  1067                 if ( completeServerMessages )

  1068                     {

  1069                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL:");

  1070                     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Returning complete SOAP envelope.");

  1071                     // Destroy the original response buffer received from

  1072                     // transport, since now the parsed SOAP envelope can

  1073                     // be returned

  1074 

  1075                     delete aResponse;

  1076                     aResponse = NULL;

  1077                     aResponse = pResponseSoapMsg->AsXmlL(); 

  1078                     }

  1079                 else

  1080                     {

  1081                     HBufC8* pBody = pResponseSoapMsg->BodyAsStringL();

  1082                     if(pBody)

  1083                         {

  1084                         // Destroy the original response buffer received from 

  1085                         // transport, since now the SOAP body must be returned

  1086                         delete aResponse;

  1087                         aResponse = pBody;

  1088                         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL:");

  1089                         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Detached SOAP message body.");

  1090                         }

  1091                     else

  1092                         {

  1093                         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SubmitL:");

  1094                         CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"- Could not detach SOAP body(!) - return KErrSenNoSoapBody");

  1095                         retVal = KErrSenNoSoapBody;

  1096                         }

  1097                     }

  1098                 CleanupStack::PopAndDestroy(pResponseSoapMsg);

  1099                 }

  1100             }

  1101         }

  1102 

  1103 #ifdef _SENDEBUG

  1104     if(aResponse)

  1105         {

  1106         CSLOG_L(aConsumer.ConnectionId()  , KMaxLogLevel,"-------------------------------------------------------------------");

  1107         CSLOG_FORMAT((aConsumer.ConnectionId() , KMaxLogLevel, _L8("Submit response (%d bytes):"),

  1108                             aResponse->Length()));

  1109         //CSLOG_ALL(aConsumer.ConnectionId()  , KMaxLogLevel,( *aResponse ));

  1110         CSLOG_L(aConsumer.ConnectionId()  , KMaxLogLevel,"-------------------------------------------------------------------");

  1111         }

  1112 #endif

  1113 

  1114     return retVal;

  1115     }

  1116 

  1117 EXPORT_C TInt CSenWebServiceSession::SendL( const TDesC8& aMessage, 

  1118                                             const TDesC8& aTransportProperties,

  1119                                             MSenRemoteServiceConsumer& aConsumer,

  1120                                             TInt& aTxnId,

  1121                                             HBufC8*& /*aRevalidationError*/ )

  1122     {

  1123     CSLOG_L(aConsumer.ConnectionId()  , KMinLogLevel,"CSenWebServiceSession::SendL");

  1124 

  1125     CSenSoapMessage* pMsg = NULL;

  1126     TInt retVal( MessageForSendingL(aMessage, aConsumer.Id(), pMsg) ); 

  1127     CleanupStack::PushL(pMsg);

  1128 

  1129     if(retVal!=KErrNone)

  1130         {

  1131         CSLOG_FORMAT((aConsumer.ConnectionId() , KMinLogLevel, _L8("- MessageForSendingL returned an error: %d"), retVal));

  1132         CleanupStack::PopAndDestroy(); // pMsg

  1133         return retVal;

  1134         }