/*

* 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 <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <dirent.h>

#include <sys/uio.h>

#include <unistd.h>

#include <fcntl.h>

#include "fs_methodcall.h"

#include "javajniutils.h"

#include "servicerecord.h"

#include "logger.h"

#include "javasymbianoslayer.h"

#include "bluetoothconsts.h"

#include "applicationinfo.h"

#include "fileutilities.h"

#include "javaoslayer.h"

#include "javacommonutils.h"

#include "btservicerecordpopulator.h"

#include "serviceclasshandler.h"

#include "fileutilities.h"

#include "exceptionbase.h"

using namespace java::util;

using namespace java::fileutils;

namespace java

{

namespace bluetooth

{

#define SERVICE_AVAILABLE 0xFF

#define KGOEP 0x0008    // This is the fixed Id. Should not be modified at any time.

#define SERVICE_CLASSES_BITS_POS    13

// Permission: Read,Write,Execute for both Owner & Group

#define BT_DIR_PERM 0777

/**

 * Returns the new ServiceRecord object.

 */

OS_EXPORT ServiceRecord* ServiceRecord::NewL(BluetoothFunctionServer* aServer)

{

    JELOG2(EJavaBluetooth);

    ServiceRecord* servRec = new ServiceRecord(aServer);

    CleanupStack::PushL(servRec);

    servRec->ConstructL();

    CleanupStack::Pop(servRec);

    return servRec;

}

OS_EXPORT void ServiceRecord::cleanup(ServiceRecord*& aServer)

{

    JELOG2(EJavaBluetooth);

    if (aServer)

    {

        aServer->cleanUp();

        delete aServer;

        aServer = NULL;

    }

}

void ServiceRecord::ConstructL()

{

    JELOG2(EJavaBluetooth);

    mInitializedByPush = false;

    mRestoredFromPersistentFile = false;

    // Open sdp session

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

    // Open sdp database session

    User::LeaveIfError(mSdpDB.Open(mSdp));

    mRecordState = 0;

}

ServiceRecord::ServiceRecord(BluetoothFunctionServer* aServer)

{

    JELOG2(EJavaBluetooth);

    mFunctionServer = aServer;

    mRecord = 0;

    mSrvRecFd = 0;

}

ServiceRecord::~ServiceRecord()

{

    JELOG2(EJavaBluetooth);

    mFunctionServer = NULL;

}

void ServiceRecord::cleanUp()

{

    JELOG2(EJavaBluetooth);

    if (mRecord)

    {

        TRAP_IGNORE(mSdpDB.DeleteRecordL(mRecord));

        mRecord = 0;

    }

    mSdpDB.Close();

    mSdp.Close();

}

/**

 * Used in case there is no persistence storage of service record

 * On success returns 0; otherwise err number.

 *

 * Creates and initializes the Service record.

 * aProtocol: One among the PROTOCOL_L2CAP, PROTOCOL_RFCOMM, PROTOCOL_GOEP

 * aPSMValue: In case of L2CAP it should be PSM Value;

 *            In case of RFComm it should be channel number.

 * aUuid: UUID string of the current service

 * aServiceName: Name of the current service.

 */

OS_EXPORT int ServiceRecord::initializeRecord(int aProtocol, int aPSMValue,

        std::wstring aUuid, std::wstring aServiceName)

{

    JELOG2(EJavaBluetooth);

    int uuidByteLength = 0;

    TUint8* uuidBytes = uuidToByteArray(aUuid, uuidByteLength);

    TUUID uuid;

    TPtrC8 uuidDes(uuidBytes, uuidByteLength);

    TRAPD(err, uuid.SetL(uuidDes));

    delete[] uuidBytes;

    uuidBytes = NULL;

    if (KErrNone != err)

    {

        LOG2(EJavaBluetooth, EInfo,

             "- ServiceRecord::initializeRecord Error SetL:%d [UUID:%S]",

             err, aUuid.c_str());

        return err;

    }

    HBufC* nameString = wstringToBuf(aServiceName);

    TPtrC nameBufPointer(nameString->Des());

    HBufC8* utf8NameBuffer = HBufC8::NewMax(aServiceName.length() + 1);

    TPtr8 utf8NameBufferPtr(utf8NameBuffer->Des());

    utf8NameBufferPtr.Copy(nameBufPointer);

    TRAP(err, initializeRecordL(aProtocol, aPSMValue, uuid, utf8NameBufferPtr));

    return err;

}

/**

 * Used in case of persistence storage of updated service record

 */

OS_EXPORT int ServiceRecord::restorePersistentRecord()

{

    JELOG2(EJavaBluetooth);

    int ret = 0;

    CallMethod(ret, this, &ServiceRecord::restorePersistentRecordFs,

               mFunctionServer);

    return ret;

}

int ServiceRecord::restorePersistentRecordFs()

{

    JELOG2(EJavaBluetooth);

    // Can set this flag as this function will get called

    // only in case of push invocation

    mInitializedByPush = true;

    std::wstring persistentFileName = getPersistentFileName();

    int persistentRecFd = -1;

    int ret = 0;

    int err = 0;

    if (persistentFileName.length() > 0)

    {

        try

        {

            char *fileName = java::util::JavaCommonUtils::wstringToUtf8(

                                 persistentFileName);

            persistentRecFd = open(fileName, O_RDONLY);

            delete[] fileName;

        }

        {

            ELOG1(

                EJavaBluetooth,

                "- ServiceRecord::restorePersistentRecordFs exception Caught: %S",

                ex.toString().c_str());

        }

    }

    if (persistentRecFd < 0)

        return errno;

    // Reading and restoring the DeviceServiceClasses bits

    int devServClass = 0;

    ret = read(persistentRecFd, &devServClass, sizeof(devServClass));

    if (ret <= 0)

        return errno;

    if (devServClass != 0)

    {

        LOG1(EJavaBluetooth, EInfo,

             "  ServiceRecord::restorePersistentRecordFs Setting COD:0x%X",

             devServClass);

        ret = ServiceClassHandler::setDeviceServiceClass(devServClass, true);

        LOG1(EJavaBluetooth, EInfo,

             "  ServiceRecord::restorePersistentRecordFs Set COD Return:%d",

             ret);

    }

    // Restoring all other service record data

    int attrId = 0;

    while ((ret = read(persistentRecFd, &attrId, sizeof(attrId))) > 0)

    {

        int dataType = 0;

        ret = read(persistentRecFd, &dataType, sizeof(dataType));

        if (ret <= 0)

            break;

        LOG2(EJavaBluetooth, EInfo, "  ServiceRecord reading %X, %X", attrId,

             dataType);

        switch (dataType)

        {

        case DataElement_DATSEQ:

        case DataElement_DATALT:

        {

            err = attributeListStartFs(attrId, dataType, EFalse);

            break;

        }

        case DataElement_EndList:

        {

            err = attributeListEndFs(attrId, EFalse);

            break;

        }

        case DataElement_NULL:

        {

            err = setAttributeNilFs(attrId, EFalse);

            break;

        }

        case DataElement_BOOL:

        {

            TUint8 val = 0;

            ret = read(persistentRecFd, &val, sizeof(val));

            if (ret <= 0)

                break;

            LOG1(EJavaBluetooth, EInfo, "  ServiceRecord reading Bool %X", val);

            err = setAttributeBoolFs(attrId, (val) ? ETrue : EFalse, EFalse);

            break;

        }

        case DataElement_INT_1:

        case DataElement_INT_2:

        case DataElement_INT_4:

        {

            int len = 0;

            ret = read(persistentRecFd, &len, sizeof(len));

                break;

            ret = read(persistentRecFd, buf, len);

            if (ret <= 0)

                break;

            std::auto_ptr<HBufC8> val(convertIntToDesC(buf, dataType));

            err = setAttributeIntFs(attrId, dataType, *val, EFalse);

            break;

        }

        case DataElement_INT_8:

        case DataElement_INT_16:

        {

            int len = 0;

            ret = read(persistentRecFd, &len, sizeof(len));

                break;

            ret = read(persistentRecFd, buf, len);

            if (ret <= 0)

                break;

            TPtrC8 val(buf, len);

            err = setAttributeIntFs(attrId, dataType, val, EFalse);

            break;

        }

        case DataElement_U_INT_1:

        case DataElement_U_INT_2:

        case DataElement_U_INT_4:

        {

            int len = 0;

            ret = read(persistentRecFd, &len, sizeof(len));

                break;

            ret = read(persistentRecFd, buf, len);

            if (ret <= 0)

                break;

            LOG2(EJavaBluetooth, EInfo, "  ServiceRecord reading INT8 %X, %S",

                 len, buf);

            std::auto_ptr<HBufC8> val(convertIntToDesC(buf, dataType));

            err = setAttributeUintFs(attrId, dataType, *val, EFalse);

            break;

        }

        case DataElement_U_INT_8:

        case DataElement_U_INT_16:

        {

            int len = 0;

            ret = read(persistentRecFd, &len, sizeof(len));

                break;

            ret = read(persistentRecFd, buf, len);

            if (ret <= 0)

                break;

            LOG2(EJavaBluetooth, EInfo, "  ServiceRecord reading INT16 %X, %S",

                 len, buf);

            TPtrC8 val(buf, len);

            err = setAttributeUintFs(attrId, dataType, val, EFalse);

            break;

        }

        case DataElement_UUID:

        {

            int len = 0;

            ret = read(persistentRecFd, &len, sizeof(len));

                break;

            TUint8 buf[256] = { 0 };

            ret = read(persistentRecFd, buf, len);

            if (ret <= 0)

                break;

            LOG2(EJavaBluetooth, EInfo, "  ServiceRecord reading UUID %X, %S",

                 len, buf);

            TPtrC8 uuidDes(buf, len);

            TUUID val;

            TRAP(err, val.SetL(uuidDes));

            if (KErrNone == err)

            {

                err = setAttributeUUIDFs(attrId, val, EFalse);

            }

            break;

        }

        case DataElement_STRING:

        {

            int len = 0;

            ret = read(persistentRecFd, &len, sizeof(len));

                break;

            TUint8 buf[1024] = {0};

            ret = read(persistentRecFd, buf, len);

            if (ret <= 0)

                break;

            LOG1(EJavaBluetooth, EInfo, "  ServiceRecord reading STRING %X",

                 len);

            TPtrC8 val(buf, len);

            err = setAttributeStringFs(attrId, val, EFalse);

            break;

        }

        case DataElement_URL:

        {

            int len = 0;

            ret = read(persistentRecFd, &len, sizeof(len));

                break;

            TUint8 buf[1024] = {0};

            ret = read(persistentRecFd, buf, len);

            if (ret <= 0)

                break;

            LOG2(EJavaBluetooth, EInfo, "  ServiceRecord reading URL %X, %S",

                 len, buf);

            TPtrC8 val(buf, len);

            err = setAttributeUrlFs(attrId, val, EFalse);

            break;

        }

        default:

            break;

        }

        // Treated as EOF reached.

        if (ret <= 0)

            break;

    }

    // Indicates a successful retrieval

    // of the service record from the persistent file

    mRestoredFromPersistentFile = true;

    return ret;

}

/**

 * Creates and initializes the Service record.

 * aProtocol: One among the PROTOCOL_L2CAP, PROTOCOL_RFCOMM, PROTOCOL_GOEP

 * aPSMValue: In case of L2CAP it should be PSM Value;

 *            In case of RFComm it should be channel number.

 * aServiceUUID: UUID of the current service

 * aServiceName: Name of the current service.

 */

OS_EXPORT void ServiceRecord::initializeRecordL(TInt aProtocol, TInt aPsmValue,

        TUUID &aServiceUUID, TDesC8 &aServiceName)

{

    JELOG2(EJavaBluetooth);

    CallMethodL(this, &ServiceRecord::initializeRecordFsL, aProtocol,

                aPsmValue, aServiceUUID, aServiceName, mFunctionServer);

}

/**

 * Returns the service record handle.

 */

OS_EXPORT int ServiceRecord::getServiceRecordID()

{

    return mRecord;

}

void ServiceRecord::initializeRecordFsL(TInt aProtocol, TInt aPsmValue,

                                        TUUID &aServiceUUID, TDesC8 &aServiceName)

{

    JELOG2(EJavaBluetooth);

    // Open sdp session

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

    // Open sdp database session

    User::LeaveIfError(mSdpDB.Open(mSdp));

    LOG1(

        EJavaBluetooth,

        EInfo,

        "  ServiceRecord::initializeRecordFsL: After registering to SDPDB: %S",

        aServiceUUID.Des().Ptr());

    // Creating proper ServiceClassID list

    CSdpAttrValueDES *serviceClassIds = CSdpAttrValueDES::NewDESL(NULL);

    serviceClassIds->BuildUUIDL(aServiceUUID);

    if (PROTOCOL_RFCOMM == aProtocol)

    {

        LOG(EJavaBluetooth, EInfo,

            "  ServiceRecord::initializeRecordFsL: Adding KSerialPortUUID");

        serviceClassIds->BuildUUIDL(TUUID(KSerialPortUUID));

    }

    // Create a record of the correct service class

    mSdpDB.CreateServiceRecordL(*serviceClassIds, mRecord);

    // Add a protocol to the record

    mSdpAttrValueList = CSdpAttrValueDES::NewDESL(NULL);

    mLastSdpAttr = mSdpAttrValueList;

    CleanupStack::PushL(mSdpAttrValueList);

    // Getting port number

    TSdpIntBuf<TUint> portBuf(aPsmValue);

    LOG1(EJavaBluetooth, EInfo,

         "  ServiceRecord::initializeRecordFsL: port value : %d", aPsmValue);

    LOG(EJavaBluetooth, EInfo,

        "  ServiceRecord::initializeRecordFsL: Creating protocol list");

    // Create protocol list for our service

    switch (aProtocol)

    {

    case PROTOCOL_L2CAP:

        LOG(EJavaBluetooth, EInfo,

            "  ServiceRecord::initializeRecordFsL: PROTOCOL_L2CAP");

        mLastSdpAttr = mLastSdpAttr -> StartListL();

        mLastSdpAttr = mLastSdpAttr -> BuildDESL();

        mLastSdpAttr = mLastSdpAttr -> StartListL();

        mLastSdpAttr = mLastSdpAttr -> BuildUUIDL(KL2CAP);

        mLastSdpAttr = mLastSdpAttr -> BuildUintL(portBuf);

        mLastSdpAttr = mLastSdpAttr -> EndListL();

        mLastSdpAttr = mLastSdpAttr -> EndListL();

        break;

    case PROTOCOL_RFCOMM:

        LOG(EJavaBluetooth, EInfo,

            "  ServiceRecord::initializeRecordFsL: PROTOCOL_RFCOMM");

        mLastSdpAttr = mLastSdpAttr -> StartListL();

        mLastSdpAttr = mLastSdpAttr -> BuildDESL();

        mLastSdpAttr = mLastSdpAttr -> StartListL();

        mLastSdpAttr = mLastSdpAttr -> BuildUUIDL(KL2CAP);

        mLastSdpAttr = mLastSdpAttr -> EndListL();

        mLastSdpAttr = mLastSdpAttr -> BuildDESL();