/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

*

*/

//  EXTERNAL RESOURCES

//  Include Files

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <ctsy/pluginapi/cmmdatapackage.h>

// Temporarily removed for Bridge camp!

//#include <ctsy/serviceapi/ctsysatmessagingbase.h>

#include <etelsat.h>  // for sat mo sm control error values

#include <ctsy/serviceapi/gsmerror.h> // for sat mo sm control error values

#include <etelmmerr.h>

#include <tisi.h>

#include <smsisi.h>

#include <gsmuelem.h> // for tsmsfirstoctet

#include <ctsy/rmmcustomapi.h>

#include "cmmsmsmesshandler.h"

#include "cmmnetmesshandler.h"

#include "cmmsmsgsmaddress.h"

#include "cmmstaticutility.h"

#include "cmmmessagerouter.h"

#include "cmmphonemesshandler.h"

#include "tsylogger.h"

#include "cmmphonetsender.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmsmsmesshandlerTraces.h"

#endif

//  External Data Structures

//  none

//  External Function Prototypes

//  none

//  LOCAL CONSTANTS AND MACROS

const TUint8 KSmsPadding( 0x00 ); // Filler byte for ISI messages

// const TUint8 KUnicodeCharLength( 2 ); Compiler warning removal

// The following constanst are for extracting information from TPDU

// See 3GPP 23.040.

// For submit and command types

const TUint8 KTpduIndexMessageParameters( 0 );

const TUint8 KTpduIndexMessageReference( 1 );

// SMS submit type specific costanst

const TUint8 KTpduSubmitIndexDestinationAddressLength( 2 );

const TUint8 KTpduSubmitIndexProtocolIdentifier( 4 );

const TUint8 KTpduSubmitIndexDataCodingScheme( 5 );

const TUint8 KTpduSubmitIndexValidityperiod( 6 );

// User data length index when no validity period

const TUint8 KTpduSubmitIndexUserDataLengthIfNoTpVp( 6 );

// User data length index when validity period length is 1

const TUint8 KTpduSubmitIndexUserDataLengthVpfRelative( 7 );

// User data length index when validity period length is 7

const TUint8 KTpduSubmitIndexUserDataLengthVpfAbsoluteEnchanced( 13 );

// SMS command type specific constants

const TUint8 KTpduCommandIndexProtocolIdentifier( 2 );

const TUint8 KTpduCommandIndexType( 3 );

const TUint8 KTpduCommandIndexMessageNumber( 4 );

const TUint8 KTpduCommandIndexDestinationAddressLength( 5 );

const TUint8 KTpduCommandIndexUserDataLength( 7 );

// const TUint8 KSizeOfAlphaTag( 34 ); Compiler warning removal

const TUint8 KSmsScTimeStampMaxLength( 7 );

// Constanst for SMS parameters

const TUint8 KSmsMandatoryParamsLength( 28 );

const TUint8 KSmsMaxAddressLength( 12 );

const TUint8 KSmsParamsParamIndicatorOffset( 0 );

const TUint8 KSmsParamsDestAddressOffset( 1 );

const TUint8 KSmsParamsScAddressOffset( 13 );

const TUint8 KSmsParamsProtocolIdOffset( 25 );

const TUint8 KSmsParamsDcsOffset( 26 );

const TUint8 KSmsParamsValidityPeriodOffset( 27 );

const TUint8 KSizeOfAlphaTag( 62 );

//  MODULE DATA STRUCTURES

//  Local Data Structures

//  none

//  Local Function Prototypes

//  none

//  LOCAL FUNCTIONS

//  none

//  MEMBER FUNCTIONS

//=============================================================================

// -----------------------------------------------------------------------------

// CMmSmsMessHandler::CMmSmsMessHandler

// C++ default constructor

// -----------------------------------------------------------------------------

//

CMmSmsMessHandler::CMmSmsMessHandler()

    {

TFLOGSTRING("TSY: CMmSmsMessHandler::CMmSmsMessHandler: constructor.");

OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_CMMSMSMESSHANDLER, "CMmSmsMessHandler::CMmSmsMessHandler" );

    }

// -----------------------------------------------------------------------------

// CMmSmsMessHandler::CMmSmsMessHandler

// C++ default destructor

// -----------------------------------------------------------------------------

//

CMmSmsMessHandler::~CMmSmsMessHandler()

    {

TFLOGSTRING("TSY: CMmSmsMessHandler::CMmSmsMessHandler: destructor.");

OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_CMMSMSMESSHANDLER, "CMmSmsMessHandler::~CMmSmsMessHandler" );

    // Delete arrays

    if( iSmsListArray )

        {

        iSmsListArray->ResetAndDestroy();

        delete iSmsListArray;

        }

    if( iSmspListArray )

        {

        iSmspListArray->ResetAndDestroy();

        delete iSmspListArray;

        }

    }

// -----------------------------------------------------------------------------

// CMmSmsMessHandler::NewL

// Creates a new Gsm specific SmsMessageHandler object instance

// -----------------------------------------------------------------------------

//

CMmSmsMessHandler* CMmSmsMessHandler::NewL(

    CMmPhoNetSender* aPhoNetSender,      // pointer to PhoNet sender

    CMmPhoNetReceiver* aPhoNetReceiver,  // pointer to PhoNet receiver

    CMmMessageRouter* aMessageRouter,    // pointer to Message router

    CMmUiccMessHandler* aUiccMessHandler // pointer to UICC message handler

    )

    {

TFLOGSTRING("TSY: CMmSmsMessHandler::NewL");

OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_NEWL, "CMmSmsMessHandler::NewL" );

    CMmSmsMessHandler* smsMessHandler = new ( ELeave ) CMmSmsMessHandler();

    CleanupStack::PushL( smsMessHandler );

    smsMessHandler->iPhoNetSender = aPhoNetSender;

    smsMessHandler->iMessageRouter = aMessageRouter;

    smsMessHandler->iMmUiccMessHandler = aUiccMessHandler;

    smsMessHandler->ConstructL();

    aPhoNetReceiver->RegisterL( smsMessHandler, PN_SMS );

    CleanupStack::Pop( smsMessHandler );

    return smsMessHandler;

    }

// -----------------------------------------------------------------------------

// CMmSmsMessHandler::ConstructL

// Initialises object attributes

// -----------------------------------------------------------------------------

//

void CMmSmsMessHandler::ConstructL()

    {

TFLOGSTRING("TSY: CMmSmsMessHandler::ConstructL");

OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_CONSTRUCTL, "CMmSmsMessHandler::ConstructL" );

    iSmsListArray = new ( ELeave ) CArrayPtrFlat<TSmsMsg>( 1 );

    iSmspListArray = new ( ELeave ) CArrayPtrFlat<TSmsParameters>( 1 );

    iReceivedClass2ToBeReSent = EFalse;

    // default bearer setting is "CS preferred"

    iMobileSmsBearer = RMobileSmsMessaging::ESmsBearerCircuitPreferred;

    iMemoryCapacityExceeded = EFalse;

    // Reading of SMSP entries starts from record 1

    iSmspRecordNumber = 1;

    }

// -----------------------------------------------------------------------------

// CMmSmsMessHandler::ReceiveMessageL

// Called by PhonetReceiver when an ISI message has been received

// -----------------------------------------------------------------------------

//

void CMmSmsMessHandler::ReceiveMessageL( const TIsiReceiveC& aIsiMessage )

    {

    TUint8 resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );

    TUint8 messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

TFLOGSTRING3("TSY: CMmSmsMessHandler::ReceiveMessageL - resource: %d, msgId: %d", resource, messageId);

OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_RECEIVEMESSAGEL,"CMmSmsMessHandler::ReceiveMessageL;resource=%hhu;messageId=%hhu", resource, messageId );

    switch ( resource )

        {

        case PN_SMS:

            {

            switch( messageId )

                {

                case SMS_MESSAGE_SEND_RESP:

                    {

                    // check transaction id type

                    TUint8 traId( aIsiMessage.Get8bit(

                        ISI_HEADER_OFFSET_TRANSID ) );

                    if ( ESmsMessagingSendMessage == traId )

                        {

                        // SMS Messaging-originated SendSMS

                        SmsMessageSendResp( aIsiMessage,

                            EMobileSmsMessagingSendMessage );

                        }

                    else if ( ESmsMessagingSendNoFdnMessage == traId )

                        {

                        SmsMessageSendResp( aIsiMessage,

                            EMobileSmsMessagingSendMessageNoFdnCheck );

                        }

                    else if ( ESmsMessagingSendSatMessage == traId )

                        {

                        // SAT-originated SendSMS

                        SmsMessageSendResp( aIsiMessage,

                            EMmTsySmsSendSatMessage );

                        }

                    else

                        {

TFLOGSTRING2("TSY:CMmSmsMessHandler::ReceiveMessageL:Unexpected transId=%d in SMS_MESSAGE_SEND_RESP.",traId);

OstTraceExt1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_RECEIVEMESSAGEL, "CMmSmsMessHandler::ReceiveMessageL;traId=%hhu", traId );

                        }

                    break;

                    }

                case SMS_RECEIVE_MESSAGE_RESP:

                    {

                    SmsReceiveMessageResp( aIsiMessage );

                    break;

                    }

                case SMS_RECEIVED_MSG_IND:

                    {

                    SmsReceivedMsgInd( aIsiMessage );

                    break;

                    }

                case SMS_RECEIVED_MSG_REPORT_RESP:

                    {

                    SmsReceivedMsgReportResp( aIsiMessage );

                    break;

                    }

                case SMS_SETTINGS_UPDATE_RESP :

                    {

                    SmsSettingsUpdateResp( aIsiMessage );

                    break;

                    }

                default:

                    {

TFLOGSTRING2("TSY: CMmSmsMessHandler::ReceiveMessageL - PN_SMS - unknown msgId: %d", messageId);

OstTraceExt1( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_RECEIVEMESSAGEL, "CMmSmsMessHandler::ReceiveMessageL;messageId=%hhu", messageId );

                    // No handler methods for ISI-message found.

                    break;

                    }

                }

            break;

            }

        default:

            {

TFLOGSTRING2("TSY: CMmSmsMessHandler::ReceiveMessageL - unknown resource: %d", resource);

OstTraceExt1( TRACE_NORMAL, DUP6_CMMSMSMESSHANDLER_RECEIVEMESSAGEL, "CMmSmsMessHandler::ReceiveMessageL;resource=%hhu", resource );

            // No handler methods for ISI-message found.

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CMmSmsMessHandler::SmsMessageSendReq

// Creates request for SMS message sending

// -----------------------------------------------------------------------------

//

TInt CMmSmsMessHandler::SmsMessageSendReq(

    TUint8 aTransactionId,              // Transaction ID

    const CMmDataPackage* aDataPackage, // Packed data

    TBool aSmsCheckDisableFdn )         // Add SMS_SB_CHECK_INFO with

                                        // SMS_CHECK_DISABLE_FDN

    {

TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsMessageSendReq. Transaction ID: %d", aTransactionId);

OstTraceExt1( TRACE_NORMAL,DUP18_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ,"CMmSmsMessHandler::SmsMessageSendReq;aTransactionId=%hhu", aTransactionId );

    TInt ret( KErrNone );

    TUint8 subBlockId( 0 );

    // Structure for all SMS parameters and user data

    TSendSmsDataAndAttributes sendData;

    // Structure for message attributes

    RMobileSmsMessaging::TMobileSmsSendAttributesV1* msgAttr;

    // Buffer for TPDU

    TBuf8<RMobileSmsMessaging::KGsmTpduSize> msgData;

    aDataPackage->UnPackData( sendData );

    msgAttr = sendData.iAttributes;

    // Check TPDU length

    if ( RMobileSmsMessaging::KGsmTpduSize >= sendData.iMsgData->Length() )

        {

        msgData.Append( *sendData.iMsgData );

        // Get TP-MTI (TP-Message-Type-Indicator) from first octet of TPDU

        TUint8 tpMti( msgData[KTpduIndexMessageParameters] &

            TSmsFirstOctet::ESmsMTIMask );

        if ( TSmsFirstOctet::ESmsMTISubmitOrSubmitReport == tpMti )

            {

            subBlockId = SMS_SB_SUBMIT;

            }

        else if ( TSmsFirstOctet::ESmsMTIStatusReportOrCommand == tpMti )

            {

            subBlockId = SMS_SB_COMMAND;

            }

        else // Message type not supported

            {

            ret = CMmStaticUtility::EpocErrorCode(

                KErrArgument,

                KErrGsmSMSTpduNotSupported );

TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsMessageSendReq. Error! SMS type not supported: %d", tpMti);

OstTraceExt1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ, "CMmSmsMessHandler::SmsMessageSendReq.Error! SMS type not supported;tpMti=%hhu", tpMti );

            }

        }

    else

        {

        // TPDU too long

        ret = CMmStaticUtility::EpocErrorCode(

            KErrArgument,

            KErrGsmSMSTpduNotSupported );

TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsMessageSendReq. Error! TPDU too long: %d", sendData.iMsgData->Length());

OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ, "CMmSmsMessHandler::SmsMessageSendReq.Error! TPDU too long;sendData.iMsgData->Length()=%d", sendData.iMsgData->Length() );

        }

    // Check the format of TPDU and data buffer

    if ( ! ( RMobileSmsMessaging::KSmsDataFormat & msgAttr->iFlags &&

        RMobileSmsMessaging::EFormatGsmTpdu & msgAttr->iDataFormat ) )

        {

        ret = CMmStaticUtility::EpocErrorCode(

            KErrArgument,

            KErrGsmSMSTpduNotSupported );

TFLOGSTRING3("TSY: CMmSmsMessHandler::SmsMessageSendReq. Error! Invalid TPDU format (%d) or data buffer format (%d)", msgAttr->iFlags, msgAttr->iDataFormat );

OstTraceExt2( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ, "CMmSmsMessHandler::SmsMessageSendReq.Error!;msgAttr->iFlags=%d;msgAttr->iDataFormat=%hhu", msgAttr->iFlags, msgAttr->iDataFormat );

        }

#if (NCP_COMMON_S60_VERSION_SUPPORT>S60_VERSION_32)

    // Check whether there is SMS sending ongoing.

    if ( iSMSSendingOngoing )

        {

        ret = KErrServerBusy;

TFLOGSTRING("TSY: CMmSmsMessHandler::SmsMessageSendReq. SMS sending failed, server busy!" );

OstTrace0( TRACE_NORMAL, DUP17_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ, "CMmSmsMessHandler::SmsMessageSendReq. SMS sending failed, server busy!" );

        }

#endif // NCP_COMMON_S60_VERSION_SUPPORT

    if ( KErrNone == ret )

        {

        // Create and send SMS_MESSAGE_SEND_REQ message with needed subblocks

        ret = CreateSmsMessageSendReq(

            aTransactionId,

            msgAttr,

            msgData,

            subBlockId,

            aSmsCheckDisableFdn );

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// CMmSmsMessHandler::CreateSmsMessageSendReq

// Construct a SMS_MESSAGE_SEND_REQ ISI message with needed subblocks

// for SMS message send request to SMS server

// -----------------------------------------------------------------------------

//

TInt CMmSmsMessHandler::CreateSmsMessageSendReq(

    TUint8 aTransactionId,

    RMobileSmsMessaging::TMobileSmsSendAttributesV1* aMsgAttr,

    const TDesC8& aMsgData,

    TUint8 aSubblockId,

    TBool aSmsCheckDisableFdn )         // Add SMS_SB_CHECK_INFO with

                                        // SMS_CHECK_DISABLE_FDN

    {

    // Structure of the message, depending on the TP-MTI:

    // SMS_MESSAGE_SEND_REQ (8 bytes + sub blocks, total max. 212)

    //  |

    //  |- SMS_SB_SUBMIT (mandatory, 8 bytes)

    //  |

    //  |- SMS_SB_ADDRESS (destination address, mandatory, max. 20 bytes)

    //  |

    //  |- SMS_SB_ADDRESS (service center address, mandatory, max. 20 bytes)

    //  |

    //  |- SMS_SB_USER_DATA (optional, max. 148 bytes)

    //  |

    //  |- SMS_SB_VALIDITY_PERIOD (optional, max. 12 bytes)

    //

    // or

    //

    // SMS_MESSAGE_SEND_REQ (8 bytes + sub blocks, total max. 220)

    //  |

    //  |- SMS_SB_COMMAND (mandatory, 12 bytes)

    //  |

    //  |- SMS_SB_ADDRESS (destination address, mandatory, max. 20 bytes)

    //  |

    //  |- SMS_SB_ADDRESS (service center address, mandatory, max. 20 bytes)

    //  |

    //  |- SMS_SB_USER_DATA (optional, max. 174 bytes)

TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. Subblock ID: %d", aSubblockId);

OstTraceExt1( TRACE_NORMAL, DUP9_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq;aSubblockId=%hhu", aSubblockId );

    TInt ret( KErrNone );

    TUint8 addressLength( 0 );

    ret = GetDestAddressLength( aMsgData, aSubblockId, addressLength );

    // Destination address is OK. Create ISI message and needed subblocks

    if ( KErrNone == ret )

        {

        TUint8 moreMsgToSend( 0 );

        TUint8 smsRoute( SMS_ROUTE_DEFAULT );

        TUint8 tpVpLength( 0 );

        TUint8 tpVpf( 0 );

        TUint8 tpVpSubblockLength( SIZE_SMS_SB_VALIDITY_PERIOD );

        TUint8 tpUdl( 0 );

        TUint8 tpUserDataLengthIndex( KTpduSubmitIndexUserDataLengthIfNoTpVp );

        TUint8 tpUserDataIndex( 0 );

        TUint8 tpDaIndex( KTpduSubmitIndexDestinationAddressLength );

        TUint8 tpDcs( 0 );

        TUint8 msgOffset( ISI_HEADER_SIZE + SIZE_SMS_MESSAGE_SEND_REQ );

        TUint8 numOfSubblocks( 3 ); // 3 mandatory subblocks

        TUint8 lengthOfAddressSb( 0 );

        TUint8 lengthOfSMSUserDataSb( 0 );

        TBool defaultAlphabet( EFalse ); // Data coding type, true if 7-bit

        // Check if more to send parameter is included

        if ( RMobileSmsMessaging::KMoreToSend & aMsgAttr->iFlags )

            {

            moreMsgToSend = static_cast<TUint8>( aMsgAttr->iMore );

            }

        // Set the bearer

        if ( RMobileSmsMessaging::ESmsBearerPacketOnly == iMobileSmsBearer )

            {

            smsRoute = SMS_ROUTE_PS;

            }

        else if ( RMobileSmsMessaging::ESmsBearerCircuitOnly ==

            iMobileSmsBearer )

            {

            smsRoute = SMS_ROUTE_CS;

            }

        // No else. SMS_ROUTE_DEFAULT is used. The route is used that is

        // available and preferred by PP-bits or prior client settings

        // Create SMS_MESSAGE_SEND_REQ message

        TIsiSend isiMsg( iPhoNetSender->SendBufferDes() );

        isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_SMS );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + SMS_MESSAGE_SEND_REQ_OFFSET_TRANSID,

            aTransactionId );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + SMS_MESSAGE_SEND_REQ_OFFSET_MESSAGEID,

            SMS_MESSAGE_SEND_REQ );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + SMS_MESSAGE_SEND_REQ_OFFSET_MOREMESSAGESTOSEND,

            moreMsgToSend );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + SMS_MESSAGE_SEND_REQ_OFFSET_SMSROUTE,

            smsRoute );

        // Set repeatedMessage to FALSE. Tsy doesn't know if message is tried

        // to send first or second time.

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + SMS_MESSAGE_SEND_REQ_OFFSET_REPEATEDMESSAGE,

            EFalse );

        // Filler, two bytes

        isiMsg.Set16bit(

            ISI_HEADER_SIZE + SMS_MESSAGE_SEND_REQ_OFFSET_FILLERBYTE1,

            0 );

TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_MESSAGE_SEND_REQ created. Message offset: %d", msgOffset );

TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. More messages to be sent: %d", moreMsgToSend);

TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS route: %d", smsRoute);

OstTraceExt3( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq;msgOffset=%hhu;moreMsgToSend=%hhu;smsRoute=%hhu", msgOffset, moreMsgToSend, smsRoute );

        // Create SMS_SB_SUBMIT subblock

        if ( SMS_SB_SUBMIT == aSubblockId )

            {

            BuildSmsSbSubmit( aMsgData, isiMsg, msgOffset, addressLength );

            msgOffset += SIZE_SMS_SB_SUBMIT;

TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_SUBMIT created. Message offset: %d", msgOffset );

OstTraceExt1( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_SUBMIT created.;msgOffset=%hhu", msgOffset );

            // Set needed TPDU index values that depends on SMS type, VP existence

            // and destination address length. Those parameters are needed when

            // creating subblocks SMS_DESTINATION_ADDRESS, SMS_SB_VALIDITY_PERIOD

            // and SMS_SB_USER_DATA.

            // TP-VPF is LSB bits 3 and 4 from the first octect of TPDU

            tpVpf = ( aMsgData[KTpduIndexMessageParameters] >> 3 ) & 3;

            if ( tpVpf )

                {

                // Relative format (tpVpf == 2).

                // Subblock length SIZE_SMS_SB_VALIDITY_PERIOD by default

                if ( 2 == tpVpf)

                    {

                    tpVpLength = SMS_VPF_RELATIVE;

                    tpUserDataLengthIndex =

                        KTpduSubmitIndexUserDataLengthVpfRelative;

                    }

                // Absolute or enhanced format, subblock length is 12

                else

                    {

                    tpVpLength = SMS_VPF_ABSOLUTE_OR_ENHANCED;

                    tpVpSubblockLength = 12;