bluetoothcommunicator.cpp

Go to the documentation of this file.

/*
 * bluetoothcommunicator.cpp,v 1.33 2003/11/25 19:29:56 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)
{
    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);
    TUint8 sid[] = { 0x01, 0x02, 0x03, 0x04 };

    TPeerDataList *peers = new (ELeave) TPeerDataList();
    TPeerData *data = new TPeerData;
    data->iDeviceName = _L("device1");
    data->iDeviceAddress = addrbuf;
    data->iServiceID.Copy(sid, 4);
    data->iPort = 1;
    peers->Append(data);
    data = new TPeerData;
    data->iDeviceName = _L("device2");
    data->iDeviceAddress = addrbuf;
    data->iServiceID.Copy(sid, 4);
    data->iPort = 2;
    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);

    /*
    User::LeaveIfError(socket->Open(iSocketServ,
                                    KBTAddrFamily,
                                    KSockStream,
                                    KRFCOMM));
*/
    //Log::Print(_L("calling socket->Open()"));
    User::LeaveIfError(socket->Open(iSocketServ,
                                    KBTAddrFamily,
                                    KSockSeqPacket, //KSockStream,
                                    KL2CAP));

    //Log::Print(_L("constructing remote address"));

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

    //Log::Print(_L("calling socket->Connect()"));

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

    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;
}

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));

    // Creates the service record
    iSdpDB.CreateServiceRecordL(aServiceClassID, iRecord);

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

    TBuf8<1> channel;
    channel.Append((TChar)aPort);
    /*
    protocolDescriptorList
    ->StartListL()   //  List of protocols required for this method
        ->BuildDESL()
        ->StartListL()
            ->BuildUUIDL(KL2CAP)
        ->EndListL()
    
        ->BuildDESL()
        ->StartListL()
            ->BuildUUIDL(KRFCOMM) 
            ->BuildUintL(channel)
        ->EndListL()
    ->EndListL();
*/
    protocolDescriptorList
    ->StartListL()   //  List of protocols required for this method
        ->BuildDESL()
        ->StartListL()
            ->BuildUUIDL(KL2CAP)
            ->BuildUintL(channel)
        ->EndListL()
    ->EndListL();

    iSdpDB.UpdateAttributeL(iRecord, 
                            KSdpAttrIdProtocolDescriptorList, 
                            *protocolDescriptorList);

    CleanupStack::PopAndDestroy(); // protocolDescriptorList
    
    // 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
}

//##TODO## find out what the hell is the meaning of the bits we are setting
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()"));

    //Log::Print(_L("calling RSocket.Close()"));

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

    //Log::Print(_L("deleting old connection"));

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

    // open socket 
    /*
    User::LeaveIfError(iListeningSocket.Open(iSocketServ,
                                             KBTAddrFamily,
                                             KSockStream,
                                             KRFCOMM));
*/
    //Log::Print(_L("calling RSocket.Open()"));

    User::LeaveIfError(iListeningSocket.Open(iSocketServ,
                                             KBTAddrFamily,
                                             KSockSeqPacket,//KSockStream,
                                             KL2CAP));

                                                
    /*
    // acquire port (a.k.a. channel) to listen to
    TInt port;
    User::LeaveIfError(
        iListeningSocket.GetOpt(KRFCOMMGetAvailableServerChannel, 
                KSolBtRFCOMM, port)
    );
*/
//    //Log::Print(_L("calling RSocket.GetOpt()"));

    // select an arbitrary value for L2CAP PSM (must be odd) from range 0x1001..0xffff
    TInt port = 1;

    // create listening address
//    TBTSockAddr listen_addr;
//    TL2CAPSockAddr listen_addr;
//    listen_addr.SetPort(port);


    // try port numbers until one is free
    TBool is_ok = EFalse;

    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);
        }
    }

    // bind socket and start to listen
//    //Log::Print(_L("calling Bind()"));
//    User::LeaveIfError(iListeningSocket.Bind(listen_addr));
    //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;

    //Log::Print(_L("SetChannelSecurityL(): channel: %d"), aChannel);

    // 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, 0);
    TBTServiceSecurity sec_settings(KCobainServerUid3, KSolBtL2CAP, 0);
    sec_settings.SetAuthentication(EFalse);
    sec_settings.SetEncryption(EFalse);
    sec_settings.SetAuthorisation(EFalse);

    // register the service
    sec_settings.SetChannelID(aChannel);
    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) 
{
    __ASSERT_ALWAYS(iListeningConnection == NULL, 
                    User::Panic(KBTCommPanic, KErrBTCommAlreadyListening));

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

    // 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;
}

---