DataMessage AlanTuring::decodeMessage (NetworkMessage netMsg)
{
DataMessage dataMsg;
memcpy(&dataMsg, netMsg.msg_Data, sizeof(DataMessage));
std::string msgID(dataMsg.msg_ID);
int pos = msgID.find("$");
string id(msgID.substr(0, pos));
msgID.erase(0, pos + 1);
string valor(msgID);
memcpy(dataMsg.msg_ID, id.c_str(), MESSAGE_ID_BYTES_LIMIT);
memcpy(dataMsg.msg_value, valor.c_str(), MESSAGE_VALUE_SIZE);
return dataMsg;
}
// ---------------------------------------------------------
// 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 );
}
