/*

* Copyright (c) 2008 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:

*

*/

#include "logger.h"

#include "functionserver.h"

#include "bluetoothfunctionserver.h"

#include "bluetoothremotedevice.h"

#include "fs_methodcall.h"

#include "bluetoothclientconnection.h"

#include "btrfcommserverconnection.h"

#include "bluetoothpusheventlistener.h"

#include "javasymbianoslayer.h"

using namespace std;

using namespace java::util;

namespace java

{

namespace bluetooth

{

const TInt KSizeOfListenQueue = 7;

#define SERVICE_AVAILABLE 0xFF

#define SERVICE_NOTAVAILABLE 0x00

_LIT(KRfComm, "RFCOMM");

OS_EXPORT RFCOMMServerConnection::RFCOMMServerConnection(

    java::bluetooth::BluetoothFunctionServer* server):

        mAcceptMonitor(NULL),

        mAsyncAccept(false),

        mBtUrlParams(NULL),

        mBtClientConn(NULL),

        mServer(server),

        mIsConnected(EFalse),

        mServRec(NULL),

        mState(ENone)

{

    JELOG2(EJavaBluetooth);

}

OS_EXPORT RFCOMMServerConnection::~RFCOMMServerConnection()

{

    JELOG2(EJavaBluetooth);

    CloseServer();

    delete mAcceptMonitor;

}

OS_EXPORT int RFCOMMServerConnection::openServer(bool authorize,

        bool authenticate, bool encrypt)

{

    JELOG2(EJavaBluetooth);

    return ServerOpen(authorize, authenticate, encrypt);

}

OS_EXPORT int RFCOMMServerConnection::ServerOpen(TBool authorize,

        TBool authenticate, TBool encrypt)

{

    JELOG2(EJavaBluetooth);

    int result = 0;

    TRAP(result, CallMethodL(this, &RFCOMMServerConnection::ServerOpenL,

                             authorize, authenticate, encrypt, mServer));

    return result;

}

OS_EXPORT ServiceRecord *RFCOMMServerConnection::getServiceRecordHandle()

{

    return mServRec;

}

void RFCOMMServerConnection::ServerOpenL(TBool authorize, TBool authenticate,

        TBool encrypt)

{

    JELOG2(EJavaBluetooth);

    if (mState != ENone)

    {

        User::Leave(KErrInUse);

    }

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

    User::LeaveIfError(mSocketServ.ShareAuto());

    TRAPD(err,

    {

        // Set this active object to connecting state

        mState = EConnecting;

        // Set a Bluetooth socket address

        BindL(authorize, authenticate, encrypt);

        // Set a socket to listen for incoming connections

        ListenL();

    }

         );

    if (KErrNone != err)

    {

        ELOG(EJavaBluetooth,

             "- RFCOMMServerConnection::ServerOpenL: Exception caught ");

        mState = ENone;

        mSocketServ.Close();

        User::LeaveIfError(err);

    }

}

void RFCOMMServerConnection::BindL(TBool authorize, TBool authenticate,

                                   TBool encrypt)

{

    JELOG2(EJavaBluetooth);

    // Load protocol, RFCOMM

    TProtocolDesc protocolDesc;

    User::LeaveIfError(mSocketServ.FindProtocol(KRfComm(), protocolDesc));

    LOG(EJavaBluetooth, EInfo,

        "  RFCOMMServerConnection::Bind: Opening A Listener Socket ");

    // Open a socket

    mListenSock = CBluetoothSocket::NewL(*this, mSocketServ,

                                         protocolDesc.iSockType, KRFCOMM);

    mListenSock->SetNotifier(*this);

    TInt Channel = 0;

    // Get listening channel

    User::LeaveIfError(mListenSock->GetOpt(KRFCOMMGetAvailableServerChannel,

                                           KSolBtRFCOMM, Channel));

    // Set security

    TBTServiceSecurity secSettings;

    secSettings.SetAuthentication(authenticate);

    secSettings.SetAuthorisation(authorize);

    secSettings.SetEncryption(encrypt);

    LOG(EJavaBluetooth, EInfo,

        "  RFCOMMServerConnection::Accept: setting The Security Settings ");

    // Attach the security settings.

    mBtSockAddr.SetSecurity(secSettings);

    LOG1(EJavaBluetooth, EInfo,

         "  RFCOMMServerConnection::Bind: setting port to: %d", Channel);

    // Setting Rfcom Port

    mBtSockAddr.SetPort(Channel);

    LOG(EJavaBluetooth, EInfo,

        "  RFCOMMServerConnection::Bind: Binding Bluetooth Socket ");

    // Bind bluetooth socket

    User::LeaveIfError(mListenSock->Bind(mBtSockAddr));

}

OS_EXPORT int RFCOMMServerConnection::GetRfListeningChannel()

{

    JELOG2(EJavaBluetooth);

    int result = 0;

    TRAPD(err, CallMethodL(result, this,

                           &RFCOMMServerConnection::GetRfListeningChannelFs, mServer));

    if (err != KErrNone)

    {

        return err;

    }

    return result;

}

int RFCOMMServerConnection::GetRfListeningChannelFs()

{

    JELOG2(EJavaBluetooth);

    TInt channel = 0;

    if (mState != EConnecting)

    {

        return -1;

    }

    channel = mListenSock->LocalPort();

    LOG1(EJavaBluetooth, EInfo,

         "  RFCOMMServerConnection::GetRfListeningChannelFs: %d", channel);

    return channel;

}

void RFCOMMServerConnection::ListenL()

{

    JELOG2(EJavaBluetooth);

    // Listen on port

    User::LeaveIfError(mListenSock->Listen(KSizeOfListenQueue));

}

OS_EXPORT int RFCOMMServerConnection::asyncAccept(

    java::bluetooth::BluetoothPushEventListener* aEventListener,

    BtUrlParams *aBtUrlParams)

{

    JELOG2(EJavaBluetooth);

    //Store event listener and notify it when client is accepted.

    //Make a call to accept and do not wait.

    mAsyncAccept = true;

    mPushEventListener = aEventListener;

    mBtUrlParams = aBtUrlParams;

    int result = 0;

    TRAPD(err, CallMethodL(result, this, &RFCOMMServerConnection::AcceptL,

                           mServer));

    return err;

}

OS_EXPORT long RFCOMMServerConnection::Accept()

{

    JELOG2(EJavaBluetooth);

    long result = 0;

    mBtClientConn = NULL;

    TRAPD(err, CallMethodL(result, this, &RFCOMMServerConnection::AcceptL,

                           mServer));

    if (err != KErrNone)

    {

        return err;

    }

    mAcceptMonitor->wait();

    if (mAcceptStatus != KErrNone)

    {

        return mAcceptStatus;

    }

    mAcceptedSocket = NULL;

    return reinterpret_cast<long>(mBtClientConn);

}

long RFCOMMServerConnection::AcceptL()

{

    JELOG2(EJavaBluetooth);

    // Open blank socket and pass it to accept to be assigned a proper

    // socket upon completion of Accept()

    mAcceptedSocket = CBluetoothSocket::NewL(*this, mSocketServ);

    LOG(EJavaBluetooth, EInfo,

        "  RFCOMMServerConnection::Accept: Set To Accept Incoming Connections ");

    if (NULL == mAcceptMonitor)

    {

        mAcceptMonitor = java::util::Monitor::createMonitor();

    }

    mAcceptStatus = 0;

    // Enabling the advertising flag

    if (NULL != mServRec)

    {

        mServRec -> setAdvertiseFs(ETrue);

    }

    int err = mListenSock->Accept((*mAcceptedSocket));

    LOG1(EJavaBluetooth,EInfo,

         "  RFCOMMServerConnection::Accept: accept return: %d", err);

    return err;

}

OS_EXPORT int RFCOMMServerConnection::initializeServiceRecord(

    TInt aChannel, TUUID &aServiceUUID, TDesC8 &aServiceName, bool aIsGOEP)

{

    JELOG2(EJavaBluetooth);

    int result = 0;

    if (NULL == mServRec)

    {

        TRAP(result, CallMethodL(mServRec, this,

                                 &RFCOMMServerConnection::createServiceRecordL, mServer));

        if (KErrNone == result)

        {

            TInt protocol = (true == aIsGOEP)?PROTOCOL_GOEP : PROTOCOL_RFCOMM;

            TRAP(result, mServRec->initializeRecordL(protocol,

                    aChannel, aServiceUUID, aServiceName));

        }

    }

    return result;

}

OS_EXPORT int RFCOMMServerConnection::initializeServiceRecord(

    int aChannel, wstring aServiceUUID, wstring aServiceName, bool aIsGOEP)

{

    JELOG2(EJavaBluetooth);

    int result = 0;

    if (NULL == mServRec)

    {

        TRAP(result, CallMethodL(mServRec, this,

                                 &RFCOMMServerConnection::createServiceRecordL, mServer));

        if (KErrNone == result)

        {

            TInt protocol = (true == aIsGOEP)?PROTOCOL_GOEP : PROTOCOL_RFCOMM;

            result = mServRec->initializeRecord(protocol,

                                                aChannel, aServiceUUID, aServiceName);

        }

    }

    return result;

}

OS_EXPORT int RFCOMMServerConnection::restorePersistentRecord()

{

    JELOG2(EJavaBluetooth);

    int result = 0;

    if (NULL != mServRec)

    {

        result = mServRec->restorePersistentRecord();

    }

    return result;

}

ServiceRecord *RFCOMMServerConnection::createServiceRecordL()

{

    return ServiceRecord::NewL(mServer);

}

int RFCOMMServerConnection::CloseServer()

{

    JELOG2(EJavaBluetooth);

    int result = 0;

    mIsConnected = EFalse;

    mAsyncAccept = false;

    CallMethod(this, &RFCOMMServerConnection::Close, mServer);

    return result;

}

void RFCOMMServerConnection::Close()

{

    JELOG2(EJavaBluetooth);

    // Deleting service record.

    ServiceRecord::cleanup(mServRec);

    if (mState != ENone)

    {

        mListenSock->CancelAll();

        mListenSock->Shutdown(RSocket::EImmediate);

        delete mListenSock; //Destructor closes the socket

        mListenSock = NULL;

        mState = ENone;

        mAcceptStatus = KErrCancel;

        if (mAcceptMonitor)

            mAcceptMonitor->notify();

    }

}

void RFCOMMServerConnection::DoCancel()

{

    JELOG2(EJavaBluetooth);

}

bool RFCOMMServerConnection::isConnectionAllowed(TBTSockAddr aBtAddr)

{

    JELOG2(EJavaBluetooth);

    if (NULL == mBtUrlParams)

    {

        return true;

    }

    bool authorize = false;

    bool authenticate = false;

    HBufC* devAddr = HBufC::New(aBtAddr.Length());

    TPtr ptr = devAddr->Des();

    TBTDevAddr btDeviceAddress = aBtAddr.BTAddr();

    btDeviceAddress.GetReadable((TDes&)ptr);

    if (true == mBtUrlParams->isBlockedSender(*devAddr))

    {

        delete devAddr;

        return false;

    }

    if (true == mBtUrlParams->isAllowedSender(*devAddr, authorize, authenticate))

    {

        LOG(EJavaBluetooth, EInfo,

            "  RFCOMMServerConnection::isConnectionAllowed AllowedSender");

        bool flag = true;

        TInt64 longBtAddr = 0;

        TLex16 toParse(*devAddr);

        toParse.Val(longBtAddr, EHex);

        LOG1(EJavaBluetooth, EInfo,

             " RFCOMMServerConnection::isConnectionAllowed Long BTRemote address %llx",longBtAddr);

        if (true == authorize)

        {

            flag = BluetoothRemoteDevice::getSecurityProperty(

                       REMOTE_AUTHORIZED, longBtAddr);

        }

        if (true == flag && true == authenticate)

        {

            flag = BluetoothRemoteDevice::getSecurityProperty(

                       REMOTE_AUTHENTICATED, longBtAddr);

        }

        delete devAddr;

        return flag;

    }

    delete devAddr;

    LOG(EJavaBluetooth, EInfo, "- RFCOMMServerConnection::isConnectionAllowed");

    return false;

}

void RFCOMMServerConnection::avoidFilter()

{

    JELOG2(EJavaBluetooth);

    mAvoidFilter = true;

}

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

//  Methods from MBluetoothSocketNotifier to handle Bluetooth Events

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

//Notification of an accept complete event

void RFCOMMServerConnection::HandleAcceptCompleteL(TInt err)

{

    TBTSockAddr btRemoteAddr;

    mAcceptStatus = err;

    LOG1(EJavaBluetooth, EInfo, "+  RFCOMMServerConnection::HandleAcceptCompleteL Err:%d", err);

    if (KErrNone == err)

    {

        mAcceptedSocket->RemoteName(btRemoteAddr);

        {

            mAcceptedSocket->CancelAll();

            mAcceptedSocket->Shutdown(RSocket::EImmediate);

            delete mAcceptedSocket;

            mAcceptedSocket = NULL;

            ELOG(EJavaBluetooth,

                 "RFCOMMServerConnection::HandleAcceptCompleteL Connection Rejected");

            AcceptL();

            return;

        }

        mBtClientConn = new BluetoothClientConnection(mAcceptedSocket, mServer);

        mBtClientConn->initialize(PROTOCOL_RFCOMM, longBtAddr, 0, 0);

        if (mAsyncAccept)

        {

            mPushEventListener->handleConnectionRequest(mBtClientConn, err);

        }

        else

        {

            mAcceptMonitor->notify();

        }

    }

    else

    {

        if (mAsyncAccept)

        {

            // If Pushframework cancels the listening then return otherwise

            // continue listening.

            if (KErrCancel == err)

            {

                mPushEventListener->handleConnectionRequest(NULL, err);

            }

            else

            {

                ELOG(EJavaBluetooth,

                     "  RFCOMMServerConnection::HandleAcceptCompleteL: Error while accept. Listening again.");

                AcceptL();

            }

            return;

        }

        else

        {

            mAcceptMonitor->notify();

        }

    }

    // If connection is accepted, then it should

    // disable the advertising flag

    if (NULL != mServRec)

    {

        mServRec -> setAdvertiseFs(EFalse);

    }

    LOG(EJavaBluetooth, EInfo, "-  RFCOMMServerConnection::HandleAcceptCompleteL");

}

// Notification of a baseband event

void RFCOMMServerConnection::HandleActivateBasebandEventNotifierCompleteL(

    TInt /*aErr*/, TBTBasebandEventNotification& /*aEventNotification*/)

{

    LOG1(EJavaBluetooth,EInfo,

         "+  RFCOMMServerConnection::HandleActivateBasebandEventNotifierCompleteL %s",

         "WARNING: Nothing to handle in this event !!");

}

//Notification of a connection complete event

void RFCOMMServerConnection::HandleConnectCompleteL(TInt /*aErr*/)

{

    LOG1(EJavaBluetooth,EInfo,

         "+  RFCOMMServerConnection::HandleConnectCompleteL %s",

         "WARNING: Nothing to handle in this event !!");

}