--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/smsprotocols/smsstack/smsprot/Src/smspproc.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,675 @@
+// Copyright (c) 1999-2009 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:
+//
+
+/**
+ @file
+*/
+
+
+#include "smspproc.h"
+#include "smspmondsk.h"
+#include "smspfacadestor.h"
+#include "smsuset.h"
+#include "smsulog.h"
+#include "smspmain.h"
+
+#include <gsmusar.h>
+#include <exterror.h>
+#include "gsmubuf.h"
+#include "Gsmumsg.h"
+#include "smspcdb.h"
+#include "smspread.h"
+
+
+/**
+ * Creates new CSmsPDUProcess instance
+ *
+ * @return a new CSmsPDUProcess object.
+ */
+CSmsPDUProcessor* CSmsPDUProcessor::NewL(MSmsComm& aSmsComm, const TSmsSettings& aSmsSettings,
+ CFacadeSmsReassemblyStore& aReassemblyStore,
+ CSmsSegmentationStore& aSegmentationStore,
+ CSmsMonitorDiskSpace& aSmsMonitorDiskSpace)
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::NewL()");
+
+ CSmsPDUProcessor* smsPDUProcessor = new (ELeave) CSmsPDUProcessor(aSmsComm,
+ aSmsSettings,
+ aReassemblyStore,
+ aSegmentationStore,
+ aSmsMonitorDiskSpace);
+
+ CleanupStack::PushL(smsPDUProcessor);
+ smsPDUProcessor->ConstructL();
+ CleanupStack::Pop(smsPDUProcessor);
+
+ return smsPDUProcessor;
+ } // CSmsPDUProcessor::NewL
+
+
+CSmsPDUProcessor::~CSmsPDUProcessor()
+ {
+ delete iSmsMessage;
+ delete iOriginalSmsMessage;
+ iStatusArray.Close();
+ } // CSmsPDUProcessor::~CSmsPDUProcessor
+
+
+CSmsPDUProcessor::CSmsPDUProcessor(MSmsComm& aSmsComm,
+ const TSmsSettings& aSmsSettings,
+ CFacadeSmsReassemblyStore& aReassemblyStore,
+ CSmsSegmentationStore& aSegmentationStore,
+ CSmsMonitorDiskSpace& aSmsMonitorDiskSpace)
+ :iSmsComm(aSmsComm),
+ iSmsSettings(aSmsSettings),
+ iReassemblyStore(aReassemblyStore),
+ iSegmentationStore(aSegmentationStore),
+ iSmsMonitorDiskSpace(aSmsMonitorDiskSpace)
+ {
+ // NOP
+ } // CSmsPDUProcessor::CSmsPDUProcess
+
+
+/**
+ * Second phase constructor.
+ */
+void CSmsPDUProcessor::ConstructL()
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::ConstructL()");
+ } // CSmsPDUProcessor::ConstructL
+
+
+void CSmsPDUProcessor::DecodeAndProcessPDUL(TGsmSmsSlot& aSlot, TBool aIsEnumeration)
+ {
+ LOGSMSPROT2("CSmsPDUProcessor::DecodeAndProcessPDUL(): aIsEnumeration=%d",
+ aIsEnumeration);
+
+ //
+ // Store the slot...
+ //
+ iSlot = aSlot;
+
+ //
+ // We need to know if this message is MT or MO before decoding...
+ //
+ if (iSlot.iMsgStatus == RMobileSmsStore::EStoredMessageUnread ||
+ iSlot.iMsgStatus == RMobileSmsStore::EStoredMessageRead)
+ {
+ iIsMobileTerminated = ETrue;
+ }
+
+ LOGSMSPROT2("CSmsStoreRead::DecodeAndProcessPDUL(): iIsMobileTerminated=%d",
+ iIsMobileTerminated);
+
+ //
+ // Put the PDU and Service Center Address in the TGsmSms structure...
+ //
+ TGsmSmsTelNumber sca;
+
+ sca.iTelNumber = iSlot.iServiceCentre.iTelNumber;
+ sca.iTypeOfAddress.SetFromETelMM(static_cast<NMobilePhone::TMobileTON>(iSlot.iServiceCentre.iTypeOfNumber),
+ static_cast<NMobilePhone::TMobileNPI>(iSlot.iServiceCentre.iNumberPlan));
+ iGsmSms.SetPdu(iSlot.iMsgData);
+ iGsmSms.SetSca(sca);
+
+ //
+ // Allocate a CSmsBuffer for use during the decoding of the PDU and
+ // create the CSmsMessage object - this will actaully decode the PDU. Note
+ // that the CSmsBuffer ownership is transfered during NewL()!!!
+ //
+ CSmsBuffer* smsBuffer = CSmsBuffer::NewL();
+ iSmsMessage = CSmsMessage::NewL(iReassemblyStore.FileSession(), iGsmSms,
+ smsBuffer, EFalse, iIsMobileTerminated);
+
+ //
+ // Store the enumeration type and calculate other basic info...
+ //
+ iIsEnumeration = aIsEnumeration;
+
+ AnalysePDUCharacteristics();
+
+ //
+ // If the store information is supplied, then check if the PDU will
+ // be deleted from the store.
+ //
+ // When enumerating, only messages which are on the SIM or in the
+ // Combined Store are forwarded to the client. If the message on the
+ // SIM is marked for automatic deletion or a type 0, then it may
+ // have its storage set to CSmsMessage::ESmsNoStorage in this routine.
+ // However the method CSmsProtocol::ExternalizeEnumeratedMessagesL()
+ // still needs to know that the message was originally on the SIM or
+ // the combined store.
+ //
+ if (iSlot.iStore.Length() > 0)
+ {
+ iSmsMessage->SetStatus(static_cast<NMobileSmsStore::TMobileSmsStoreStatus>(iSlot.iMsgStatus));
+ if (iSlot.iStore == KETelCombinedSmsStore)
+ {
+ if (iSmsSettings.DeletePDUsFromCombinedStores() == EFalse)
+ {
+ iSmsMessage->SetStorage(CSmsMessage::ESmsCombinedStorage);
+ }
+
+ iSmsMessage->SetDecodedOnSIM(ETrue);
+ }
+ else if (iSlot.iStore == KETelIccSmsStore)
+ {
+ if (iSmsSettings.DeletePDUsFromSIM() == EFalse)
+ {
+ iSmsMessage->SetStorage(CSmsMessage::ESmsSIMStorage);
+ }
+
+ iSmsMessage->SetDecodedOnSIM(ETrue);
+ }
+ else if (iSmsSettings.DeletePDUsFromPhoneStores() == EFalse)
+ {
+ iSmsMessage->SetStorage(CSmsMessage::ESmsPhoneStorage);
+ }
+ }
+
+ //
+ // If the PDU will be deleted, then assume it has no storage...
+ //
+ if (iIsPDUToBeDeleted)
+ {
+ iSmsMessage->SetStorage(CSmsMessage::ESmsNoStorage);
+ }
+
+ //
+ // Is this a MOSES message?
+ //
+ if (iSmsMessage->ToFromAddress().CompareF(KNETWORK) == 0)
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::DecodeAndProcessPDUL(): MOSES OTE message!");
+ if (iSmsComm.NetworkInfoAvailable())
+ {
+ iSmsMessage->SetToFromAddressL(iSmsComm.NetworkInfo().iDisplayTag);
+ }
+ }
+
+ //
+ // Call the processing function for this time of message. Enumerations of
+ // a PDU can be SUBMIT, DELIVER or STATUS-REPORT. Receiving of a PDU can
+ // be SUBMIT or STATUS-REPORT...
+ //
+ if ((iIsEnumeration && iSmsMessage->Type() == CSmsPDU::ESmsSubmit) ||
+ iSmsMessage->Type() == CSmsPDU::ESmsDeliver)
+ {
+ if (iIsForwardMessageToClient)
+ {
+ //
+ // Record that this SMS should be forwarded to the client...
+ //
+ iSmsMessage->SetForwardToClient(ETrue);
+
+ //
+ // Check that there is disk space to process this PDU. This may signal to
+ // the network to stop SMS reception until further notice, and it may go
+ // active to monitor the disk space.
+ //
+ /*
+ The below logic is quite complicated. This logic is written to support backward compatibility.
+ Previously SMS stack was sending -ve ack for class 0 messages before implementation of REQ6523.
+ Even after implementation of REQ6523, there will be provision so that the customer who does
+ not want this feature, then can go back to previous implementation.
+ With REQ6523, there is another requiremnt REQ7012 which states that class 0 WAP messages
+ will be handled like other non-class 0 messages. That means in out-of-disk condition it will
+ send -ve ack to network. WAP class 0 messages will be stored in non-class 0 re-assembly store.
+
+ If SMS stack is configured for handling class 0 messages in out-of-disk condition,
+ Class 0 messages will be stored in reserved space (Pre-allocated file) internally.
+ But if this function is called at the time of enumeration and disk is full then -ve ack
+ will be sent to client for disk full. The behaviour is different for class 0 messages
+ at the time of enumeration & normal read from network.
+ */
+ TInt ret=KErrNone;
+ iIsWapSms = iReassemblyStore.IsWapSMS(*iSmsMessage);
+ if (iIsClass0Message && iIsWapSms)
+ {
+ //Wap class 0 sms message will be stored in non-class 0 reassembly store.
+ TRAP(ret, iSmsMonitorDiskSpace.CheckDiskSpaceForPDUL(EFalse));
+ }
+ else
+ {
+ TRAP(ret, iSmsMonitorDiskSpace.CheckDiskSpaceForPDUL(iIsClass0Message));
+ }
+
+ if ((iIsClass0Message && !iIsWapSms) && iReassemblyStore.IsSeparateClass0StoreSupported() && (!aIsEnumeration))
+ {
+ if (ret == KErrDiskFull)
+ {
+ iReassemblyStore.SetDiskSpaceState(ESmsDiskSpaceFull);
+ ret = KErrNone;
+ }
+ else if (ret == KErrNone)
+ {
+ iReassemblyStore.SetDiskSpaceState(ESmsDiskSpaceAvailable);
+ }
+ }
+
+ if (ret!=KErrNone)
+ {
+ User::Leave(ret);
+ }
+
+ AddSlotToSmsMessageIfRequiredL();
+ AddSegmentOfMessageToReassemblyStoreIfRequiredL();
+ }
+ }
+ else if (iSmsMessage->Type() == CSmsPDU::ESmsStatusReport)
+ {
+ FindOriginalMessageAndProcessStatusReportL();
+
+ if (iIsForwardMessageToClient && iIsMessageGoingToBeStored)
+ {
+ //
+ // Record that this SMS should be forwarded to the client...
+ //
+ iSmsMessage->SetForwardToClient(ETrue);
+
+ AddSlotToSmsMessageIfRequiredL();
+ AddSegmentOfMessageToReassemblyStoreIfRequiredL();
+ }
+
+ //
+ // If the message to which this report refers is complete (and
+ // logically most will be as unless it refers to a SMS-SUBMIT
+ // message we no longer have), then update the received time and
+ // the
+ //
+ if (iIsComplete)
+ {
+ UpdateStatusReportL();
+ }
+ }
+ else
+ {
+ User::Leave(KErrCorrupt);
+ }
+
+ //
+ // Should we delete the PDU?
+ //
+ if ((iIsEnumeration && iSlot.iStore == KETelMeSmsStore) ||
+ (iIsEnumeration == EFalse && iSmsMessage->Storage() != CSmsMessage::ESmsSIMStorage) ||
+ iIsPDUToBeDeleted)
+ {
+ DeletePDUL();
+ }
+ } // CSmsPDUProcessor::DecodeAndProcessPDUL
+
+
+void CSmsPDUProcessor::AnalysePDUCharacteristics()
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::AnalysePDUCharacteristics()");
+
+ CSmsPDU& pdu = iSmsMessage->SmsPDU();
+
+ //
+ // Check store the message class...
+ //
+ TSmsDataCodingScheme::TSmsClass msgClass;
+
+ if (pdu.DataCodingSchemePresent() && pdu.Class(msgClass))
+ {
+ if (msgClass == TSmsDataCodingScheme::ESmsClass0)
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::AnalysePDUCharacteristics(): Class 0");
+ iIsClass0Message = ETrue;
+ }
+ else if (msgClass == TSmsDataCodingScheme::ESmsClass1)
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::AnalysePDUCharacteristics(): Class 1");
+ iIsClass1Message = ETrue;
+ }
+ else if (msgClass == TSmsDataCodingScheme::ESmsClass2)
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::AnalysePDUCharacteristics(): Class 2");
+ iIsClass2Message = ETrue;
+ }
+ else if (msgClass == TSmsDataCodingScheme::ESmsClass3)
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::AnalysePDUCharacteristics(): Class 3");
+ iIsClass3Message = ETrue;
+ }
+ else
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::AnalysePDUCharacteristics(): Class Unknown!");
+ }
+ }
+ else
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::AnalysePDUCharacteristics(): Class-less");
+ }
+
+ //
+ // Is this PDU PID Type 0?
+ //
+ if (pdu.ProtocolIdentifierPresent() &&
+ pdu.PIDType() == TSmsProtocolIdentifier::ESmsPIDShortMessageType &&
+ pdu.ShortMessageType() == TSmsProtocolIdentifier::ESmsShortMessageType0)
+ {
+ iIsPIDType0 = ETrue;
+ }
+
+ LOGSMSPROT2("CSmsPDUProcessor::AnalysePDUCharacteristics(): iIsPIDType0=%d",
+ iIsPIDType0);
+
+ //
+ // Should this message be forwarded to the client?
+ //
+ if (!(iIsPIDType0 &&
+ ((iIsClass0Message && iOptionDiscardType0Class0) ||
+ (iIsClass2Message && iOptionDiscardType0Class2) ||
+ (iIsClass0Message == EFalse && iIsClass2Message == EFalse))))
+ {
+ iIsForwardMessageToClient = ETrue;
+ }
+
+ LOGSMSPROT2("CSmsPDUProcessor::AnalysePDUCharacteristics(): iIsForwardMessageToClient=%d",
+ iIsForwardMessageToClient);
+
+ //
+ // Is it flaged for auto-delete?
+ //
+ if (pdu.DataCodingSchemePresent())
+ {
+ TInt autoDelete = pdu.Bits7To4() & TSmsDataCodingScheme::ESmsDCSAutomaticDeletionMask;
+
+ if (autoDelete == TSmsDataCodingScheme::ESmsDCSAutomaticDeletion)
+ {
+ iIsMarkedForAutoDelete = ETrue;
+ }
+ }
+
+ LOGSMSPROT2("CSmsPDUProcessor::AnalysePDUCharacteristics(): iIsMarkedForAutoDelete=%d",
+ iIsMarkedForAutoDelete);
+
+ //
+ // Should this PDU be deleted after processing?
+ //
+ if (iIsMarkedForAutoDelete &&
+ (iIsClass2Message == EFalse || iOptionApplyAutoDeletionToClass2))
+ {
+ iIsPDUToBeDeleted = ETrue;
+ }
+ else if (iIsPIDType0 &&
+ (iIsClass2Message == EFalse || iOptionDiscardType0Class2))
+ {
+ iIsPDUToBeDeleted = ETrue;
+ }
+
+ LOGSMSPROT2("CSmsPDUProcessor::AnalysePDUCharacteristics(): iIsPDUToBeDeleted=%d",
+ iIsPDUToBeDeleted);
+
+ //
+ // Does the message need to be stored???
+ //
+ // Don't store class 2 SMSs with index 0 on SIM. Not sure why, but
+ // it appears to be delibrate and no one has ever complained!
+ //
+ // Don't store messages already stored somewhere other than the
+ // phone store.
+ //
+ if (iIsPDUToBeDeleted == EFalse &&
+ ((iIsEnumeration && iSlot.iIndex != 0 && iSlot.iStore != KETelMeSmsStore) ||
+ (iSlot.iStore != KETelMeSmsStore && iSlot.iStore.Length() > 0)))
+ {
+ iIsMessageGoingToBeStored = ETrue;
+ }
+
+ LOGSMSPROT2("CSmsPDUProcessor::AnalysePDUCharacteristics(): iIsMessageGoingToBeStored=%d",
+ iIsMessageGoingToBeStored);
+
+ //
+ // Is the message complete? This value may change later, when the segmentation and
+ // reassembley stores are examined.
+ //
+ iIsComplete = iSmsMessage->IsComplete();
+
+ LOGSMSPROT2("CSmsPDUProcessor::AnalysePDUCharacteristics(): iIsComplete=%d",
+ iIsComplete);
+
+ //
+ // Store PDU Data. These values may be updated later.
+ //
+ iSmsPDUData.iType = iSmsMessage->Type();
+ iSmsPDUData.iTotal = 1;
+ iSmsPDUData.iReceived = 1;
+ } // CSmsPDUProcessor::AnalysePDUCharacteristics
+
+
+void CSmsPDUProcessor::FindOriginalMessageAndProcessStatusReportL()
+ {
+ __ASSERT_DEBUG(iSmsMessage->Type() == CSmsPDU::ESmsStatusReport,
+ SmspPanic(KSmspPanicNotStatusReport));
+
+ //
+ // Find the original message in the segmentation store and update its status
+ // to that contained in the status report.
+ //
+ TBool found = iSegmentationStore.AddStatusReportL(iIndex, iIsComplete, *iSmsMessage);
+
+ LOGSMSPROT2("CSmsPDUReadProcess::FindOriginalMessageAndProcessStatusReportL(): found=%d",found);
+
+ if (found)
+ {
+ //
+ // The status report refers to a known message. Update the this status message
+ // with the correct Log Server ID and it's related info.
+ //
+ const TSmsSegmentationEntry& entry = (const TSmsSegmentationEntry&)
+ iSegmentationStore.Entries()[iIndex];
+
+ iSmsMessage->SetLogServerId(entry.LogServerId());
+
+ iSmsPDUData.iType = entry.PduType();
+ iSmsPDUData.iTotal = entry.Total();
+ iSmsPDUData.iSent = entry.Count();
+ iSmsPDUData.iDelivered = entry.Delivered();
+ iSmsPDUData.iFailed = entry.Failed();
+
+ //
+ // Load the original SUBMIT message into memory for further processing later...
+ // Note that smsBuffer's ownership transfers straight away!!!
+ //
+ CSmsBuffer* smsBuffer = CSmsBuffer::NewL();
+
+ iOriginalSmsMessage = CSmsMessage::NewL(iReassemblyStore.FileSession(),
+ CSmsPDU::ESmsSubmit,
+ smsBuffer);
+ iSegmentationStore.GetMessageL(iIndex, iSmsAddr, *iOriginalSmsMessage,
+ iStatusArray);
+ }
+ } // CSmsPDUProcessor::FindOriginalMessageAndProcessStatusReportL
+
+
+void CSmsPDUProcessor::UpdateStatusReportL()
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::UpdateStatusReportL()");
+
+ //
+ // Update the receive time of the status report...
+ //
+ TTime currTime;
+ currTime.UniversalTime();
+
+ iSmsMessage->SetTime(currTime);
+ iSmsMessage->SetUTCOffset(User::UTCOffset());
+ iSmsMessage->SetToFromAddressL(iOriginalSmsMessage->ToFromAddress());
+
+ //
+ // Set the status report to the last status received by the SME...
+ //
+ CSmsStatusReport& statusReport = (CSmsStatusReport&) iSmsMessage->SmsPDU();
+ TInt count = iStatusArray.Count();
+
+ for (TInt index = 0; index < count; index++)
+ {
+ TInt status = iStatusArray[index].Status();
+
+ statusReport.SetStatus((TSmsStatus::TSmsStatusValue) status);
+ if (status != TSmsStatus::ESmsShortMessageReceivedBySME)
+ {
+ break;
+ }
+ }
+ } // CSmsPDUProcessor::UpdateStatusReportL
+
+
+void CSmsPDUProcessor::AddSlotToSmsMessageIfRequiredL()
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::AddSlotToSmsMessageIfRequiredL()");
+
+ //
+ // Add the slot to the message (if it is not going to be deleted and
+ // the client needs to know it's location e.g. to store it)...
+ //
+ if (iIsMessageGoingToBeStored)
+ {
+ TGsmSmsSlotEntry smsSlotEntry;
+
+ smsSlotEntry.iIndex = iSlot.iIndex;
+ smsSlotEntry.iStore = iSlot.iStore;
+
+ iSmsMessage->AddSlotL(smsSlotEntry);
+ }
+ } // CSmsPDUProcessor::AddSlotToSmsMessageIfRequiredL
+
+
+/**
+ * Add the message segment to the reassembly store. There are 5 possiblities:
+ *
+ * 1) This is the complete message (e.g. a single-segment message).
+ * We therefore have all the segments.
+ * 2) This is a duplicate message segment.
+ * We will ignore it.
+ * 3) This is the last segment in the message required to complete it.
+ * The other segments are already stored.
+ * 4) This is another PDU to an existing message in the store, but it is
+ * not yet complete.
+ * 5) This is the first PDU in the message, and therefore the message is
+ * not yet complete and no segments are stored.
+ *
+ * @note Only SUBMIT or DELIVER PDUs can be added to the reassembly store.
+ */
+void CSmsPDUProcessor::AddSegmentOfMessageToReassemblyStoreIfRequiredL()
+ {
+ LOGSMSPROT2("CSmsPDUReadProcess::AddSegmentOfMessageToReassemblyStoreIfRequiredL(): iIsComplete=%d",
+ iIsComplete);
+
+ iReassemblyStore.AddSegmentToReassemblyStoreL(*iSmsMessage, iGsmSms, iIndex, iIsComplete, iIsEnumeration, iSmsPDUData.iReceived, iSmsPDUData.iTotal);
+ } // CSmsPDUProcessor::AddSegmentOfMessageToReassemblyStoreIfRequiredL
+
+
+void CSmsPDUProcessor::UpdateLogServerIdL()
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::UpdateLogServerIdL()");
+
+ //
+ // If this is a SUBMIT or DELIVER PDU,
+ // then search for it in the Reassembly store.
+ //
+ if (iSmsMessage != NULL && iIndex != KErrNotFound &&
+ (iSmsMessage->Type() == CSmsPDU::ESmsSubmit ||
+ iSmsMessage->Type() == CSmsPDU::ESmsDeliver))
+ {
+ iReassemblyStore.UpdateLogServerIdL(*iSmsMessage, iIndex);
+ }
+ } // CSmsPDUProcessor::UpdateLogServerIdL
+
+void CSmsPDUProcessor::ProcessMessageIfCompleteL()
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::ProcessMessageIfCompleteL()");
+
+ if ((iIsClass0Message && !iIsWapSms) && iReassemblyStore.IsSeparateClass0StoreSupported())
+ {
+ //Note: Process Class 0 Message which is not wap message & return.
+ if (iIsComplete)
+ {
+ //
+ // Process the message...
+ //
+ if (iOriginalSmsMessage == NULL)
+ {
+ iReassemblyStore.ForwardCompleteClass0SmsMessagesL(iSmsComm, *iSmsMessage, NULL, iOriginalSmsMessage, iDeliverReportBuffer);
+ }
+ else
+ {
+ iReassemblyStore.ForwardCompleteClass0SmsMessagesL(iSmsComm, *iSmsMessage, &iSmsAddr, iOriginalSmsMessage, iDeliverReportBuffer);
+ }
+ }
+ else
+ {
+ iReassemblyStore.ProcessMessageIfExceedLimitationL(iSmsComm);
+ }
+ return;
+ }
+
+ if (iIsComplete)
+ {
+ //
+ // Process the message...
+ //
+ TInt ret(KErrUnknown);
+
+ if (iOriginalSmsMessage == NULL)
+ {
+ ret = iSmsComm.ProcessMessageL(*iSmsMessage, NULL,
+ iOriginalSmsMessage,
+ iDeliverReportBuffer);
+ }
+ else
+ {
+ ret = iSmsComm.ProcessMessageL(*iSmsMessage, &iSmsAddr,
+ iOriginalSmsMessage,
+ iDeliverReportBuffer);
+ }
+
+ //
+ // If successful, mark the entry as delivered to the msgc...
+ //
+ if(ret == KErrNone)
+ {
+ iReassemblyStore.SetMessagePassedToClientL(*iSmsMessage);
+ }
+ }
+ } // CSmsPDUProcessor::ProcessMessageIfCompleteL
+
+void CSmsPDUProcessor::DeletePDUL()
+ {
+ LOGSMSPROT1("CSmsPDUProcessor::DeletePDUL()");
+
+ //
+ // If the slot number has an index and store assigned, then we can delete
+ // it.
+ //
+ if (iSlot.iIndex >= 0 && iSlot.iStore.Length() > 0)
+ {
+ CArrayFixFlat<TGsmSmsSlotEntry>* smsSlotEntryArray = new (ELeave) CArrayFixFlat<TGsmSmsSlotEntry>(1);
+ CleanupStack::PushL(smsSlotEntryArray);
+
+ TGsmSmsSlotEntry smsSlotEntry;
+
+ smsSlotEntry.iIndex = iSlot.iIndex;
+ smsSlotEntry.iStore = iSlot.iStore;
+ smsSlotEntryArray->AppendL(smsSlotEntry);
+
+ iSmsComm.DeletePDUs(*smsSlotEntryArray, NULL);
+
+ CleanupStack::PopAndDestroy(smsSlotEntryArray);
+ }
+ } // CSmsPDUProcessor::DeletePDUL
+