diff -r 000000000000 -r b497e44ab2fc syncmlfw/common/syncagent/src/nsmlcmdsbase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/syncmlfw/common/syncagent/src/nsmlcmdsbase.cpp Thu Dec 17 09:07:52 2009 +0200 @@ -0,0 +1,1659 @@ +/* +* 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: Common Agent SyncML command handling +* +*/ + + +// INCLUDE FILES + +#include +#include +#include +#include +#include +#include "nsmlcliagconstants.h" +#include "NSmlCmdsBase.h" +#include "NSmlAgentBase.h" +#include "NSmlStatusContainer.h" +#include "NSmlResponseController.h" +#include "NSmlResultsContainer.h" +#include "NSmlURI.h" +#include "NSmlAuth.h" +#include "WBXMLSyncMLGenerator.h" +#include "WBXMLSyncMLParser.h" +#include "WBXMLGeneratorError.h" +#include "WBXMLParser.h" +#include "smldtd.h" + + +// --------------------------------------------------------- +// CNSmlCmdsBase::CNSmlCmdsBase() +// Constructor +// --------------------------------------------------------- +// +EXPORT_C CNSmlCmdsBase::CNSmlCmdsBase() + { + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::~CNSmlCmdsBase() +// Destructor +// --------------------------------------------------------- +// +EXPORT_C CNSmlCmdsBase::~CNSmlCmdsBase() + { +//1.2 CHANGES: 1.1 and 1.2 version support + delete iVerDTD; +//end changes + delete iVerProto; + delete iSentSyncHdrTarget; + delete iSentSyncHdrSource; + delete iRespURI; + delete iStatusToServer; + delete iResponseController; + delete iResultsToServer; + delete iGenerator; + delete iParser; + delete iDocHandler; + delete iPhoneInfo; + delete iServerAuth; + delete iSessionID; + delete iSyncMLUserName; + delete iSyncServer; + delete iLargeObjectItem; + delete iRecBuf; + delete iLargeObjectUID; + delete iCurrServerMsgID; + delete iBufferArea; + iReadStream.Close(); + } + + +// --------------------------------------------------------- +// CNSmlCmdsBase::ProcessCopyCmdL +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ProcessCopyCmdL(SmlCopy_t* /*aCopy*/) + { + //for future use + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::ProcessExecCmdL +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ProcessExecCmdL(SmlExec_t* /*aExec*/) + { + //for future use + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::ProcessMapCmdL +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ProcessMapCmdL(SmlMap_t* /*aContent*/) + { + //for future use + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::ProcessSearchCmdL +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ProcessSearchCmdL(SmlSearch_t* /*aSearch*/) + { + //for future use + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::FetchIDMappingTableL +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::FetchIDMappingTableL(const TInt /*aType*/) + { + //for future use + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::CloseIDMappingTableL +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::CloseIDMappingTableL() + { + //for future use + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DeleteIDMappingTableL +// +// --------------------------------------------------------- +EXPORT_C TBool CNSmlCmdsBase::DeleteIDMappingTableL(const TDesC& /*aId*/, const TDesC& /*aDatabase*/) + { + //for future use + return EFalse; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::EndOfServerMessageL +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::EndOfServerMessageL() const + { + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::WriteMappingInfoToDbL +// Empty default implementation. +// --------------------------------------------------------- +EXPORT_C TInt CNSmlCmdsBase::WriteMappingInfoToDbL() const + { + // Defined only in DM agent + return KErrNone; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoSyncHdrL +// Makes SyncHdr element and calls parser to generate xml +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoSyncHdrL() + { + // create generator instance first + if ( !iGenerator ) + { + iGenerator = new( ELeave ) CWBXMLSyncMLGenerator( iVersionPublicId ); + } + // create workspace + iGenerator->CreateWorkspaceL( iWorkspaceSize ); + //initialise SyncHdr + SmlSyncHdr_t* syncHdr = new( ELeave ) SmlSyncHdr_t; + CleanupStack::PushL( syncHdr ); + //element type + syncHdr->elementType = SML_PE_HEADER; + //VerDTD element + +//1.2 CHANGES: 1.2 and 1.1 version support + PcdataNewL ( syncHdr->version, *iVerDTD ); +//changes end + + //VerProto element + PcdataNewL ( syncHdr->proto, *iVerProto ); + //sessionID element + PcdataNewL ( syncHdr->sessionID, *iSessionID ); + //msgID element + TBuf8<16> stringMsgID; + stringMsgID.Num( ++iCurrMsgID ); + PcdataNewL( syncHdr->msgID, stringMsgID ); + //Target element + delete iSentSyncHdrTarget; + iSentSyncHdrTarget = NULL; + if ( iRespURI ) + { + // Target changes if a server has issued RespURI in previous message + DoTargetL( syncHdr->target, iRespURI->HostName() ); + iSentSyncHdrTarget = CNSmlURI::NewL( iRespURI->HostName() ); + } + else + { + DoTargetL( syncHdr->target, iSyncServer->HostName() ); + iSentSyncHdrTarget = CNSmlURI::NewL( iSyncServer->HostName() ); + } + //Source element + HBufC* imeiCode = HBufC::NewLC( 50 ); + TPtr imeiCodePtr = imeiCode->Des(); + iPhoneInfo->PhoneDataL( CNSmlPhoneInfo::EPhoneSerialNumber, imeiCodePtr ); + CNSmlAgentBase::TAuthenticationType authType; + authType = iAgent->AuthTypeL(); + if ( ( !iAlreadyAuthenticated ) && ( authType == CNSmlAgentBase::EMD5 ) ) + { + DoSourceL( syncHdr->source, imeiCodePtr, *iSyncMLUserName); + } + else + { + DoSourceL( syncHdr->source, imeiCodePtr ); + } + delete iSentSyncHdrSource; + iSentSyncHdrSource = NULL; + iSentSyncHdrSource = CNSmlURI::NewL( *imeiCode ); + CleanupStack::PopAndDestroy(); //imeiCode + // Cred element + if ( authType == CNSmlAgentBase::ENoAuth || iAgent->AlreadyAuthenticated() ) + { + syncHdr->cred = NULL; + } + else + { + syncHdr->cred = new( ELeave ) SmlCred_t; + SmlMetInfMetInf_t* metInf; + DoMetInfLC( metInf ); + if ( authType == CNSmlAgentBase::EMD5 ) + { + PcdataNewL( metInf->type, KNSmlAgentAuthMD5 ); + PcdataNewL( metInf->format, KNSmlAgentBase64Format ); + } + else // Basic + { + PcdataNewL( metInf->type, KNSmlAgentAuthBasic ); + } + DoMetaL( syncHdr->cred->meta, metInf ); + CleanupStack::Pop(); //metInf + + HBufC8* credential; + if ( authType == CNSmlAgentBase::EMD5 ) + { + credential = iAgent->Md5CredentialL(); + } + else // Basic + { + credential = iAgent->BasicCredentialL(); + } + CleanupStack::PushL( credential ); + PcdataNewL ( syncHdr->cred->data, *credential ); + CleanupStack::PopAndDestroy(); //credential + } + // MaxMsgSize + SmlMetInfMetInf_t* maxMsgMetInf; + DoMetInfLC( maxMsgMetInf ); + TBuf<16> maxMsgSize; + maxMsgSize.Num( iWorkspaceSize ); + HBufC8* maxMsgSizeInUTF8 = NULL; + NSmlUnicodeConverter::HBufC8InUTF8LC( maxMsgSize, maxMsgSizeInUTF8 ); + PcdataNewL( maxMsgMetInf->maxmsgsize, *maxMsgSizeInUTF8 ); + CleanupStack::PopAndDestroy(); //maxMsgSizeInUTF8 + if ( iSynchHdrMaxObjSize > 0 ) + { + DoMaxObjSizeL( *maxMsgMetInf, iSynchHdrMaxObjSize ); + } + DoMetaL( syncHdr->meta, maxMsgMetInf ); + CleanupStack::Pop(); //maxMsgMetInf + TInt ret; + ret = iGenerator->smlStartMessage( syncHdr ); + if ( ret != KWBXMLGeneratorOk ) + { + User::Leave( ret ); + } + CleanupStack::PopAndDestroy(); //syncHdr + iCurrCmdID = 0; + //save Status response information for response status controlling + CreateAndInitResponseItemL( KNSmlAgentSyncHdr ); + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoStatusL +// Generate Status element and calls Ref.Toolkit parser to generate xml +// --------------------------------------------------------- +EXPORT_C CNSmlCmdsBase::TReturnValue CNSmlCmdsBase::DoStatusL( SmlStatus_t* aStatus ) + { + TReturnValue returnValue = EReturnOK; + //CmdID element + SmlPcdata_t* cmdID = NULL; + DoCmdIdL( cmdID ); + CleanupStack::PushL( cmdID ); + TInt entryID = iStatusToServer->CurrentEntryID(); + iStatusToServer->SetCmdIDL( entryID, cmdID ); + CleanupStack::PopAndDestroy(); //cmdID + // call SyncML generator + TInt ret = iGenerator->smlStatusCmd( aStatus ); + switch ( ret ) + { + case KWBXMLGeneratorOk: + iStatusToServer->RemoveWritten( entryID ); + break; + case KWBXMLGeneratorBufferFull: + returnValue = CNSmlCmdsBase::EReturnBufferFull; + break; + default: + User::Leave( ret ); + } + return returnValue; + } + +// FOTA +// --------------------------------------------------------- +// CNSmlCmdsBase::DoGenericAlertL +// Makes generic alert. +// This is needed only in Device Management. +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoGenericAlertL ( const TDesC8& /*aFwMgmtUri*/, const TDesC8& /*aMetaType*/, + const TDesC8& /*aMetaFormat*/, TInt /*aFinalResult*/, const TDesC8& /*aFwCorrelator*/ ) + { + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoGenericAlertL +// Makes generic alert. +// This is needed only in Device Management. +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoGenericAlertL ( const TDesC8& /*aCorrelator*/, const RArray& /*aData*/ ) + { + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoGenericUserAlertL +// Makes generic user alert. +// This is needed only in Device Management. +// --------------------------------------------------------- +EXPORT_C TBool CNSmlCmdsBase::DoGenericUserAlertL ( TInt /*aProfileId*/ ) + { + return EFalse; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::ResetGenericUserAlertL +// Resets a user request for fw update in the central repository. +// This is needed only in Device Management. +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ResetGenericUserAlertL() + { + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::MarkGenAlertsSentL +// When the generic alerts are successfully sent to the remote +// server, the FOTA adapter needs to be informed about this. +// This is needed only in Device Management. +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::MarkGenAlertsSentL() + { + } +// --------------------------------------------------------- +// CNSmlCmdsBase::MarkGenAlertsSentL(const TDesC8) +// When the generic alerts are successfully sent to the remote +// server, the respective adapter needs to be informed about this. +// URI will have adapter's root node. +// This is needed only in Device Management. +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::MarkGenAlertsSentL(const TDesC8 &aURI) + { + + } +// --------------------------------------------------------- +// CNSmlCmdsBase::DisconnectFromOtherServers +// Closes the connections to callback server and host servers. +// This is needed only in Device Management, since the +// disconnecting cannot be made after the active scheduler +// of the thread is stopped. +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DisconnectFromOtherServers() + { + } + +// FOTA end + +// --------------------------------------------------------- +// CNSmlCmdsBase::ProcessReceivedDataL +// Parse next received SyncML command using Ref.Toolkit parser +// --------------------------------------------------------- +EXPORT_C TBool CNSmlCmdsBase::ProcessReceivedDataL() + { + if ( !iDocHandler ) + { + iDocHandler = CWBXMLSyncMLDocHandler::NewL( iAgent ); + } + if ( !iParser ) + { + iParser = CWBXMLParser::NewL(); + iParser->SetDocumentHandler( iDocHandler ); + iParser->SetExtensionHandler( iDocHandler ); + if ( !iBufferArea ) + { + iBufferArea = HBufC8::NewL( iWorkspaceSize ); + } + iReadStream.Open( *iBufferArea ); + iParser->SetDocumentL( iReadStream ); + } + + TWBXMLParserError ret = KWBXMLParserErrorOk; + iAgent->SetOffCallbackCalled(); + while ( ret == KWBXMLParserErrorOk && !iAgent->CallbackCalled() ) + { + ret = iParser->ParseL(); + } + if ( ret == KWBXMLParserErrorOk ) + { + return ETrue; + } + else + { + delete iBufferArea; + iBufferArea = NULL; + delete iParser; + iParser = NULL; + if ( ret == KWBXMLParserErrorEof ) + { + return EFalse; + } + else + { + User::Leave( ret ); + return EFalse; // this sentence ignores compiler warning + } + } + } +// --------------------------------------------------------- +// CNSmlCmdsBase::ProcessSyncHdrL +// Process received SyncHdr element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ProcessSyncHdrL( SmlSyncHdr_t* aSyncHdr ) + { + if ( !aSyncHdr ) + { + User::Leave( TNSmlError::ESmlSyncHdrMissing ); + } + // Status response flag + if ( IsFlagSet( aSyncHdr->flags, SmlNoResp_f ) ) + { + iStatusToServerNoResponse = ETrue; + } + else + { + iStatusToServerNoResponse = EFalse; + } + // build corresponding status element to server + if ( !iStatusToServer ) + { + iStatusToServer = CNSmlStatusContainer::NewL(); + } + iStatusToServer->InitMsgRefL( aSyncHdr->msgID ); + delete iCurrServerMsgID; + iCurrServerMsgID = NULL; + iCurrServerMsgID = HBufC8::NewL(0); + + TInt statusID; + statusID = iStatusToServer->CreateNewStatusElementL(); + HBufC8* cmdRef = HBufC8::NewLC( KNSmlAgentSyncHdrCmdID.iTypeLength ); + *cmdRef = KNSmlAgentSyncHdrCmdID; + SmlPcdata_t* cmdRefElement; + PcdataNewL ( cmdRefElement, *cmdRef ); + CleanupStack::PushL( cmdRefElement ); + iStatusToServer->SetCmdRefL( statusID, cmdRefElement ); + CleanupStack::PopAndDestroy( 2 ); //cmdRefElement, cmdRef + iStatusToServer->SetCmdL( statusID, KNSmlAgentSyncHdr ); + iStatusToServer->SetNoResponse( statusID, IsFlagSet( aSyncHdr->flags, SmlNoResp_f ) ); + iStatusToServer->AddTargetRefL( statusID, aSyncHdr->target ); + iStatusToServer->AddSourceRefL( statusID, aSyncHdr->source ); + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusOK ); + //respURI + if ( aSyncHdr->respURI ) + { + HBufC* respURI; + PCDATAToUnicodeLC( *aSyncHdr->respURI, respURI ); + respURI->Des().TrimRight(); + if ( respURI->Length() > 0 ) + { + delete iRespURI; + iRespURI = NULL; + iRespURI = CNSmlURI::NewL( *respURI ); + } + CleanupStack::PopAndDestroy(); //respURI + } + // verDTD and verProto (Check only once) + // sync is interrupted if version is other than 1.1 + if ( !iVersionCheck ) + { + iVersionIsChecked = ETrue; + } + if ( !iVersionIsChecked ) + { + if ( !aSyncHdr->version->content ) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusVersionNotSupported ); + iAgent->Interrupt( TNSmlError::ESmlVerDTDMissing, EFalse, EFalse ); + return; + } + TPtr8 verDTD( (TUint8*) aSyncHdr->version->content, aSyncHdr->version->length, aSyncHdr->version->length ); + TrimRightSpaceAndNull( verDTD ); +//1.2 CHANGES: 1.1 and 1.2 version support + if ( ( verDTD != KNSmlAgentVerDTD11 ) && (verDTD != KNSmlAgentVerDTD12 )) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusVersionNotSupported ); + SmlPcdata_t* data = NULL; + + PcdataNewL( data, *iVerDTD ); +//changes end + CleanupStack::PushL( data ); + iStatusToServer->AddItemDataL( statusID, data ); + CleanupStack::PopAndDestroy(); //data + iAgent->Interrupt( TNSmlError::ESmlVerDTDNotSupported, EFalse, EFalse ); + return; + } + if ( !aSyncHdr->proto->content ) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusProtocolVersionNotSupported ); + iAgent->Interrupt( TNSmlError::ESmlVerProtoMissing, EFalse, EFalse ); + return; + } + TPtr8 verProto( (TUint8*) aSyncHdr->proto->content, aSyncHdr->proto->length, aSyncHdr->proto->length ); + TrimRightSpaceAndNull( verProto ); + if ( verProto != *iVerProto ) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusProtocolVersionNotSupported ); + SmlPcdata_t* data = NULL; + PcdataNewL( data, *iVerProto ); + CleanupStack::PushL( data ); + iStatusToServer->AddItemDataL( statusID, data ); + CleanupStack::PopAndDestroy(); //data + iAgent->Interrupt( TNSmlError::ESmlVerProtoNotSupported, EFalse, EFalse ); + return; + } + iVersionIsChecked = ETrue; + } + // msgID + TPtr8 msgID( (TUint8*) aSyncHdr->msgID->content, aSyncHdr->msgID->length, aSyncHdr->msgID->length ); + delete iCurrServerMsgID; + iCurrServerMsgID = NULL; + iCurrServerMsgID = msgID.AllocL(); + if ( msgID.Length() == 0 ) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusIncompleteCommand ); + iAgent->Interrupt( TNSmlError::ESmlMsgIDMissing, EFalse, EFalse ); + return; + } + // target + // here must be client's Source (IMEI), check that client has got its message + if ( !aSyncHdr->target ) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusIncompleteCommand ); + iAgent->Interrupt( TNSmlError::ESmlTargetLocURIMissing, EFalse, EFalse ); + return; + } + else + if ( !aSyncHdr->target->locURI ) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusIncompleteCommand ); + iAgent->Interrupt( TNSmlError::ESmlTargetLocURIMissing, EFalse, EFalse ); + return; + } + else + { + HBufC* syncHdrTarget; + PCDATAToUnicodeLC( *aSyncHdr->target->locURI, syncHdrTarget ); + syncHdrTarget->Des().TrimRight(); + CNSmlURI* syncHdrTargetURI = CNSmlURI::NewLC( *syncHdrTarget ); + if ( syncHdrTargetURI->HostName().Length() != 0 && syncHdrTargetURI->HostName() != _L("/") ) + { + HBufC* imeiCode = HBufC::NewLC( 50 ); + TPtr imeiCodePtr = imeiCode->Des(); + iPhoneInfo->PhoneDataL( CNSmlPhoneInfo::EPhoneSerialNumber, imeiCodePtr ); + if ( syncHdrTargetURI->HostName() != *imeiCode ) + { + iUnknownDevice = ETrue; + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusNotFound ); + CleanupStack::PopAndDestroy( 3 ); //imeiCode, syncHdrTargetURI,syncHdrTarget + iAgent->Interrupt( TNSmlError::ESmlTargetLocURIInvalid, EFalse, EFalse ); + return; + } + CleanupStack::PopAndDestroy(); //imeiCode + } + CleanupStack::PopAndDestroy( 2 ); //syncHdrTargetURI, syncHdrTarget + } + // Cred + if ( aSyncHdr->cred ) + { + HBufC8* type = MetaTypeInUtf8LC( aSyncHdr->cred->meta ); + iServerAuth->SetTypeL( *type ); + CleanupStack::PopAndDestroy(); //type + HBufC8* format = MetaFormatInUtf8LC( aSyncHdr->cred->meta ); + iServerAuth->SetFormatL( *format ); + CleanupStack::PopAndDestroy(); //format + if ( aSyncHdr->cred->data ) + { + if ( aSyncHdr->cred->data->content ) + { + TPtr8 credential( (TUint8*) aSyncHdr->cred->data->content, aSyncHdr->cred->data->length, aSyncHdr->cred->data->length ); + iServerAuth->SetCredentialL( credential ); + } + } + } + TNSmlError::TNSmlSyncMLStatusCode authStatus = iServerAuth->StatusCodeL(); + iStatusToServer->SetStatusCodeL( statusID, authStatus ); + if ( authStatus == TNSmlError::ESmlStatusUnauthorized ) + { + iAgent->Interrupt( TNSmlError::ESmlServerUnauthorized, EFalse, ETrue ); + iServerAuth->CreateAndSaveNewNonceL(); + } + + if ( iServerAuth->ChallengeNeeded() ) + { + iStatusToServer->SetChalL( statusID, iServerAuth->NonceL() ); + iServerAuth->SetChallenced(); + } + + + //MaxMsgSize + //Client must obey this value in the next message to server + if ( aSyncHdr->meta ) + { + if ( ( aSyncHdr->meta->content ) && ( aSyncHdr->meta->contentType == SML_PCDATA_EXTENSION ) && ( aSyncHdr->meta->extension == SML_EXT_METINF ) ) + { + SmlMetInfMetInf_t* metInf; + metInf = (SmlMetInfMetInf_t*) aSyncHdr->meta->content; + if ( metInf->maxmsgsize ) + { + if ( metInf->maxmsgsize->content ) + { + TPtr8 maxMsgSize( (TUint8*) metInf->maxmsgsize->content, metInf->maxmsgsize->length, metInf->maxmsgsize->length ); + TrimRightSpaceAndNull( maxMsgSize ); + TLex8 lexicalValue( maxMsgSize ); + TInt maxMsgSizeNum; + if ( lexicalValue.Val( maxMsgSizeNum ) != KErrNone ) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusIncompleteCommand ); + iAgent->Interrupt( TNSmlError::ESmlMaxMsgSizeInvalid, EFalse, EFalse ); + return; + } + else + { + + if ( maxMsgSizeNum < KNSmlMininumWorkspaceSize ) + { + iWorkspaceSize = maxMsgSizeNum; + } + else + { + if ( maxMsgSizeNum > iMaxWorkspaceSize ) + { + iWorkspaceSize = iMaxWorkspaceSize; + } + else + { + iWorkspaceSize = maxMsgSizeNum; + } + } + } + } + } + } + } + iServerMaxObjectSize = ServerMaxObjSize( aSyncHdr->meta ); + } + + +// --------------------------------------------------------- +// CNSmlCmdsBase::ProcessStatusCmdL +// Handles Status command from a server. +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ProcessStatusCmdL( SmlStatus_t* aStatus ) + { + //msgRef + if ( !aStatus->msgRef ) + { + return; + } + if ( !aStatus->msgRef->content ) + { + return; + } + TPtr8 msgRef( (TUint8*) aStatus->msgRef->content, aStatus->msgRef->length, aStatus->msgRef->length ); + TrimRightSpaceAndNull( msgRef ); + if ( msgRef.Length() == 0 ) + { + return; + } + //cmd + if ( !aStatus->cmd ) + { + return; + } + if ( !aStatus->cmd->content ) + { + return; + } + TPtr8 cmd( (TUint8*) aStatus->cmd->content, aStatus->cmd->length, aStatus->cmd->length ); + TrimRightSpaceAndNull( cmd ); + if ( cmd.Length() == 0 ) + { + return; + } + //cmdRef + HBufC8* cmdRef = NULL; + if ( !aStatus->cmdRef ) + { + if ( cmd == KNSmlAgentSyncHdr ) + { + cmdRef = HBufC8::NewLC( KNSmlAgentSyncHdrCmdID.iTypeLength ); + *cmdRef = KNSmlAgentSyncHdrCmdID; + } + else + { + return; + } + } + else + if ( !aStatus->cmdRef->content ) + { + if ( cmd == KNSmlAgentSyncHdr ) + { + cmdRef = HBufC8::NewLC( KNSmlAgentSyncHdrCmdID.iTypeLength ); + *cmdRef = KNSmlAgentSyncHdrCmdID; + } + else + { + return; + } + } + else + { + TPtr8 cmdRefPtr ( (TUint8*) aStatus->cmdRef->content, aStatus->cmdRef->length, aStatus->cmdRef->length ); + TrimRightSpaceAndNull( cmdRefPtr ); + if ( cmdRefPtr.Length() == 0 ) + { + if ( cmd == KNSmlAgentSyncHdr ) + { + cmdRef = HBufC8::NewLC( KNSmlAgentSyncHdrCmdID.iTypeLength ); + *cmdRef = KNSmlAgentSyncHdrCmdID; + } + else + { + return; + } + } + else + { + cmdRef = HBufC8::NewLC( cmdRefPtr.Length() ); + *cmdRef = cmdRefPtr; + } + } + // Status code + TPtr8 statusCode( (TUint8*) aStatus->data->content, aStatus->data->length, aStatus->data->length ); + TrimRightSpaceAndNull( statusCode ); + if ( statusCode.Length() == 0 ) + { + CleanupStack::PopAndDestroy(); //cmdRef + return; + } + TLex8 lexicalStatus( statusCode ); + TInt numericStatus; + if ( lexicalStatus.Val (numericStatus ) != KErrNone ) + { + CleanupStack::PopAndDestroy(); //cmdRef + return; + } + TInt entryID = 0; + TBool statusIsMatching; + statusIsMatching = iResponseController->MatchStatusElement( msgRef, *cmdRef , numericStatus, entryID ); + if ( !statusIsMatching ) + { + } + else + { + // chal element is stored for later use + if ( aStatus->chal ) + { + if ( aStatus->chal->meta ) + { + if ( aStatus->chal->meta->content && aStatus->chal->meta->contentType == SML_PCDATA_EXTENSION && aStatus->chal->meta->extension == SML_EXT_METINF ) + { + SmlMetInfMetInf_t* metInf; + metInf = (SmlMetInfMetInf_t*) aStatus->chal->meta->content; + if ( metInf->type ) + { + if ( metInf->type->content ) + { + TPtr8 chalType( (TUint8*) metInf->type->content, metInf->type->length, metInf->type->length ); + TrimRightSpaceAndNull( chalType ); + if ( chalType.Length() > 0 ) + { + iResponseController->SetChalTypeL( entryID, chalType ); + } + } + } + if ( metInf->format ) + { + if ( metInf->format->content ) + { + TPtr8 chalFormat( (TUint8*) metInf->format->content, metInf->format->length, metInf->format->length ); + TrimRightSpaceAndNull( chalFormat ); + if ( chalFormat.Length() > 0 ) + { + iResponseController->SetChalFormatL( entryID, chalFormat ); + } + else + { + iResponseController->SetChalFormatL( entryID, KNSmlAgentChrFormat ); + } + } + else + { + iResponseController->SetChalFormatL( entryID, KNSmlAgentChrFormat ); + } + } + else + { + iResponseController->SetChalFormatL( entryID, KNSmlAgentChrFormat ); + } + if ( metInf->nextnonce ) + { + if ( metInf->nextnonce->content ) + { + TPtr8 chalNextNonce( (TUint8*) metInf->nextnonce->content, metInf->nextnonce->length, metInf->nextnonce->length ); + TrimRightSpaceAndNull( chalNextNonce ); + if ( chalNextNonce.Length() > 0 ) + { + iResponseController->SetChalNextNonceL( entryID, chalNextNonce ); + } + } + } + } + } + } + } + CleanupStack::PopAndDestroy(); //cmdRef + if ( statusIsMatching ) + { + iAgent->CheckServerStatusCodeL( entryID ); + } + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::AlertCode +// +// --------------------------------------------------------- +EXPORT_C TPtr8 CNSmlCmdsBase::AlertCode( SmlAlert_t* aAlert ) const + { + TPtr8 alertCode( NULL,0,0 ); + if ( aAlert ) + { + if ( aAlert->data ) + { + if ( aAlert->data->content ) + { + alertCode.Set( (TUint8*) aAlert->data->content, aAlert->data->length, aAlert->data->length ); + TrimRightSpaceAndNull( alertCode ); + } + } + } + return alertCode; + } + + +// --------------------------------------------------------- +// CNSmlCmdsBase::StatusToUnsupportedCommandL() +// Makes status data to unsupported or illegal SyncML command +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::StatusToUnsupportedCommandL( TBool aIllegal, const TDesC8& aCmd, const SmlPcdata_t* aCmdRef, Flag_t aFlags ) + { + if ( iStatusToServer ) + { + TInt statusID( 0 ); + statusID = iStatusToServer->CreateNewStatusElementL(); + iStatusToServer->SetCmdRefL( statusID, aCmdRef ); + iStatusToServer->SetCmdL( statusID, aCmd ); + if ( iStatusToServerNoResponse || IsFlagSet( aFlags, SmlNoResp_f ) ) + { + iStatusToServer->SetNoResponse( statusID, ETrue ); + } + else + { + iStatusToServer->SetNoResponse( statusID, EFalse ); + } + if ( aIllegal ) + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusCommandFailed ); + } + else + { + iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusOptFeatureNotSupported ); + } + } + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::GeneratedDocument() +// +// --------------------------------------------------------- +TPtrC8 CNSmlCmdsBase::GeneratedDocument() const + { + return ( iGenerator->Document() ); + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::BufferAreaForParsingL +// +// --------------------------------------------------------- +EXPORT_C TPtr8 CNSmlCmdsBase::BufferAreaForParsingL() + { + delete iBufferArea; + iBufferArea = 0; + iBufferArea = HBufC8::NewL( iWorkspaceSize ); + return iBufferArea->Des(); + } +// --------------------------------------------------------- +// CNSmlCmdsBase::BusyStatus +// +// --------------------------------------------------------- +EXPORT_C TBool CNSmlCmdsBase::BusyStatus() const + { + TBool busyStatusReceived = EFalse; + if ( iResponseController ) + { + if ( iResponseController->BusyStatus( iCurrMsgID ) ) + { + busyStatusReceived = ETrue; + } + } + return ( busyStatusReceived ); + } +// --------------------------------------------------------- +// CNSmlCmdsBase::StatusContainer() +// +// --------------------------------------------------------- +EXPORT_C CNSmlStatusContainer* CNSmlCmdsBase::StatusContainer() const + { + return iStatusToServer; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::ResponseController() +// +// --------------------------------------------------------- +EXPORT_C CNSmlResponseController* CNSmlCmdsBase::ResponseController() const + { + return iResponseController; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::ResultsContainer() +// +// --------------------------------------------------------- +EXPORT_C CNSmlResultsContainer* CNSmlCmdsBase::ResultsContainer() const + { + return iResultsToServer; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::ServerAuth() +// +// --------------------------------------------------------- +EXPORT_C CNSmlAuth* CNSmlCmdsBase::ServerAuth() const + { + return iServerAuth; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::RespURI +// +// --------------------------------------------------------- +EXPORT_C CNSmlURI* CNSmlCmdsBase::RespURI() const + { + return iRespURI; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::DoMetaL +// Makes Meta element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoMetaL( SmlPcdata_t*& aMeta, const SmlMetInfMetInf_t* aMetaData ) const + { + aMeta = new( ELeave ) SmlPcdata_t; + aMeta->length = 0; + aMeta->content = ( TAny* ) aMetaData; + aMeta->contentType = SML_PCDATA_EXTENSION; + aMeta->extension = SML_EXT_METINF; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::DoMetInfLC +// Initialises empty MetInf structure +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoMetInfLC( SmlMetInfMetInf_t*& aMeta ) const + { + aMeta = new( ELeave ) SmlMetInfMetInf_t; + CleanupStack::PushL( aMeta ); + } +// --------------------------------------------------------- +// CNSmlCmdsBase::PcDataNewL +// Create Pcdata +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::PcdataNewL( SmlPcdata_t*& aPcdata, const TDesC8& aContent ) const + { + aPcdata = new( ELeave ) SmlPcdata_t; + aPcdata->SetDataL( aContent ); + aPcdata->contentType = SML_PCDATA_OPAQUE; + aPcdata->extension = SML_EXT_UNDEFINED; + } + +//1.2 CHANGES + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoSourceL +// Makes Source or Target element without LocName element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoSourceL( sml_source_s*& aSource, const TDesC& aLocURIData ) const + { + aSource = new( ELeave ) sml_source_s; + HBufC8* locURIDataInUTF8 = NULL; + NSmlUnicodeConverter::HBufC8InUTF8LC( aLocURIData, locURIDataInUTF8 ); + PcdataNewL ( aSource->locURI, *locURIDataInUTF8 ); + CleanupStack::PopAndDestroy(); //locURIDataInUTF8 + aSource->locName = NULL; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoSourceL +// Makes Source or Target element without LocName element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoSourceL( sml_source_s*& aSource, const TDesC8& aLocURIData ) const + { + aSource = new( ELeave ) sml_source_s; + PcdataNewL ( aSource->locURI, aLocURIData ); + aSource->locName = NULL; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoSourceL +// Makes Source or Target element with LocName element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoSourceL( sml_source_s*& aSource, const TDesC& aLocURIData, const TDesC& aLocNameData ) const + { + aSource = new( ELeave ) sml_source_s; + HBufC8* locURIDataInUTF8 = NULL; + NSmlUnicodeConverter::HBufC8InUTF8LC( aLocURIData, locURIDataInUTF8 ); + PcdataNewL ( aSource->locURI, *locURIDataInUTF8 ); + CleanupStack::PopAndDestroy(); //locURIDataInUTF8 + HBufC8* locNameDataInUTF8 = NULL; + NSmlUnicodeConverter::HBufC8InUTF8LC( aLocNameData, locNameDataInUTF8 ); + PcdataNewL ( aSource->locName, *locNameDataInUTF8 ); + CleanupStack::PopAndDestroy(); //locNameDataInUTF8 + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoTargetL +// Makes Source or Target element without LocName element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoTargetL( sml_target_s*& aTarget, const TDesC& aLocURIData ) const + { + aTarget = new( ELeave ) sml_target_s; + HBufC8* locURIDataInUTF8 = NULL; + NSmlUnicodeConverter::HBufC8InUTF8LC( aLocURIData, locURIDataInUTF8 ); + PcdataNewL ( aTarget->locURI, *locURIDataInUTF8 ); + CleanupStack::PopAndDestroy(); //locURIDataInUTF8 + aTarget->locName = NULL; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoTargetL +// Makes Source or Target element without LocName element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoTargetL( sml_target_s*& aTarget, const TDesC8& aLocURIData ) const + { + aTarget = new( ELeave ) sml_target_s; + PcdataNewL ( aTarget->locURI, aLocURIData ); + aTarget->locName = NULL; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoTargetL +// Makes Source or Target element with LocName element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoTargetL( sml_target_s*& aTarget, const TDesC& aLocURIData, const TDesC& aLocNameData ) const + { + aTarget = new( ELeave ) sml_target_s; + HBufC8* locURIDataInUTF8 = NULL; + NSmlUnicodeConverter::HBufC8InUTF8LC( aLocURIData, locURIDataInUTF8 ); + PcdataNewL ( aTarget->locURI, *locURIDataInUTF8 ); + CleanupStack::PopAndDestroy(); //locURIDataInUTF8 + HBufC8* locNameDataInUTF8 = NULL; + NSmlUnicodeConverter::HBufC8InUTF8LC( aLocNameData, locNameDataInUTF8 ); + PcdataNewL ( aTarget->locName, *locNameDataInUTF8 ); + CleanupStack::PopAndDestroy(); //locNameDataInUTF8 + } +//end changes + +// --------------------------------------------------------- +// CNSmlCmdsBase::PCDATAToUnicodeLC +// Converts data in Pcdata structure (used by xml parser) +// to Unicode +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::PCDATAToUnicodeLC( const SmlPcdata_t& aPcdata, HBufC*& aUnicodeData ) const + { + if ( !aPcdata.content ) + { + aUnicodeData = NULL; + aUnicodeData = HBufC16::NewLC( 0 ); + } + TPtr8 pcdata( (TUint8*) aPcdata.content, aPcdata.length, aPcdata.length ); + TrimRightSpaceAndNull( pcdata ); + NSmlUnicodeConverter::HBufC16InUnicodeLC( pcdata, aUnicodeData ); + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::ResetLargeObjectBuffer() +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ResetLargeObjectBuffer() + { + delete iRecBuf; + iRecBuf = NULL; + iServerLargeObjectSize = 0; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::WaitingLargeObjectChunk() +// +// --------------------------------------------------------- +EXPORT_C TBool CNSmlCmdsBase::WaitingLargeObjectChunk() const + { + if ( iRecBuf != NULL ) + { + return ETrue; + } + else + { + return EFalse; + } + } +// --------------------------------------------------------- +// CNSmlCmdsBase::ConstructL +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::ConstructL( CNSmlAgentBase* aAgentBase, const TDesC8& aSessionID, const TDesC8& aVerProto, const TInt aPublicId, const HBufC& aSyncMLUserName, CNSmlURI* aSyncServer, TBool aVersionCheck ) + { + iMaxWorkspaceSize = KNSmlDefaultWorkspaceSize; + iAgent = aAgentBase; + iSessionID = aSessionID.AllocL(); + iWorkspaceSize = iMaxWorkspaceSize; + iVerProto = aVerProto.AllocL(); + iVersionPublicId = aPublicId; + +//1.2 CHANGES: 1.1 and 1.2 version support + if ( aPublicId == KNSmlSyncMLPublicId ) + { + iVerDTD = KNSmlAgentVerDTD11().AllocL(); + } + else + { + iVerDTD = KNSmlAgentVerDTD12().AllocL(); + } +//end changes + + iVersionCheck = aVersionCheck; + iSyncMLUserName = aSyncMLUserName.AllocL(); + iSyncServer = CNSmlURI::NewL( aSyncServer->HostNameWithPortL() ); + iPhoneInfo = CNSmlPhoneInfo::NewL(); + iStatusToServer = CNSmlStatusContainer::NewL(); + iResponseController = CNSmlResponseController::NewL(); + iResultsToServer = CNSmlResultsContainer::NewL(); + iServerAuth = CNSmlAuth::NewL(); + } +// --------------------------------------------------------- +// CNSmlCmdsBase::DoCmdIdL +// Makes CmdID element +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoCmdIdL( SmlPcdata_t*& aCmdID ) + { + HBufC8* stringCmdID = HBufC8::NewLC( 16 ); + stringCmdID->Des().Num( ++iCurrCmdID ); + PcdataNewL ( aCmdID, *stringCmdID ); + CleanupStack::PopAndDestroy(); //stringCmdID + } + + + +// --------------------------------------------------------- +// CNSmlCmdsBase::DoAnchorsL +// Makes Anchor elements in MetInf DTD +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoAnchorsL( SmlMetInfMetInf_t& aMetInf, const TDesC8* aLast, const TDesC8* aNext ) const + { + aMetInf.anchor = new ( ELeave) SmlMetInfAnchor_t; + if ( aLast ) + { + PcdataNewL( aMetInf.anchor->last, *aLast ); + } + else + { + aMetInf.anchor->last = NULL; + } + if ( aNext ) + { + PcdataNewL( aMetInf.anchor->next, *aNext ); + } + else + { + aMetInf.anchor->next = NULL; + } + } +// --------------------------------------------------------- +// CNSmlCmdsBase::DoMaxObjSizeL() +// Set MaxObjSize element with default value +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::DoMaxObjSizeL( SmlMetInfMetInf_t& aMetInf, TInt aMaxObjSize ) const + { + HBufC8* stringSize = HBufC8::NewLC( 16 ); + stringSize->Des().Num( aMaxObjSize ); + PcdataNewL( aMetInf.maxobjsize, *stringSize ); + CleanupStack::PopAndDestroy(); //stringSize + } + + + + + +// --------------------------------------------------------- +// CNSmlCmdsBase::SubtractConsumedFromPcData +// +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::SubtractConsumedFromPcData( SmlItem_t*& aItem, TInt aConsumed ) + { + TPtr8 data( (TUint8*) aItem->data->content, aItem->data->length ); + data.SetLength( aItem->data->length ); + if ( data.Length() < aConsumed ) + { + data.Delete( 0, data.Length() ); + aItem->data->length = 0; + } + else + { + data.Delete( 0, aConsumed ); + aItem->data->length -= aConsumed; + } + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::StatusDataToGenericCommandL() +// Save status data to Add, Replace and Delete commands +// --------------------------------------------------------- +EXPORT_C TInt CNSmlCmdsBase::StatusDataToGenericCommandL( const TDesC8& aCmd, const SmlGenericCmd_t* aContent, const SmlItem_t* aItem, TNSmlError::TNSmlSyncMLStatusCode aStatusCode, const TDesC8* aStatusItem ) + { + return StatusDataToCommandL( aCmd, aContent->cmdID, aContent->flags, aItem, aStatusCode, aStatusItem ); + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::StatusDataToGetCommandL() +// Save status data to Get command +// --------------------------------------------------------- +EXPORT_C TInt CNSmlCmdsBase::StatusDataToGetCommandL( const SmlGet_t* aContent, const SmlItem_t* aItem, TNSmlError::TNSmlSyncMLStatusCode aStatusCode, const TDesC8* aStatusItem ) + { + return StatusDataToCommandL( KNSmlAgentGet, aContent->cmdID, aContent->flags, aItem, aStatusCode, aStatusItem ); + } +// --------------------------------------------------------- +// CNSmlCmdsBase::StatusDataToCommandL() +// Save status data to command +// --------------------------------------------------------- +EXPORT_C TInt CNSmlCmdsBase::StatusDataToCommandL( const TDesC8& aCmd, const SmlPcdata_t* aCmdID, TUint aFlags, const SmlItem_t* aItem, TNSmlError::TNSmlSyncMLStatusCode aStatusCode, const TDesC8* aStatusItem ) + { + TInt statusID( 0 ); + statusID = iStatusToServer->CreateNewStatusElementL(); + iStatusToServer->SetCmdRefL( statusID, aCmdID ); + iStatusToServer->SetCmdL( statusID, aCmd ); + if ( iStatusToServerNoResponse || IsFlagSet( aFlags, SmlNoResp_f ) ) + { + iStatusToServer->SetNoResponse( statusID, ETrue ); + } + else + { + iStatusToServer->SetNoResponse( statusID, EFalse ); + } + if ( aItem ) + { + iStatusToServer->AddTargetRefL( statusID, aItem->target ); + iStatusToServer->AddSourceRefL( statusID, aItem->source ); + } + if ( aStatusItem ) + { + SmlPcdata_t* data = NULL; + PcdataNewL( data, *aStatusItem ); + CleanupStack::PushL( data ); + iStatusToServer->AddItemDataL( statusID, data ); + CleanupStack::PopAndDestroy(); //data + } + iStatusToServer->SetStatusCodeL( statusID, aStatusCode ); + return statusID; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::CreateAndInitResponseItemL() +// Creates and initialises response controller for Clients commands +// --------------------------------------------------------- +EXPORT_C TInt CNSmlCmdsBase::CreateAndInitResponseItemL( const TDesC8& aCommand ) + { + TInt respID; + respID = iResponseController->CreateNewResponseItemL(); + iResponseController->SetMsgID( respID, iCurrMsgID ); + iResponseController->SetCmdID( respID, iCurrCmdID ); + iResponseController->SetCmdL( respID, aCommand ); + return respID; + } + + + +// --------------------------------------------------------- +// CNSmlCmdsBase::TargetIsUnderItem() +// +// --------------------------------------------------------- +EXPORT_C TBool CNSmlCmdsBase::TargetIsUnderItem( const SmlItemList_t* aItemList ) const + { + if ( aItemList ) + { + if ( aItemList->item ) + { + if ( aItemList->item->target ) + { + if ( aItemList->item->target->locURI ) + { + return ETrue; + } + } + } + } + return EFalse; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::SourceIsUnderItem() +// +// --------------------------------------------------------- +EXPORT_C TBool CNSmlCmdsBase::SourceIsUnderItem( const SmlItemList_t* aItemList ) const + { + if ( aItemList ) + { + if ( aItemList->item ) + { + if ( aItemList->item->source ) + { + if ( aItemList->item->source->locURI ) + { + return ETrue; + } + } + } + } + return EFalse; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::MetaTypeInUtf8LC() +// +// --------------------------------------------------------- +EXPORT_C HBufC8* CNSmlCmdsBase::MetaTypeInUtf8LC( const SmlPcdata_t* aMeta ) const + { + HBufC8* typeInUtf8 = NULL; + if ( aMeta ) + { + if ( ( aMeta->content ) && ( aMeta->contentType == SML_PCDATA_EXTENSION ) && ( aMeta->extension == SML_EXT_METINF ) ) + { + SmlMetInfMetInf_t* metInf; + metInf = (SmlMetInfMetInf_t*) aMeta->content; + if ( metInf->type ) + { + if ( metInf->type->content ) + { + TPtr8 type( (TUint8*) metInf->type->content, metInf->type->length, metInf->type->length ); + TrimRightSpaceAndNull( type ); + typeInUtf8 = type.AllocLC(); + } + } + } + } + if ( typeInUtf8 == NULL ) + { + typeInUtf8 = HBufC8::NewLC( 0 ); + } + return typeInUtf8; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::MetaTypeLC() +// +// --------------------------------------------------------- +EXPORT_C HBufC* CNSmlCmdsBase::MetaTypeLC( const SmlPcdata_t* aMeta ) const + { + HBufC* typeInUnicode = NULL; + if ( aMeta ) + { + if ( ( aMeta->content ) && ( aMeta->contentType == SML_PCDATA_EXTENSION ) && ( aMeta->extension == SML_EXT_METINF ) ) + { + SmlMetInfMetInf_t* metInf; + metInf = (SmlMetInfMetInf_t*) aMeta->content; + if ( metInf->type ) + { + PCDATAToUnicodeLC( *metInf->type, typeInUnicode ); + } + } + } + if ( typeInUnicode == NULL ) + { + typeInUnicode = HBufC::NewLC( 0 ); + } + return typeInUnicode; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::MetaFormatInUtf8LC() +// +// --------------------------------------------------------- +EXPORT_C HBufC8* CNSmlCmdsBase::MetaFormatInUtf8LC( const SmlPcdata_t* aMeta ) const + { + HBufC8* formatInUtf8 = NULL; + if ( aMeta ) + { + if ( ( aMeta->content ) && ( aMeta->contentType == SML_PCDATA_EXTENSION ) && ( aMeta->extension == SML_EXT_METINF ) ) + { + SmlMetInfMetInf_t* metInf; + metInf = (SmlMetInfMetInf_t*) aMeta->content; + if ( metInf->format ) + { + if ( metInf->format->content ) + { + TPtr8 format( (TUint8*) metInf->format->content, metInf->format->length, metInf->format->length ); + TrimRightSpaceAndNull( format ); + formatInUtf8 = format.AllocLC(); + } + } + } + } + if ( formatInUtf8 == NULL ) + { + formatInUtf8 = HBufC8::NewLC( 0 ); + } + return formatInUtf8; + } +// --------------------------------------------------------- +// CNSmlCmdsBase::IsFlagSet +// +// --------------------------------------------------------- +EXPORT_C TBool CNSmlCmdsBase::IsFlagSet( const TUint& aValue, const TUint& aBit ) const + { + return( (aValue & aBit) == aBit ); + } + + +// --------------------------------------------------------- +// CNSmlCmdsBase::TrimRightSpaceAndNull +// Trims right spaces and zero terminator (NULL) +// --------------------------------------------------------- +EXPORT_C void CNSmlCmdsBase::TrimRightSpaceAndNull( TDes8& aDes ) const + { + aDes.TrimRight(); + if ( aDes.Length() > 0 ) + { + if ( aDes[aDes.Length() - 1] == NULL ) + { + aDes.SetLength( aDes.Length() - 1 ); + } + } + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::MoreDataL +// Handles the buffering of received chunked large objects +// --------------------------------------------------------- +EXPORT_C TNSmlError::TNSmlSyncMLStatusCode CNSmlCmdsBase::MoreDataL( const HBufC8* aUID, const SmlItem_t* aCurrentItem, const SmlPcdata_t* aMetaInCommand, CBufBase*& aTotalItem ) + { + aTotalItem = NULL; + TNSmlError::TNSmlSyncMLStatusCode statusCode = TNSmlError::ESmlStatusOK; + TBool moreData = IsFlagSet( aCurrentItem->flags, SmlMoreData_f ); + + if ( iRecBuf != NULL ) // previous chunks, check that UID is same + { + HBufC8* UID; + if ( aUID ) + { + UID = aUID->AllocLC(); + } + else + { + UID = HBufC8::NewLC( 0 ); + } + if ( *UID != *iLargeObjectUID ) + { + iAgent->SetEndOfDataAlertRequest(); + delete iRecBuf; + iRecBuf = NULL; + delete iLargeObjectUID; + iLargeObjectUID = NULL; + iServerLargeObjectSize = 0; + } + CleanupStack::PopAndDestroy(); //UID + } + if ( moreData && iRecBuf == NULL ) //save object size when the first chunk + { + iServerLargeObjectSize = ServerObjectSize( aCurrentItem->meta ); + if ( iServerLargeObjectSize == 0 ) + { + iServerLargeObjectSize = ServerObjectSize( aMetaInCommand ); + } + delete iLargeObjectUID; + iLargeObjectUID = NULL; + if ( aUID ) + { + iLargeObjectUID = aUID->AllocL(); + } + else + { + iLargeObjectUID = HBufC8::NewL( 0 ); + } + } + + TBool previousChunks = EFalse; + if ( iRecBuf == NULL ) + { + iRecBuf = CBufFlat::NewL( 1 ); + } + else + { + previousChunks = ETrue; + } + if ( aCurrentItem->data ) + { + if ( aCurrentItem->data->content ) + { + TPtr8 data( (TUint8*) aCurrentItem->data->content, aCurrentItem->data->length, aCurrentItem->data->length ); + iRecBuf->InsertL( iRecBuf->Size(), data ); + } + } + if ( !moreData ) + { + if ( (previousChunks) && (iRecBuf->Size() != iServerLargeObjectSize) ) + { // size check with large objects + statusCode = TNSmlError::ESmlStatusSizeMismatch; + delete iRecBuf; + } + else + { // it is the last chunk, ownership of the buffer is moved to a caller + aTotalItem = iRecBuf; + } + iRecBuf = NULL; + iServerLargeObjectSize = 0; + } + else + { + aTotalItem = NULL; + statusCode = TNSmlError::ESmlStatusItemAccepted; + } + + return statusCode; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::ServerMaxObjSize +// MaxObjSize from Meta element structure +// --------------------------------------------------------- +EXPORT_C TInt CNSmlCmdsBase::ServerMaxObjSize( const SmlPcdata_t* aMeta ) const + { + TInt maxObjSizeNum = 0; + if ( aMeta ) + { + if ( ( aMeta->content ) && ( aMeta->contentType == SML_PCDATA_EXTENSION ) && ( aMeta->extension == SML_EXT_METINF ) ) + { + SmlMetInfMetInf_t* metInf; + metInf = (SmlMetInfMetInf_t*) aMeta->content; + if ( metInf->maxobjsize ) + { + if ( metInf->maxobjsize->content ) + { + TPtr8 maxObjSize( (TUint8*) metInf->maxobjsize->content, metInf->maxobjsize->length, metInf->maxobjsize->length ); + TrimRightSpaceAndNull( maxObjSize ); + TLex8 lexicalValue( maxObjSize ); + if ( lexicalValue.Val( maxObjSizeNum ) != KErrNone ) + { + maxObjSizeNum = 0; + } + } + } + } + } + return maxObjSizeNum; + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::ServerObjectSize() +// Size from Meta element structure +// --------------------------------------------------------- +EXPORT_C TInt CNSmlCmdsBase::ServerObjectSize( const SmlPcdata_t* aMeta ) const + { + TInt sizeNum = 0; + if ( aMeta ) + { + if ( ( aMeta->content ) && ( aMeta->contentType == SML_PCDATA_EXTENSION ) && ( aMeta->extension == SML_EXT_METINF ) ) + { + SmlMetInfMetInf_t* metInf; + metInf = (SmlMetInfMetInf_t*) aMeta->content; + if ( metInf->size ) + { + if ( metInf->size->content ) + { + TPtr8 size( (TUint8*) metInf->size->content, metInf->size->length, metInf->size->length ); + TrimRightSpaceAndNull( size ); + TLex8 lexicalValue( size ); + if ( lexicalValue.Val( sizeNum ) != KErrNone ) + { + sizeNum = 0; + } + } + } + } + } + return sizeNum; + } + +// ----------------------------------------------------------------------------- +// CNSmlCmdsBase::SetMaximumWorkspaceSize +// Sets the maximum workspace size +// ----------------------------------------------------------------------------- +// +EXPORT_C void CNSmlCmdsBase::SetMaximumWorkspaceSize( const TInt aMaxSize ) + { + iMaxWorkspaceSize = aMaxSize; + + if ( iWorkspaceSize == KNSmlDefaultWorkspaceSize ) + { + iWorkspaceSize = aMaxSize; + } + } + +// --------------------------------------------------------- +// CNSmlCmdsBase::BufferAreaForDebugDumpL +// +// --------------------------------------------------------- +#ifdef __NOTRANSPORT + +TPtr8 CNSmlCmdsBase::BufferAreaForDebugDumpL() + { + return iBufferArea->Des(); + } + +#endif +