cmdbasedrfcommhandler.cpp

It s a tool designed to extract as much information as possible from Bluetooth devices without the r

/* -*- c++ -*- ---------------------------------------------------------------
   Copyright (C) 2005, SWECO, All Rights Reserved.

   Implementation of CmdBasedRFCommHandler class

   Author: Zsolt Molnar ([e-mail])
   ---------------------------------------------------------------------------*/

#include <sstream>
#include <iostream>
#include "AppFactory.hh" 
#include "CmdBasedRFCommHandler.hh"

namespace { 
	const char rcs_id[] = "$Id$"; 
}

#ifndef __TEST__
const CmdBasedRFCommHandler::tDevLimit 
    CmdBasedRFCommHandler::_serialLimits(100, 200);
#else // __TEST__
const CmdBasedRFCommHandler::tDevLimit 
    CmdBasedRFCommHandler::_serialLimits(5, 6);
#endif // #ifndef __TEST__

ConnectedDevice::ConnectedDevice(const Device& aDevice)
	: Device(aDevice),
	  _isConnected(false)
{
	// EMPTY
}


ConnectedDevice::ConnectedDevice(const ConnectedDevice& aDevice)
	: Device(aDevice),
	  _isConnected(aDevice._isConnected)
{
	// EMPTY
}


ConnectedDevice::~ConnectedDevice()
{
	if (_isConnected) {
        dynamic_cast<CmdBasedRFCommHandler&>(AppFactory::getRFCommHandler()).unconnect_nolock(*this);
	}
}



CmdBasedRFCommHandler::CmdBasedRFCommHandler()
	: _connDb(0)
{
	_connDb.setMaxSize(getMaxSerialConnections() + 1);
}


CmdBasedRFCommHandler::~CmdBasedRFCommHandler()
{
	for (_tRFCommBindings::iterator itr = _RFCommBindings.begin();
		 itr != _RFCommBindings.end(); ++itr) 
	{
		unconnect_nolock(itr->first);
	}
}


bool 
CmdBasedRFCommHandler::serial_connect(const Device& aDevice)
{
	lock();
	ConnectedDevice& dev = _connDb.accessElem(aDevice);

	if (!dev.isConnected()) {
		if (_connect(dev, _SERIAL_CHANNEL, _serialLimits)) {
			dev.setConnected();
		}
	}

	bool ret = dev.isConnected();
	unlock();
	return ret;
}
	

bool 
CmdBasedRFCommHandler::unconnect(const Device& aDevice)
{
	lock();
	bool ret = unconnect_nolock(aDevice);
	_connDb.accessElem(aDevice).setUnconnected();
	unlock();
	return ret;
}


int
CmdBasedRFCommHandler::getPort(const Device& aDevice)
{
	lock();
	int ret = -1;
	_tRFCommBindings::iterator pos = _RFCommBindings.find(aDevice);
	
	if (pos != _RFCommBindings.end()) {
		ret = pos->second;
	}
	
	unlock();
	return ret;
}


int 
CmdBasedRFCommHandler::getMaxSerialConnections()
{
	return _serialLimits.second - _serialLimits.first;
}


bool 
CmdBasedRFCommHandler::unconnect_nolock(const Device& aDevice)
{
	bool ret = false;
	_tRFCommBindings::iterator pos = _RFCommBindings.find(aDevice);
	
	if (pos != _RFCommBindings.end()) {
		stringstream command;
		command << "rfcomm release " << CBRF_RFCOMM_DEV << pos->second
				<< " >& /dev/null";
		system(command.str().c_str());
		cout << "CmdBasedRFCommHandler: device " << aDevice.devID 
			 << " unconnected from " << CBRF_RFCOMM_DEV << pos->second
			 << endl;
		_RFCommBindings.erase(pos);
		ret = true;
	}
	return ret;
}


void 
CmdBasedRFCommHandler::_construct()
{
	// unbind all the possibly bound rfcomm channels
	for (int i = 0; i <= CBRF_MAX_DEV; ++i) {
		stringstream command;
		command << "rfcomm release " << i << " >& /dev/null";
		system(command.str().c_str());
	}
}


int 
CmdBasedRFCommHandler::_getDevNumber(const tDevLimit& aLimits)
{
	for (int i = aLimits.first; i <= aLimits.second; ++i) {
		_tRFCommBindings::iterator itr = _RFCommBindings.begin();
		
		while (itr != _RFCommBindings.end() && itr->second != i) {
			++itr;
		}

		if (itr == _RFCommBindings.end()) {
			return i;
		}
	}
	return -1;
}


bool 
CmdBasedRFCommHandler::_connect(const Device& aDevice, 
								const int aChannel,
								const tDevLimit& aLimits)
{
	bool ret = true;
	stringstream command;
	int devNum;
	// Look if the device is already connected.
	if (_RFCommBindings.find(aDevice) != _RFCommBindings.end()) {
		goto OUT;
	}
	// Look for the first available device number
	devNum = _getDevNumber(aLimits);
	// is there any available dev. number?
	if (devNum == -1) {
		ret = false;
		goto OUT;
	}
	// Connect if there is any
	command << "rfcomm -i hci1 bind " << devNum << " " << aDevice.devID << " "
			<<  aChannel << " >& /dev/null";
	system(command.str().c_str());
	_RFCommBindings[aDevice] = devNum;

	cout << "CmdBasedRFCommHandler: device " << aDevice.devID 
		 << " connected to " << CBRF_RFCOMM_DEV << devNum << endl;

OUT:
	return ret;
}


#ifdef __TEST__
#include <assert.h>
#include <iostream>

bool
CmdBasedRFCommHandler::test()
{
	Device dev_0("00:00:00:00:00:00", Device::OTHER);
	Device dev_1("11:11:11:11:11:11", Device::NOKIA6600);
	Device dev_2("22:22:22:22:22:22", Device::NOKIA6600);
	// 1 device appears.
	cout << endl;

	// 1 device device appears
	assert(serial_connect(dev_1));
	assert(_RFCommBindings.size() == 1);
	assert(_RFCommBindings[dev_1] == 5);
	assert(_RFCommBindings.size() == 1);
	cout << endl << "Check the bindings: " << dev_1.devID << " bound to rfcomm"
		 << " 5, channel 2. Press enter if OK." << endl;
	system("rfcomm -a");
	getchar();


	// 1 more device device appears
	assert(serial_connect(dev_2));
	assert(_RFCommBindings.size() == 2);
	assert(_RFCommBindings[dev_1] == 5);
	assert(_RFCommBindings[dev_2] == 6);
	assert(_RFCommBindings.size() == 2);
	cout << endl << "Check the bindings: " << dev_1.devID << " bound to rfcomm"
		 << " 5, " << dev_2.devID << " bound to rfcomm"
		 << " 6 (both to channel 2). Press enter if OK." << endl;
	system("rfcomm -a");
	getchar();


	// 1 more device appears - but there is no more dev. number,
	// the last one should be disconnected...
	assert(serial_connect(dev_0));
	assert(_RFCommBindings.size() == 2);
	assert(_RFCommBindings[dev_0] == 5);
	assert(_RFCommBindings[dev_2] == 6);
	assert(_RFCommBindings.size() == 2);
	cout << endl << "Check the bindings: " << dev_0.devID << " bound to rfcomm"
		 << " 5, " << dev_2.devID << " bound to rfcomm"
		 << " 6  (both to channel 2). Press enter if OK." << endl;
	system("rfcomm -a");
	getchar();

	// Disconnect a device
	assert(unconnect(dev_2));
	assert(_RFCommBindings.size() == 1);
	assert(_RFCommBindings[dev_0] == 5);
	assert(_RFCommBindings.size() == 1);
	cout << endl << "Check the bindings: " << dev_0.devID << " bound to rfcomm"
		 << " 5 (channel 2). Press enter if OK." << endl;
	system("rfcomm -a");
	getchar();

	// check getPort
	assert(getPort(dev_0) == 5);
	assert(getPort(dev_1) == -1);
	assert(getPort(dev_2) == -1);
	assert(_RFCommBindings.size() == 1);


	// Reconnect a device. dev_0 went out of the Cache, so it is 
	// disconnected now...
	assert(serial_connect(dev_1));
	assert(_RFCommBindings.size() == 1);
	assert(_RFCommBindings[dev_1] == 5);
	assert(_RFCommBindings.size() == 1);
	cout << endl << "Check the bindings: " << dev_1.devID << " bound to rfcomm"
		 << " 5, channel 2. Press enter if OK." << endl;
	system("rfcomm -a");
	getchar();

	// Disconnect all the devices
	assert(unconnect(dev_1));
	assert(_RFCommBindings.size() == 0);
	cout << endl << "Check the bindings: no bindings. Press enter if OK." 
		 << endl;
	system("rfcomm -a");
	getchar();

	// Disconnect a not connected device
	assert(!unconnect(dev_0));
	assert(_RFCommBindings.size() == 0);
	cout << endl << "Check the bindings: no bindings. Press enter if OK." 
		 << endl;
	system("rfcomm -a");
	getchar();

	cout << "CmdBasedRFCommHandler test passed" << endl;
	return true;
}
#endif // #ifdef __TEST__