// Copyright (c) 2003-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:

// Implements the CSmsProtocol and its helper classes.

// 

//

/**

 @file

*/

#include <commsdattypesv1_1.h>

#include <logwrap.h>

#include "Gsmumsg.h"

#include "gsmubuf.h"

#include "Gsmuelem.h"

#include "gsmunonieoperations.h"

#include "smsprot.h"

#include "smspfacadestor.h"

#include "smspmodm.h"

#include "smspenum.h"

#include "smspread.h"

#include "smspdel.h"

#include "smspproc.h"

#include "smspmondsk.h"

#include "smspmain.h"

#include "smspver.h"

#include "smsppara.h"

#include "SmsuBackup.h"

#include <es_prot_internal.h>

using namespace CommsDat;

//

// Class implementations

//

// application port range according to 3GPP TS 23.040 v4.4.0

// chapters 9.2.3.24.3 and 9.2.3.24.4

const TInt KMin8BitPortNumber = 240;

const TInt KMax8BitPortNumber = 255;

const TInt KMin16BitPortNumber = 16000;

const TInt KMax16BitPortNumber = 16999;

/**

 *  2 phase constructor

 *  

 */

CSmsProtocolFamily * CSmsProtocolFamily::NewL()

	{

	LOGSMSPROT4("CSmsProtocolFamily::NewL [version %d.%d.%d]",

			 KSmsPrtMajorVersionNumber,

			 KSmsPrtMinorVersionNumber,

			 KSmsPrtBuildVersionNumber

			 );

	return new (ELeave)CSmsProtocolFamily;

	} // CSmsProtocolFamily::NewL

/**

 *  Implementation of the pure virtual CProtocolFamilyBase::Install().

 *  Called by the socket server after creation of this object.

 *  Does nothing.

 *  

 */

TInt CSmsProtocolFamily::Install()

	{

	LOGSMSPROT1("CSmsProtocolFamily::Install");

	return KErrNone;

	} // CProtocolFamilyBase::Install

/**

 *  Implementation of the pure virtual CProtocolFamilyBase::Remove().

 *  Called by the socket server before unloading the library for the SMS

 *  protocol family.

 *  Does nothing.

 *  

 */

TInt CSmsProtocolFamily::Remove()

	{

	LOGSMSPROT1("CSmsProtocolFamily::Remove");

	return KErrNone;

	} // CProtocolFamilyBase::Remove

/**

 *  Implementation of the pure virtual CProtocolFamilyBase::NewProtocolL().

 *  Called by the socket server to create the CSmsProtocol object.

 *  

 *  @param aSockType not used, assumes datagram.

 *  @param aProtocol not used, assumes KSmsDatagram, the only protocol provided.

 *  @return a new instance of the CSmsProtocol class.

 *  

 */

CProtocolBase * CSmsProtocolFamily::NewProtocolL(TUint /*aSockType*/,TUint /*aProtocol*/)

	{

	LOGSMSPROT1("CSmsProtocolFamily::NewProtocolL");

	return CSmsProtocol::NewL();

	} // CProtocolFamilyBase::NewProtocolL

/**

 *  Implementation of the pure virtual CProtocolFamilyBase::ProtocolList().

 *  Called by the socket server during initialisation to retrieve a list

 *  of the protocols we support.

 *  Only KSmsDatagram is supported.

 *  

 *  @return aProtocolList a pointer to an array of protocol description objects

 *  that this function creates and fills in.

 *  @return the number of protocols supported (1).

 *  

 */

TUint CSmsProtocolFamily::ProtocolList(TServerProtocolDesc *& aProtocolList)

	{

	LOGSMSPROT1("CSmsProtocolFamily::ProtocolList");

	TRAPD(ret, (aProtocolList=new(ELeave) TServerProtocolDesc[1]));

	if(ret!=KErrNone)

		{

		LOGSMSPROT2("WARNING! new TServerProtocolDesc left with %d", ret);

		return 0;

		}

	// Datagram protocol

	aProtocolList[0].iName=KSmsDatagram;

	aProtocolList[0].iAddrFamily=KSMSAddrFamily;

	aProtocolList[0].iSockType=KSockDatagram;

	aProtocolList[0].iProtocol=KSMSDatagramProtocol;

	aProtocolList[0].iVersion=TVersion(KSmsPrtMajorVersionNumber,KSmsPrtMinorVersionNumber,KSmsPrtBuildVersionNumber);

	aProtocolList[0].iByteOrder=ELittleEndian;

	aProtocolList[0].iServiceInfo=KSMSDatagramServiceInfo;

	aProtocolList[0].iNamingServices=0;

	aProtocolList[0].iSecurity=KSocketNoSecurity;

	aProtocolList[0].iMessageSize=KSMSMaxDatagramSize;

	aProtocolList[0].iServiceTypeInfo=ESocketSupport;

	aProtocolList[0].iNumSockets=KSMSNumberSockets;

	return 1;

	} // CProtocolFamilyBase::ProtocolList

/**

 *  Constructor (empty)

 */

CSmsProtocolFamily::CSmsProtocolFamily()

	{

	} // CSmsProtocolFamily::CSmsProtocolFamily

/**

 *  The single exported function, called by the socket server to create

 *  an instance of our CProtocolFamilyBase derived class.

 *  

 */

EXPORT_C CProtocolFamilyBase* InstallSMS()

	{

	LOGSMSPROT1("CSmsProtocolFamily::CSmsProtocolFamily()");

	CSmsProtocolFamily*  smsProtocolFamily(NULL);

	TRAP_IGNORE(smsProtocolFamily = CSmsProtocolFamily::NewL());

	return smsProtocolFamily;

	} // CSmsProtocolFamily::CSmsProtocolFamily

//

// implementation of CSmsProtocol

//

/**

 *  2 phase constructor.

 *  

 */

CSmsProtocol* CSmsProtocol::NewL()

	{

	LOGSMSPROT1("CSmsProtocol::NewL()");

	return new (ELeave) CSmsProtocol();

	} // CSmsProtocol::NewL

/**

 *  Destructor, ensures all outstanding queues are empty,

 *  all resource handles are closed, and all allocated memory freed.

 *  

 */

CSmsProtocol::~CSmsProtocol()

    {

    delete iSmsPhoneInitialization;

    delete iSmsModemNotification;

    delete iSendQueue;

	delete iSetBearer;	// referenced by iSendQueue

    delete iSmsPDURead;

	delete iReceiveMode;	// referenced by iSmsPDURead

    delete iSmsPhoneEnumeration;

    delete iWriteQueue;

    delete iDeleteQueue;

    delete iSmsReadParams;

    delete iSmsWriteParams;

    delete iSmsMonitorDiskSpace;

    delete iReassemblyStore;

    if(iSegmentationStore)

        {

        iSegmentationStore->Close();

        delete iSegmentationStore;

        }

    iFs.Close();

    iSmsMessaging.Close();

    iGsmPhone.Close();

    iEnumerationPhone.Close();

    iWritePhone.Close();

    iTelServer.Close();

	delete iBackupRestoreSession;

	delete iBootTimer;

    } // CSmsProtocol::~CSmsProtocol

/**

 *  Override of CProtocolBase::NewSAPL().

 *  Called by the server to create a new SMS service access point object.

 *  

 *  @param aSocketType the socket type

 *  @leave Leaves if aSocketType is not KSockDatagram.

 *  @leave Leaves if not enough memory is available.

 *  @return a new CSmsProvider object.

 *  

 */

CServProviderBase *CSmsProtocol::NewSAPL(TUint aSocketType)

	{

	LOGSMSPROT2("*CSmsProtocol::NewSAPL [sockettype=%d]", aSocketType);

	if (aSocketType!=KSockDatagram)

		User::Leave(KErrNotSupported);

	return CSmsProvider::NewL(*this);

	} // CProtocolBase::NewSAPL

/**

 *  Override of CProtocolBase::InitL().

 *  Called by the socket server to allow any resource initialisation

 *  by the protocol.

 *  

 *  The following tasks are performed:

 *  - All member objects constructed (deferred from ConstructL() for efficiency reasons; see comment there)

 *  - TSY Name read from Comms Database

 *  - Event notification state machines started

 *  - Modem checked to see if it is already connected, and if so, a number of

 *  state machines started (otherwise wait until we receive notification of connection).

 *  

 */

void CSmsProtocol::InitL(TDesC& /*aTag*/)

	{

	LOGSMSPROT1("CSmsProtocol::InitL");

	User::LeaveIfError(iFs.Connect());

	iReassemblyStore=CFacadeSmsReassemblyStore::NewL(iFs, *this);

	iReassemblyStore->InitL();

	LOGSMSPROT1("CSmsProtocol::InitL Constructing members");

	ReadConfigurableSettingsL();

	iBootTimer = CSmsProtocolBootTimer::NewL(*this);

	iBootTimer->Start(iSmsSettings.BootTimerTimeout().Int());

	iSegmentationStore=CSmsSegmentationStore::NewL(iFs);

	iSetBearer=CSmspSetBearer::NewL(iSmsSettings, iSmsMessaging, KSmsSessionPriority);

	iReceiveMode = CSmspReceiveMode::NewL(iSmsSettings, iSmsMessaging, iMobileSmsCaps, KSmsSessionPriority);

	iSmsModemNotification=CSmsModemNotification::NewL(*this);

	iSendQueue = CSmspSendQueue::NewL(*this, *iSegmentationStore, iSmsSettings, iMobileSmsCaps, iSmsMessaging, KSmsSessionPriority, *iSetBearer);

	iSmsMonitorDiskSpace=CSmsMonitorDiskSpace::NewL(*this, iSmsMessaging,iFs);

	iSmsPDURead=CSmsPDURead::NewL(*this, iSmsSettings, iSmsMessaging,*iReassemblyStore,*iSegmentationStore, iMobileSmsCaps, KSmsSessionPriority, *iReceiveMode, *iSmsMonitorDiskSpace);

	iSmsPhoneInitialization = new (ELeave) CSmsPhoneInitialization(iSmsMessaging, iGsmPhone, *iSmsPDURead, iMobileSmsCaps, KSmsSessionPriority, iSetBearer);

	iBackupRestoreSession = CBackupAndRestore::NewL(*this);

/* THIS CODE SHOULD NEVER BE NECESSARY - who could have called CProtocolBase::InitL() if not ESOCK, which means

 * a running C32 already. However, if this is a wrong analysis then reinstate the code but with an explanatory comment

#if defined (__WINS__)

	// Make sure C32 is started under WINS

	TInt ret=StartC32();

	if (ret!=KErrAlreadyExists)

		User::LeaveIfError(ret);

#endif

*/

	LOGSMSPROT1("CSmsProtocol::InitL Querying CommDb");

	// Read the global modem ID setting from  Cooms Database

	TUint32 modemId = 0;

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* sess = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* sess = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(sess);

	CMDBField<TUint32>* globalSettingField = new(ELeave) CMDBField<TUint32>(KCDTIdModemPhoneServicesSMS);

	CleanupStack::PushL(globalSettingField);

	globalSettingField->SetRecordId(1);

	globalSettingField->LoadL(*sess);

	modemId = *globalSettingField;

	CleanupStack::PopAndDestroy(globalSettingField);

	CMDBField<TDesC>* tsyField = new(ELeave) CMDBField<TDesC>(KCDTIdTsyName);

	CleanupStack::PushL(tsyField);

	tsyField->SetRecordId(modemId);

	tsyField->LoadL(*sess);

	iGsmTsyName = *tsyField;

	CleanupStack::PopAndDestroy(tsyField);

	CleanupStack::PopAndDestroy(sess);

#ifdef _SMS_LOGGING_ENABLED

	TBuf8<KCommsDbSvrMaxFieldLength> buf8;

	buf8.Copy(iGsmTsyName);

	LOGSMSPROT3("CSmsProtocol::InitL [modemId=%d tsy=%S]",

				modemId, &buf8);

#endif

	// Start event notification state machines

	iSmsModemNotification->Start();

	// Intialise the SmsStack to the state that the phone has been found in

	iModemDetection=iSmsModemNotification->ModemState();

	if (iModemDetection == RPhone::EDetectedPresent && !iBackupRestoreSession->IsBackupOrRestoreInProgress())

		{

		DoPowerUpL(); //Call the leaving version because powering up must work here

		}

	else

		{

		PowerDown();

		}

	//

	// Define the Disk Space Monitor P&S variable...

	//

	TInt  ret;

	TSecurityPolicy  readPolicy(ECapabilityReadDeviceData);

	TSecurityPolicy  writePolicy(ECapabilityWriteDeviceData);

	ret = RProperty::Define(KUidPSSMSStackCategory, KUidPSSMSStackDiskSpaceMonitorKey,

							KUidPSSMSStackDiskSpaceMonitorKeyType, readPolicy, writePolicy);

	if (ret != KErrNone  &&  ret != KErrAlreadyExists)

		{

		User::Leave(ret);

		}

	User::LeaveIfError(RProperty::Set(KUidPSSMSStackCategory,

									  KUidPSSMSStackDiskSpaceMonitorKey, ESmsDiskSpaceAvailable));

	} // CProtocolBase::InitL

/**

 *  Override of CProtocolBase::StartL().

 *  Called by the socket server to indicate all bindings are complete

 *  and that datagram processing can begin.

 *  

 *  Binding is not supported so this indication is not important to us.

 *  

 */

void CSmsProtocol::StartL(void)

	{

	LOGSMSPROT1("CSmsProtocol::StartL");

	} // CSmsProtocol::StartL

/**

 *  Override of CProtocolBase::Identify().

 *  Called by the socket server to obtain a description of the SMS protocol.

 *  

 */

void CSmsProtocol::Identify(TServerProtocolDesc *aDesc)const

	{

	LOGSMSPROT1("CSmsProtocol::Identify");

	aDesc->iName=KSmsDatagram;

	aDesc->iAddrFamily=KSMSAddrFamily;

	aDesc->iSockType=KSockDatagram;

	aDesc->iProtocol=KSMSDatagramProtocol;

	aDesc->iVersion=TVersion(KSmsPrtMajorVersionNumber,KSmsPrtMinorVersionNumber,KSmsPrtBuildVersionNumber);

	aDesc->iByteOrder=ELittleEndian;

	aDesc->iServiceInfo=KSMSDatagramServiceInfo;

	aDesc->iNamingServices=0;

	aDesc->iSecurity=KSocketNoSecurity;

	aDesc->iMessageSize=KSMSMaxDatagramSize;

	aDesc->iServiceTypeInfo=0;

	aDesc->iNumSockets=KSMSNumberSockets;

	} // CProtocolBase::Identify

/**

 *  Override of CProtocolBase::NewHostResolverL().

 *  Called by socket server to create a host resolver.

 *  No host resolver service is provided by this SMS protocol.

 *  

 *  @leave Panics if called.

 *  

 */

CHostResolvProvdBase *CSmsProtocol::NewHostResolverL()

    {

    // Ignore in code coverage - not intended to be used

    BULLSEYE_OFF    

    LOGSMSPROT1("CSmsProtocol::NewHostResolverL");

    SmspPanic(ESmspCantCreateHostResolver);

    return NULL;

    BULLSEYE_RESTORE

    }

/**

 *  Override of CProtocolBase::NewServiceResolverL().

 *  Called by socket server to create a new service resolver.

 *  Not supported by this protocol.

 *  

 *  @leave Panics if called.

 *  

 */

CServiceResolvProvdBase *CSmsProtocol::NewServiceResolverL()

    {

    // Ignore in code coverage - not intended to be used

    BULLSEYE_OFF    

    LOGSMSPROT1("*CSmsProtocol::NewServiceResolverL");

    SmspPanic(ESmspCantCreateServiceResolver);

    return NULL;

    BULLSEYE_RESTORE

    }

/**

 *  Override of CProtocolBase::NewNetDatabaseL().

 *  Called by socket server to create a new network database.

 *  Not supported by this protocol.

 *  

 *  @leave Panics if called.

 *  

 */

CNetDBProvdBase* CSmsProtocol::NewNetDatabaseL()

    {

    // Ignore in code coverage - not intended to be used

    BULLSEYE_OFF    

    LOGSMSPROT1("CSmsProtocol::NewNetDatabaseL");

    SmspPanic(ESmspCantCreateNetDatabase);

    return NULL;

    BULLSEYE_RESTORE

    }

/**

 *  Override of CProtocolBase::BindL().

 *  Called by next protocol above wishing to bind to the SMS protocol.

 *  Not supported by this protocol.

 *  

 *  @leave Panics if called.

 *  

 */

void CSmsProtocol::BindL(CProtocolBase* /*aProtocol*/,TUint /*aId*/)

    {

    // Ignore in code coverage - not intended to be used

    BULLSEYE_OFF    

    LOGSMSPROT1("CSmsProtocol::BindL");

    SmspPanic(ESmspCantBind);

    BULLSEYE_RESTORE