bluetoothcommunicator.cpp

Go to the documentation of this file.

/*
 * bluetoothcommunicator.cpp,v 1.38 2004/01/10 14:27:10 mattid Exp
 *
 * COBAIN - Communications API for EPOC Environments
 * Copyright (C) 2002-2003 Matti Dahlbom, Matti Kokkola
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Contact: Matti Dahlbom <matti@777-team.org>
 *          Matti Kokkola <matti.kokkola@iki.fi>
 */

#include <es_sock.h>
#include <bt_sock.h>
#include <btmanclient.h>

#include "bluetoothcommunicator.h"
#include "cobainserver.h"
#include "serversession.h"
#include "btdiscoverer.h"
#include "concreteconnection.h"
#include "Log.h"

CBTCommunicator::CBTCommunicator(CServerSession *aSession)
    : iIsListening(EFalse),
      iListeningConnection(NULL),
      iListeningSocketType(-1)
{
    iServerSession = aSession;
}

CBTCommunicator::~CBTCommunicator()
{
    delete iDiscoverer;

    if( iIsListening ) {
        StopListeningL();

        // close service discovery related resources
        iSdpDB.Close();
        iSdpSession.Close();
    }

    // disconnect from socket server
    Log::Print(_L("closing socket server.."));
    iSocketServ.Close();
}

void CBTCommunicator::ConstructL()
{
    // connect to the socket server
    iSocketServ.Connect();
}

CBTCommunicator * CBTCommunicator::NewL(CServerSession *aSession)
{
    CBTCommunicator *c = new CBTCommunicator(aSession);
    CleanupStack::PushL(c);
    c->ConstructL();
    CleanupStack::Pop(); // c

    return c;
}

void CBTCommunicator::DiscoverPeersL(const RMessage &aMessage,
                                     CServerSession &aSession)
{
#ifdef __WINS__

    // foobar test code for emulator

    //jolla's btdevaddr
    TUint8 btaddr[] = { 0x00, 0x04, 0x61, 0x80, 0x2f, 0xfd };
    TBuf8<6> addrbuf;
    addrbuf.Copy(btaddr, 6);

    TPeerDataList *peers = new (ELeave) TPeerDataList();
    TPeerData *data = new TPeerData;
    data->iDeviceName = _L("device1");
    data->iDeviceAddress = addrbuf;
    data->iServiceName = _L("dummy service 1");
    data->p.iBtProperties.iL2capPort = 1;
    peers->Append(data);
    data = new TPeerData;
    data->iDeviceName = _L("device2");
    data->iDeviceAddress = addrbuf;
    data->iServiceName = _L("dummy service 2");
    data->p.iBtProperties.iRfcommPort = 3;
    peers->Append(data);
    TInt size = 2;

    // set peerlist and complete call
    aSession.SetPeerList(peers);
    TBuf8<sizeof(TInt)> buf;
    buf.Copy((const TUint8 *)(&size), sizeof(TInt));
    aMessage.WriteL(aMessage.Ptr1(), buf);
    aMessage.Complete(KErrNone);
#else

    // real discovery code for actual device

    if( iDiscoverer != NULL ) {
        delete iDiscoverer;
        iDiscoverer = NULL;
    }

    // start new discoverer
    iDiscoverer = CBTDiscoverer::NewL(aMessage, aSession);
    iDiscoverer->StartL(iSocketServ);

#endif
}

// synchronously connects to the service
RSocket* CBTCommunicator::ConnectL(TPeerData *aPeerData)
{
    //Log::Print(_L("CBTCommunicator::ConnectL()"));

    RSocket *socket = new (ELeave) RSocket();
    CleanupStack::PushL(socket);

    // select between RFCOMM/L2CAP regarding to the peer data
    TBool use_rfcomm = ETrue;
    TInt port = aPeerData->p.iBtProperties.iRfcommPort;

    if( aPeerData->p.iBtProperties.iL2capPort > 0 ) {
        use_rfcomm = EFalse;
        port = aPeerData->p.iBtProperties.iL2capPort;
    }

    // check that there is a valid port value now
    __ASSERT_ALWAYS(port > 0, User::Leave(KErrArgument));

    if( use_rfcomm ) {
        // construct RFCOMM socket
        Log::Print(_L("Opening RFCOMM socket"));
        User::LeaveIfError(socket->Open(iSocketServ,
                                        KBTAddrFamily,
                                        KSockStream,
                                        KRFCOMM));
    } else {
        // construct L2CAP socket
        Log::Print(_L("Opening L2CAP socket"));
        User::LeaveIfError(socket->Open(iSocketServ,
                                        KBTAddrFamily,
                                        KSockSeqPacket, 
                                        KL2CAP));
    }

    // construct the address to connect to
    TBTDevAddr devaddr(aPeerData->iDeviceAddress);
    TBTSockAddr address;
    address.SetBTAddr(devaddr);
    address.SetPort(port);

    // connect the socket
    TRequestStatus status;
    socket->Connect(address, status);
    User::WaitForRequest(status);

    // validate that Connect() succeeded
    User::LeaveIfError(status.Int());    

    CleanupStack::Pop(); // socket

    Log::Print(_L("CBTCommunicator::ConnectL() exiting.."));

    return socket;
}

// closes listening socket and stops advertising the service
void CBTCommunicator::StopListeningL()
{
    if( !iIsListening ) {
        return;
    }

    // delete listening connection entity 
    delete iListeningConnection;
    iListeningConnection = NULL;

    // stop advertising - nevermind errors
    TRAPD(err, iSdpDB.DeleteRecordL(iRecord));
    if( err != KErrNone ) {
        Log::Print(_L("StopListeningL(): err %d"), err);
    }

    iRecord = 0;

    iIsListening = EFalse;
    iListeningSocketType = -1;
}

void CBTCommunicator::StartAdvertisingL(TInt aPort,
                                        const TInt aServiceClassID,
                                        const TInt aApplicationID,
                                        const TDesC8 &aServiceName,
                                        const TDesC8 &aServiceDesc) 
{
    Log::Print(_L("StartAdvertisingL()"));

    // Connects to the SDP database
    User::LeaveIfError(iSdpSession.Connect());
    User::LeaveIfError(iSdpDB.Open(iSdpSession));

    // Defines the protocol that should be used to connect
    // with the advertised service
    CSdpAttrValueDES* protocol_descriptor = CSdpAttrValueDES::NewDESL(NULL);
    CleanupStack::PushL(protocol_descriptor);

    TBuf8<1> channel;
    channel.Append((TChar)aPort);

    if( iListeningSocketType == KRFCOMM ) {
        protocol_descriptor
        ->StartListL()   //  List of protocols required for this method
            ->BuildDESL()
            ->StartListL()
                ->BuildUUIDL(aServiceClassID)
                ->BuildUUIDL(KL2CAP)
                ->BuildUUIDL(KRFCOMM)
                ->BuildUintL(channel)
            ->EndListL()
        ->EndListL();
    } else {
        protocol_descriptor
        ->StartListL()   //  List of protocols required for this method
            ->BuildDESL()
            ->StartListL()
                ->BuildUUIDL(aServiceClassID)
                ->BuildUUIDL(KL2CAP)
                ->BuildUintL(channel)
                ->BuildUUIDL(KRFCOMM)
            ->EndListL()
        ->EndListL();
    }

    iSdpDB.CreateServiceRecordL(*protocol_descriptor, iRecord);
    iSdpDB.UpdateAttributeL(iRecord, 
                            KSdpAttrIdProtocolDescriptorList, 
                            *protocol_descriptor);

    CleanupStack::PopAndDestroy(); // protocol_descriptor
    
    // Defines the application ID
    iSdpDB.UpdateAttributeL(iRecord, 
                            KSdpAttrIdServiceID, 
                            aApplicationID);

    // Defines the service name
    CSdpAttrValueString *service_name =
        CSdpAttrValueString::NewStringL(aServiceName);
    CleanupStack::PushL(service_name);
    iSdpDB.UpdateAttributeL(iRecord, 
                KSdpAttrIdBasePrimaryLanguage + 
                KSdpAttrIdOffsetServiceName, 
                *service_name);
    CleanupStack::PopAndDestroy(); // service_name

    // Add a description to the record
    CSdpAttrValueString *service_desc =
        CSdpAttrValueString::NewStringL(aServiceDesc);
    CleanupStack::PushL(service_desc);
    iSdpDB.UpdateAttributeL(iRecord, 
                KSdpAttrIdBasePrimaryLanguage + 
                KSdpAttrIdOffsetServiceDescription,
                *service_desc);
    CleanupStack::PopAndDestroy(); // service_desc
}

void CBTCommunicator::SetAvailabilityL(TBool aIsAvailable)
{
    TUint state = aIsAvailable ? 0xff : 0x00;

    // set the service availability attribute field
    iSdpDB.UpdateAttributeL(iRecord, KSdpAttrIdServiceAvailability, state);

    // increase the record version
    iSdpDB.UpdateAttributeL(iRecord, KSdpAttrIdServiceRecordState, iRecordVersion++);
}


// called by StartListeningL(). returns port to listen to
TInt CBTCommunicator::OpenListeningSocketL()
{
    Log::Print(_L("OpenListeningSocketL()"));

    // close existing listening socket if open
    iListeningSocket.Close();

    // delete old connection entity if any
    delete iListeningConnection;
    iListeningConnection = NULL;

    TInt port;

    if( iListeningSocketType == KRFCOMM ) {
        // open RFCOMM socket 
        Log::Print(_L("Opening RFCOMM socket"));
        User::LeaveIfError(iListeningSocket.Open(iSocketServ,
                                                 KBTAddrFamily,
                                                 KSockStream,
                                                 KRFCOMM));

        // acquire RFCOMM server channel to listen to
        User::LeaveIfError(
            iListeningSocket.GetOpt(KRFCOMMGetAvailableServerChannel, 
                    KSolBtRFCOMM, port)
        );

        iListeningSocket.SetLocalPort(port);
    } else {
        // open L2CAP socket
        Log::Print(_L("Opening L2CAP socket"));
        User::LeaveIfError(iListeningSocket.Open(iSocketServ,
                                                 KBTAddrFamily,
                                                 KSockSeqPacket,
                                                 KL2CAP));

        // find a L2CAP PSM port value (must be odd) by trying out values until
        // found one that is not in use, starting from 5
        TBool is_ok = EFalse;
        port = 5;

        while(  !is_ok ) {
            //Log::Print(_L("trying port %d"), port);
            TInt ret = iListeningSocket.SetLocalPort(port);
            if( ret == KErrNone ) {
                // bound to the port - start to listen
                break;
            } else if( ret == KErrInUse ) {
                // try next port number
                port += 2;
            } else {
                // error - failed
                //Log::Print(_L("SetLocalPort() error: %d"), ret);
                User::Leave(ret);
            }
        }
    }
        
    Log::Print(_L("using port %d"), port);

    Log::Print(_L("calling Listen()"));
    User::LeaveIfError(iListeningSocket.Listen(KListeningQueueSize));

    Log::Print(_L("creating con entity"));

    // create new connection entity 
    iListeningConnection = CConcreteConnection::NewListeningL(&iListeningSocket,
                                                              &iSocketServ,
                                                              *iServerSession);

    return port;
}

void CBTCommunicator::SetChannelSecurityL(TInt aChannel)
{
    RBTMan sec_manager;
    RBTSecuritySettings sec_session;

    // open security manager session
    User::LeaveIfError(sec_manager.Connect());
    CleanupClosePushL(sec_manager);
    User::LeaveIfError(sec_session.Open(sec_manager));
    CleanupClosePushL(sec_session);

    // define the security settings
    TBTServiceSecurity sec_settings(KCobainServerUid3, KSolBtRFCOMM, aChannel);

    if( iListeningSocketType == KL2CAP ) {
        sec_settings.SetProtocolID(KSolBtL2CAP);
    }

    sec_settings.SetAuthentication(EFalse);
    sec_settings.SetEncryption(EFalse);
    sec_settings.SetAuthorisation(EFalse);

    // register the service
    TRequestStatus status;
    sec_session.RegisterService(sec_settings, status);
    User::WaitForRequest(status);
    User::LeaveIfError(status.Int());

    // cleanup
    CleanupStack::PopAndDestroy(); // sec_session
    CleanupStack::PopAndDestroy(); // sec_manager
}

// called by CServerSession::ListenL()
CConcreteConnection* CBTCommunicator::StartListeningL(const TInt aServiceClassID,
                                                      const TInt aApplicationID,
                                                      const TDesC8 &aServiceName,
                                                      const TDesC8 &aServiceDesc,
                                                      TInt aListeningSocketType) 
{
    __ASSERT_ALWAYS(iListeningConnection == NULL, 
                    User::Panic(KBTCommPanic, KErrBTCommAlreadyListening));

    Log::Print(_L("StartListeningL()"));    

    // store type of listening socket
    iListeningSocketType = aListeningSocketType;

    // open new listening socket 
    TInt port = -1;
    
    TRAPD(err, (port = OpenListeningSocketL()));
    if( err != KErrNone ) {
        //Log::Print(_L("OpenListeningSocketL() error: %d"), err);
        User::Panic(KBTCommPanic, KerrBTCommFailedToCreateListeningSocket);
    }

    // set channel security
    SetChannelSecurityL(port);

    // start advertising the service
    StartAdvertisingL(port, 
                      aServiceClassID, 
                      aApplicationID, 
                      aServiceName,
                      aServiceDesc);

    // make the service available
    SetAvailabilityL(ETrue);

    iIsListening = ETrue;

    return iListeningConnection;
}

TInt CBTCommunicator::ResolveMTU(RSocket& aSocket) 
{
    TInt mtu = 0;
    TInt rc = KErrNone;

    //##TODO## is this the same value with RFCOMM?
    rc = aSocket.GetOpt(KL2CAPGetOutboundMTU, 
             KSolBtL2CAP, mtu);    
    if (rc != KErrNone) {
    // Could not resolve MTU, use minimum value as
    // defined by API
    mtu = 48;
    }
    return mtu;
}

---