// Copyright (c) 2001-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 CSmsProvider service access point (SAP) class.

// Includes

// 

//

/**

 @file

*/

#include "smsprot.h"

#include <es_ver.h>

#include <es_mbuf.h>

#include "Gsmuelem.h"

#include "gsmubuf.h"

#include "Gsmumsg.h"

#include "smsustrm.h"

#include "smspmain.h"

#include "smspfacadestor.h"

// CSmsProvider policies

//

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlDeleteSmsMessagePolicy,ECapabilityWriteUserData);

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlEnumerateSmsMessagesPolicy,ECapabilityReadUserData );

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlReadMessageSucceededPolicy,ECapabilityReadUserData );

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlReadMessageFailedPolicy,ECapabilityReadUserData );

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlSendSmsMessagePolicy,ECapabilityNetworkServices );

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlWriteSmsMessagePolicy,ECapabilityWriteUserData );

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlReadSmsParamsPolicy,ECapability_None );

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlCompleteReadSmsParamsPolicy,ECapability_None );

static _LIT_SECURITY_POLICY_C1(smsProviderIoctlWriteSmsParamsPolicy,ECapabilityWriteDeviceData );

// following not implemented as too paranoid

//static _LIT_SECURITY_POLICY_C1(smsProviderIoctlSelectModemPresentPolicy,ECapabilityWriteDeviceData );

//static _LIT_SECURITY_POLICY_C1(smsProviderIoctlSelectModemNotPresentPolicy,ECapabilityWriteDeviceData );

static _LIT_SECURITY_POLICY_C1(smsProviderSetLocalNamePolicy,ECapabilityNetworkServices);

static _LIT_SECURITY_POLICY_C1(smsProviderWritePolicy,ECapability_None);

/**

 *  2 Phase constructor.

 *  

 *  @param aProtocol a reference to the SMS protocol object.

 *  @leave Leaves if ContructL() leaves, or not enough memory is available.

 *  @return a new CSmsProvider object.

 *  

 */

CSmsProvider* CSmsProvider::NewL(CSmsProtocol& aProtocol)

    {

    LOGSMSPROT1("CSmsProvider::NewL");

    CSmsProvider* self =new(ELeave) CSmsProvider(aProtocol);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    LOGSMSPROT1("-> CSmsProvider::NewL - done");

    return self;

    }

/**

 *  C'tor

 *  

 *  @param aProtocol a reference to the SMS protocol object.

 */

CSmsProvider::CSmsProvider(CSmsProtocol& aProtocol)

: iProtocol(aProtocol),iEnumSocket(EFalse),iNumOfEnumeratedMessages(0)

    {

    }

/**

 *  2nd Phase of construction.

 *  Subscribes to the protocol as an observer, and creates our send and

 *  receive buffers.

 *  

 */

void CSmsProvider::ConstructL()

    {

    LOGSMSPROT1("CSmsProvider::ConstructL");

    iProtocol.AddSmsMessageObserverL(*this);

    SetObserverAddedToProtocol(ETrue);

    iRecvBufSegArray=new(ELeave) CArrayPtrFlat<CBufSeg>(8);

    iSendBufSeg = CBufSeg::NewL(KSmsMaxSegmentLength);

    LOGSMSPROT1("-> CSmsProvider::ConstructL - done");

    }

/**

 *  D'tor

 *  

 *  Removes this SAP as an observer of the SMS protocol, and

 *  frees the send and receive buffers.

 *  

 */

CSmsProvider::~CSmsProvider()

    {

    if( ObserverAddedToProtocol() )

        {

        iProtocol.RemoveSmsMessageObserver(*this);

        }

    if( iRecvBufSegArray )

        {

        iRecvBufSegArray->ResetAndDestroy();

        delete iRecvBufSegArray;

        }

    delete iSendBufSeg;

    }

/**

 *  Does nothing.  Implementation of pure virtual CServProviderBase::Start().

 *  

 */

void CSmsProvider::Start()

    {

    LOGSMSPROT1("CSmsProvider::Start");

    }

/**

 *  Returns the local address of this SAP.  Implementation of

 *  pure virtual CServProviderBase::LocalName().

 *  

 */

void CSmsProvider::LocalName(TSockAddr& aAddr) const

    {

    LOGSMSPROT1("CSmsProvider::LocalName");

    aAddr = iLocalAddress;

    }

/**

 *  Sets the local address of this SAP by binding it to the protocol.

 *  The protocol ensures that there are no duplicate observers, and

 *  then calls back on the CSmsProvider::SetLocalAddress() method

 *  to set the address.

 *  

 *  Implementation of the pure virtual CServProviderBase::SetLocalName().

 *  

 *  @capability NetworkServices

 */

TInt CSmsProvider::SetLocalName(TSockAddr& aAddr)

    {

    LOGSMSPROT1("CSmsProvider::SetLocalName");

    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderSetLocalNamePolicy,"CSmsProvider SetLocal Name policy check") != KErrNone) )

        {

        return KErrPermissionDenied;

        }

    TSmsAddr& smsAddr=static_cast<TSmsAddr&>(aAddr);

    if( ( smsAddr.SmsAddrFamily() == ESmsAddrApplication8BitPort  || smsAddr.SmsAddrFamily() == ESmsAddrApplication16BitPort ) && smsAddr.Port() == 0 )

        {

        if( !iProtocol.AllocateLocalAddress(smsAddr) )

            {

            return KErrInUse;

            }

        }

    return iProtocol.BindSmsMessageObserver(*this,smsAddr);

    }

/**

 *  Called by the protocol to retrieve the remote name of the connection.

 *  This protocol is not connection oriented so this is not supported.

 *  

 *  Implementation of the pure virtual CServProviderBase::RemName().

 *  

 */

void CSmsProvider::RemName(TSockAddr& /*aAddr*/) const

    {

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

    BULLSEYE_OFF    

    LOGSMSPROT1("CSmsProvider::RemName");

    BULLSEYE_RESTORE

    }

/**

 *  Called by the protocol to set the remote name of the connection.

 *  This protocol is not connection oriented so this is not supported.

 *  

 *  Implementation of the pure virtual CServProviderBase::SetRemName().

 *  

 */

TInt CSmsProvider::SetRemName(TSockAddr& /*aAddr*/)

    {

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

    BULLSEYE_OFF    

    LOGSMSPROT1("CSmsProvider::SetRemName");

    return KErrNotSupported;

    BULLSEYE_RESTORE

    }

/**

 *  Returns the current value of an option setting for this SAP.

 *  No settings are currently defined.

 *  Implementation of pure virtual CServProviderBase::GetOption().

 *  

 */

TInt CSmsProvider::GetOption(TUint /*aLevel*/,TUint /*aName*/,TDes8& /*aOption*/) const

    {

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

    BULLSEYE_OFF    

    LOGSMSPROT1("CSmsProvider::GetOption");

    return 0;

    BULLSEYE_RESTORE

    }

/**

 *  Called to perform specific IO control by the client.  All of the SMS protocol

 *  services are provided through this interface.

 *  

 *  The local address of this SAP must already be bound, and only one ioctl request

 *  may be outstanding at any one time.

 *  

 *  A resulting socket error of KErrEof can result from a KErrNoMemory during a

 *  preceding write to the socket.

 *  

 *  Implementation of pure virtual CServProviderBase::Ioctl().

 *  

 *  @param aLevel the IOCTL level.  Only KSolSmsProv is supported.

 *  @param aName the IOCTL name.

 *  @param aOption the IOCTL option.

 *  

 */

void CSmsProvider::Ioctl(TUint aLevel,TUint aName,TDes8* aOption)

    {

    LOGSMSPROT3("CSmsProvider::Ioctl [aLevel=%d, aName=%d]", aLevel, aName);

    LOGSMSPROT2("CSmsProvider::Ioctl [provider=0x%08x]",this);

    // Panic in debug mode if this call is invalid in this SAPs current state

    __ASSERT_DEBUG(iLocalAddress.SmsAddrFamily()!=ESmsAddrUnbound,SmspPanic(KSmspPanicWrongSmsAddressFamily));

    __ASSERT_DEBUG(!IoctlOutstanding(),SmspPanic(KSmspPanicIoctlAlreadyOutstanding));

    // Gracefully handle invalid calls in release build

    if( iLocalAddress.SmsAddrFamily()==ESmsAddrUnbound )

        {

        iSocket->Error(KErrNotReady,MSocketNotify::EErrorIoctl);

        return;

        }

    if( IoctlOutstanding() )

        {

        iSocket->Error(KErrInUse,MSocketNotify::EErrorIoctl);

        return;

        }

    // General state is OK, now try to service the request

    iName=aName;

    switch( aLevel )

        {

        case KSolSmsProv:

            {

            switch( iName )

                {

                case KIoctlSupportOODClass0SmsMessages:

                    {

                    if( iProtocol.iReassemblyStore )

                        {

                        if( iProtocol.iReassemblyStore->IsSeparateClass0StoreSupported() )

                            {

                            iSocket->IoctlComplete(NULL);

                            }

                        else

                            {

                            iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);

                            }

                        }

                    else

                        {

                        iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);

                        }

                    } break;

                case KIoctlSendSmsMessage:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlSendSmsMessagePolicy,"CSmsProvider Ioctl SendSmsMessage policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    __ASSERT_DEBUG(iLocalAddress.SmsAddrFamily()!=ESmsAddrLocalOperation,SmspPanic(KSmspPanicWrongSmsAddressFamily));

                    __ASSERT_DEBUG(aOption!=NULL,SmspPanic(KSmspPanicOptionBufferNull));

                    // Handle bad requests gracefully

                    if( iLocalAddress.SmsAddrFamily()==ESmsAddrLocalOperation )

                        {

                        iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    if( aOption == NULL )

                        {

                        iSocket->Error(KErrArgument,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    // Read message from socket

                    CSmsMessage* smsmessage=NULL;

                    TRAPD(ret,(smsmessage=InternalizeMessageL()));

                    if( ret!=KErrNone )

                        {

                        iSendBufSeg->Reset();

                        iSocket->Error(ret,MSocketNotify::EErrorIoctl);

                        }

                    else

                        {

                            // Pass the message to the protocol for sending

                        TPckgBuf<TUint> buf;

                        buf.Copy(*aOption);

                        SetIoctlOutstanding(ETrue);

                        iProtocol.SendSmsMessage(smsmessage,*this, buf());

						}

                    } break;

                case KIoctlEnumerateSmsMessages:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlEnumerateSmsMessagesPolicy, "CSmsProvider Ioctl EnumerateSmsMessages policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    __ASSERT_DEBUG(iLocalAddress.SmsAddrFamily()!=ESmsAddrSendOnly,SmspPanic(KSmspPanicWrongSmsAddressFamily));

                    // Handle bad requests gracefully

                    if( iLocalAddress.SmsAddrFamily()==ESmsAddrSendOnly )

                        {

                        iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    SetIoctlOutstanding(ETrue);

                    iProtocol.EnumeratePhone(*this);

                    } break;

                case KIoctlWriteSmsMessage:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlWriteSmsMessagePolicy,"CSmsProvider IoctlWriteSmsMessage policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    // Read message from the socket

                    CSmsMessage*smsmessage=NULL;

                    TRAPD(ret,(smsmessage=InternalizeMessageL()));

                    if( ret!=KErrNone )

                        {

                        iSendBufSeg->Reset();

                        iSocket->Error(ret,MSocketNotify::EErrorIoctl);

                        }

                    else

                        {

                        // Pass message to the protocol for writing

                        SetIoctlOutstanding(ETrue);

                        iProtocol.WriteSmsMessage(smsmessage,*this);

                        }

                    } break;

                case KIoctlDeleteSmsMessage:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlDeleteSmsMessagePolicy,"CSmsProvider Ioctl DeleteSmsMessage policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    __ASSERT_DEBUG(iLocalAddress.SmsAddrFamily()!=ESmsAddrSendOnly,SmspPanic(KSmspPanicWrongSmsAddressFamily));

                    // Handle bad requests gracefully

                    if( iLocalAddress.SmsAddrFamily()==ESmsAddrSendOnly )

                        {

                        iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    // Read message from the socket

                    CSmsMessage*smsmessage=NULL;

                    TRAPD(ret,(smsmessage=InternalizeMessageL()));

                    if( ret!=KErrNone )

                        {

                        LOGSMSPROT2("-> CSmsProvider::Ioctl - CSmsProvider::InternalizeMessageL [ret=%d]", ret);

                        iSendBufSeg->Reset();

                        iSocket->Error(ret, MSocketNotify::EErrorIoctl);

                        }

                    else

                        {

                        // Pass request to protocol

                        SetIoctlOutstanding(ETrue);

                        iProtocol.DeleteSmsMessage(smsmessage,*this);

                        }

                    } break;

                case KIoctlReadMessageSucceeded:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlReadMessageSucceededPolicy,"CSmsProvider Ioctl ReadMessageSucceeded policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    __ASSERT_DEBUG(iLocalAddress.SmsAddrFamily()!=ESmsAddrSendOnly,SmspPanic(KSmspPanicWrongSmsAddressFamily));

                    __ASSERT_DEBUG(NumSegments(iSegmentIndex==NumSegments(iRecvBufSegArray->At(0)->Size())),SmspPanic(KSmspPanicBadClientIoctlCall));

                    CSmsMessage*smsmessage=NULL;

                    TRAPD(ret,(smsmessage=InternalizeMessageL(iRecvBufSegArray->At(0))));

                    if( ret==KErrNone )

                        {

                        TRAP(ret,(iProtocol.DeleteSMSFromReaStoreL( *smsmessage )));

                        LOGSMSPROT2("-> CSmsProvider::Ioctl - CSmsProvider::DeleteSMSFromReaStoreL [ret=%d]", ret);

                        }

                    else

                        {

                        LOGSMSPROT2("-> CSmsProvider::Ioctl - CSmsProvider::InternalizeMessageL [ret=%d]", ret);

                        }

                    delete smsmessage;

                    iProtocol.MessageReadedSuccessfully();

                    if( iEnumSocket )

                        {

                        --iNumOfEnumeratedMessages;

                        LOGSMSPROT2("-> CSmsProvider::Ioctl - [iNumOfEnumeratedMessages=%d]", iNumOfEnumeratedMessages);

                        if( iNumOfEnumeratedMessages <= 0 )

                            {

                            iProtocol.iPhoneEnumerationObserver=NULL;

                            iEnumSocket=EFalse;

                            iProtocol.MessageReadedSuccessfully();

                            LOGSMSPROT1("-> CSmsProvider::Ioctl - [iNumOfEnumeratedMessages=NULL]");

                            }

                        }

                    // Remove the message from the receive buffer & complete

                    delete iRecvBufSegArray->At(0);

                    iRecvBufSegArray->At(0) = NULL;

                    iRecvBufSegArray->Delete(0);

                    iSegmentIndex=0;

                    iSocket->IoctlComplete(NULL);

                    } break;

                case KIoctlReadMessageFailed:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlReadMessageFailedPolicy,"CSmsProvider Ioctl ReadMessageFailed policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    __ASSERT_DEBUG(iLocalAddress.SmsAddrFamily()!=ESmsAddrSendOnly,SmspPanic(KSmspPanicWrongSmsAddressFamily));

                    __ASSERT_DEBUG(NumSegments(iSegmentIndex<=NumSegments(iRecvBufSegArray->At(0)->Size())),SmspPanic(KSmspPanicBadClientIoctlCall));

                    // Handle bad requests gracefully

                    if( iLocalAddress.SmsAddrFamily()==ESmsAddrSendOnly )

                        {

                        if( iEnumSocket )

                            {

                            --iNumOfEnumeratedMessages;

                            if( iNumOfEnumeratedMessages <= 0 )

                                {

                                iProtocol.iPhoneEnumerationObserver=NULL;

                                LOGSMSPROT1("-> CSmsProvider::Ioctl - fail [iNumOfEnumeratedMessages=NULL]");

                                iEnumSocket=EFalse;

                                iProtocol.MessageReadedSuccessfully();

                                }

                            }

                        iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    // Re-notify the socket that data is available, reset the segment

                    // index of the current message back to the start & complete

                    iSocket->NewData(iSegmentIndex);

                    iSegmentIndex=0;

                    iSocket->IoctlComplete(NULL);

                    } break;

                case KIoctlReadSmsParams:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlReadSmsParamsPolicy,"CSmsProvider Ioctl ReadSmsParams policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    // Handle bad requests gracefully

                    if( iLocalAddress.SmsAddrFamily()!=ESmsAddrLocalOperation )

                        {

                        iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);

                        return;

                        }

                   // Pass request on to the protocol

                   SetIoctlOutstanding(ETrue);

                   iProtocol.ReadSmsParameters(*this);

                    } break;

                case KIoctlCompleteReadSmsParams:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlCompleteReadSmsParamsPolicy,"CSmsProvider Ioctl CompleteReadSmsParams policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    __ASSERT_DEBUG(iLocalAddress.SmsAddrFamily()!=ESmsAddrSendOnly,SmspPanic(KSmspPanicWrongSmsAddressFamily));

                    __ASSERT_DEBUG(NumSegments(iSegmentIndex==NumSegments(iRecvBufSegArray->At(0)->Size())),SmspPanic(KSmspPanicBadClientIoctlCall));

                    // Handle bad requests gracefully

                    if ( iLocalAddress.SmsAddrFamily()==ESmsAddrSendOnly )

                        {

                        iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    // Remove the parameter list from the receive buffer & complete

                    delete iRecvBufSegArray->At(0);

                    iRecvBufSegArray->At(0) = NULL;

                    iRecvBufSegArray->Delete(0);

                    iSegmentIndex=0;

                    iSocket->IoctlComplete(NULL);

                    } break; 

                case KIoctlWriteSmsParams:

                    {

                    if( !iSecurityChecker || (iSecurityChecker->CheckPolicy(smsProviderIoctlWriteSmsParamsPolicy,"CSmsProvider Ioctl WriteSmsParams policy check") != KErrNone) )

                        {

                        iSocket->Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

                        return;

                        }

                    // Read parameters from the socket

                    CMobilePhoneSmspList*mobilePhoneSmspList=NULL;

                    TRAPD(ret,(mobilePhoneSmspList=InternalizeParametersL()));

                    if( ret!=KErrNone )

                        {

                        iSendBufSeg->Reset();

                        iSocket->Error(ret,MSocketNotify::EErrorIoctl);

                        }

                    else

                        {

                        // Pass parameters to the protocol for writing.

                        // CSmsWriteParams takes ownership of mobilePhoneSmspList.

                        SetIoctlOutstanding(ETrue);

                        iProtocol.WriteSmsParameters(mobilePhoneSmspList, *this);

                        }