23 files changed, 4075 insertions, 0 deletions
diff --git a/noncore/settings/networksettings2/etc_ppp/ip-up b/noncore/settings/networksettings2/etc_ppp/ip-up new file mode 100755 index 0000000..ec964d0 --- a/dev/null +++ b/noncore/settings/networksettings2/etc_ppp/ip-up @@ -0,0 +1,71 @@ +#!/bin/sh +exec 2> /tmp/IPL +set -x +# +# This script is run by the pppd after the link is established. +# This script is run by the pppd _after_ the link is brought down. +# +# variable DIR determines if it is run after establish (up) or +# after down (down) +# +# It uses run-parts to run scripts in /etc/ppp/ip-$DIR.d +# +# This script is called with the following arguments: +# Arg Name Example +# $1 Interface name ppp0 +# $2 The tty ttyS1 +# $3 The link speed 38400 +# $4 Local IP number 12.34.56.78 +# $5 Peer IP number 12.34.56.99 +# $6 Optional ``ipparam'' value foo + +# The environment is cleared before executing this script +# so the path must be reset +PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin +export PATH + +case $0 in + *ip-up*) + DIR=up + ;; + *ip-down*) + DIR=down + ;; +esac + +# These variables are for the use of the scripts run by run-parts +PPP_IFACE="$1" +PPP_TTY="$2" +PPP_SPEED="$3" +PPP_LOCAL="$4" +PPP_REMOTE="$5" +PPP_IPPARAM="$6" +export PPP_IFACE PPP_TTY PPP_SPEED PPP_LOCAL PPP_REMOTE PPP_IPPARAM + +# as an additional convenience, $PPP_TTYNAME is set to the tty name, +# stripped of /dev/ (if present) for easier matching. +PPP_TTYNAME=`/usr/bin/basename "$2"` +export PPP_TTYNAME + +# If /var/log/ppp-ipupdown.log exists use it for logging. +if [ -e /var/log/ppp-ipupdown.log ]; then + exec > /var/log/ppp-ipupdown.log 2>&1 +fi + +# This script can be used to override the .d files supplied by other packages. +if [ -x /etc/ppp/ip-${DIR}.local ]; then + exec /etc/ppp/ip-${DIR}.local +fi + +run-parts -a "$1" -a "$2" -a "$3" -a "$4" -a "$5" -a "$6" \ + /etc/ppp/ip-${DIR}.d + +if [ "$DIR" = "up" ] +then + # if pon was called with the "quick" argument, stop pppd + if [ -e /var/run/ppp-quick ]; then + rm /var/run/ppp-quick + wait + kill $PPPD_PID + fi +fi diff --git a/noncore/settings/networksettings2/opietooth2/OTDevice.cpp b/noncore/settings/networksettings2/opietooth2/OTDevice.cpp new file mode 100644 index 0000000..62f17a0 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTDevice.cpp @@ -0,0 +1,256 @@ +#include <qdir.h> +#include <qfileinfo.h> + +#include <bluezlib.h> + +/* OPIE */ +#include <opie2/odevice.h> +#include <opie2/oprocess.h> +#include <opie2/odebug.h> + +#include <OTDevice.h> + +using namespace Opie::Core; +using namespace Opietooth2; +using Opie::Core::OProcess; + +OTDevice::OTDevice( OTGateway * _OT ) : QObject(0, "device") { + + // initialize + OT = _OT; + + // detect bluetooth type + QString a, b; // fake + unsigned long c; // fake + detectDeviceType( a, b, c ); + + if( needsAttach() ) { + // requires HCIATTACH + // pid of hciattach + m_hciattachPid = getPidOfHCIAttach(); + + m_hciattach = 0; + + if( m_hciattachPid == 0 ) { + // no pid -> not attached + m_deviceNr = -1; + } else { + // system enabled + // currently no way to figure out which attach produce which + // hci + m_deviceNr = 0; + } + } else { + m_deviceNr = 0; + } +} + +OTDevice::~OTDevice(){ + if( needsAttach() && m_hciattach ) { + // does not auto stop bluetooth + m_hciattach->detach(); + delete m_hciattach; + } +} + +bool OTDevice::attach(){ + + if( needsAttach() && m_hciattachPid == 0 ) { + QString Dev, Mode; + unsigned long Spd; + + detectDeviceType( Dev, Mode, Spd ); + + // not yet started + m_hciattach = new OProcess(); + *m_hciattach << "hciattach"; + *m_hciattach << "-p"; // so that it prints its pid + *m_hciattach << Dev + << Mode + << QString().setNum(Spd); + + connect( m_hciattach, + SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int ) ), + this, SLOT + (slotStdOut(Opie::Core::OProcess*,char*,int) ) ); + + connect( m_hciattach, + SIGNAL(receivedStderr(Opie::Core::OProcess*, char*, int ) ), + this, SLOT + (slotStdErr(Opie::Core::OProcess*,char*,int) ) ); + + // we need to start this in 'dontcare' mode because + // if qpe exists we want the hci to keep running + if( ! m_hciattach->start( OProcess::DontCare, + OProcess::AllOutput + ) ){ + emit error( tr( "Could not start hciattach" ) ); + delete m_hciattach; + m_hciattach = 0; + return FALSE; + } + } + + return TRUE; +} + +bool OTDevice::detach(){ + + if( needsAttach() && m_hciattachPid ) { + if( m_hciattach ) { + delete m_hciattach; + m_hciattach = 0; + } + + if( kill( m_hciattachPid, 9) < 0 ) { + owarn << "could not stop " << errno << oendl; + emit error( tr( "Could not stop process" ) ); + return FALSE; + } + m_hciattachPid = 0; + emit isEnabled( m_deviceNr, 0 ); + m_deviceNr = -1; + } + + return TRUE; +} + +bool OTDevice::isAttached()const{ + return ! needsAttach() || m_hciattachPid != 0; +} + +bool OTDevice::checkAttach(){ + if( ! needsAttach() ) { + m_deviceNr = 0; + emit isEnabled( 0, 1 ); + return TRUE; + } + + if( m_hciattachPid ) { + QString S; + S.setNum( m_hciattachPid ); + QDir D( "/proc" ); + if( !D.exists( S ) ) { + // down + m_hciattachPid = 0; + emit isEnabled( m_deviceNr, 0 ); + m_deviceNr = -1; + } + } else { + // check + m_hciattachPid = getPidOfHCIAttach(); + if ( m_hciattachPid ) { + m_deviceNr = 0; + emit isEnabled( m_deviceNr, 1 ); + } + } + return m_hciattachPid != 0; +} + +void OTDevice::slotStdOut(OProcess* proc, char* , int ) { + if( proc == m_hciattach ) { + m_hciattach->detach(); + + // system enabled + // currently no way to figure out which attach produce which + // hci + if( m_deviceNr == -1 ) { + m_deviceNr = 0; + emit isEnabled( m_deviceNr, 1 ); + } + } +} + +void OTDevice::slotStdErr(OProcess* proc, char* chars, int len) { + + if(proc == m_hciattach && len >= 1 ){ + // collect output + QCString string( chars, len+1 ); // \0 == +1 + QString m_output; + m_output.append( string.data() ); + owarn << m_output << oendl; + } +} + +pid_t OTDevice::getPidOfHCIAttach( void ) { + + if( needsAttach() ) { + // not yet attached -> perhaps now ? + // load /proc dir and check if command name contains hciattach + QRegExp R("[0-9]+"); + QDir ProcDir( "/proc" ); + QFileInfo FI; + QStringList EL = ProcDir.entryList( QDir::Dirs ); + + // print it out + for ( QStringList::Iterator it = EL.begin(); + it != EL.end(); + ++it ) { + if( R.match( (*it) ) >= 0 ) { + // is pid + + // get command being executed + FI.setFile( ProcDir.path()+"/"+ (*it) + "/exe" ); + + // get the link + if( FI.readLink().right( 9 ) == "hciattach" ) { + // this is hci attach process + + return (*it).toULong(); + break; + } + } + } + } + + return 0; +} + +void OTDevice::detectDeviceType( QString & Device, + QString & Mode, + unsigned long & Speed ) { + + // detect device type and determine parms + owarn << "Detecting device" << oendl; + switch ( ODevice::inst()->model() ) { + case Model_iPAQ_H39xx: + Device = "/dev/tts/1"; + Mode = "bcsp"; + Speed = 921600; + NeedsAttach = 1; + break; + + case Model_iPAQ_H5xxx: + Device = "/dev/tts/1"; + Mode = "any"; + Speed = 921600; + NeedsAttach = 1; + break; + + case Model_GenuineIntel : + Device = ""; + Mode = ""; + Speed = 0; + NeedsAttach = 0; + break; + + default: + Device = "/dev/ttySB0"; + Mode = "bcsp"; + Speed = 230400; + NeedsAttach = 1; + break; + } +} + +QString OTDevice::getRFCommDevicePattern( void ) { + + QDir D( "/dev/bluetooth/rfcomm" ); + if( D.exists() ) { + // devfs + return QString( "/dev/bluetooth/rfcomm/%1" ); + } + + // regular 'dev' directory + return QString( "/dev/rfcomm%1" ); +} diff --git a/noncore/settings/networksettings2/opietooth2/OTDevice.h b/noncore/settings/networksettings2/opietooth2/OTDevice.h new file mode 100644 index 0000000..c2abb09 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTDevice.h @@ -0,0 +1,116 @@ +#ifndef OTDEVICE_H +#define OTDEVICE_H + +#include <qobject.h> +#include <qstring.h> + +#include <bluezlib.h> + +#include <OTGateway.h> + +// define if you want to use the process hciattach for detection +// #define USEHCIPROC + +class QTimerEvent; + +namespace Opie { + namespace Core { + class OProcess; + } +} + +namespace Opietooth2 { + + /** + * Device takes care of attaching serial + * devices to the blueZ stack. + * After attaching it hciconfig ups it + */ + class OTDevice : public QObject { + + Q_OBJECT + + public: + + /** + * Brings up the device. + * will detech which device is needed + * Usage example: new Device(/dev/ttySB0, csr) + * + */ + OTDevice( OTGateway * _OT ); + + /** + * unloads the device + */ + ~OTDevice(); + + inline OTGateway * gateway() const + { return OT; } + + inline bool needsAttach( void ) const + { return NeedsAttach; } + + inline int deviceNr() const + { return m_deviceNr; } + + /** + * attach the device + * @return bool which is TRUE if command started sucessfully + */ + bool attach(); + + /** + * detach the device + * @return bool which is TRUE if command started sucessfully + */ + bool detach(); + + /** + * Is the device loaded? + * @return bool, if the device is loaded + */ + bool isAttached()const; + + // check current state of attachment + bool checkAttach(); + + // returns pattern that points to the proper + // RFCOMM device file. Put %1 where device nr should be put + // e.g. : /dev/bluetooth/rfcomm/%1 or /def/rfcomm%1 + QString getRFCommDevicePattern(); + + signals: + + /** + * Signals if the attach/detach of the device produced + * errors + * @param Mesg contains an error message + */ + void error( const QString & mesg ); + void isEnabled( int devnr, bool ); + + private slots: + + void slotStdOut(Opie::Core::OProcess*, char*, int ); + void slotStdErr(Opie::Core::OProcess*, char*, int ); + + private: + + void detectDeviceType( QString & Device, + QString & Mode, + unsigned long & Speed ); + pid_t getPidOfHCIAttach( void ); + + Opie::Core::OProcess* m_hciattach; // ptr to hciattach proces + + int m_deviceNr; // x as in hci(x) + pid_t m_hciattachPid; // pid of hciattach program + + // backpointer + OTGateway * OT; + bool NeedsAttach; + }; +}; + +#endif diff --git a/noncore/settings/networksettings2/opietooth2/OTDeviceAddress.cpp b/noncore/settings/networksettings2/opietooth2/OTDeviceAddress.cpp new file mode 100644 index 0000000..7fbfaf4 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTDeviceAddress.cpp @@ -0,0 +1,110 @@ +//-*-c++-*- +/*************************************************************************** + * Copyright (C) 2003 by Fred Schaettgen * + * kdebluetooth@schaettgen.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#include <string.h> +#include <bluezlib.h> +#include <opie2/odebug.h> + +#include <OTDeviceAddress.h> + +using namespace Opietooth2; + +//const bdaddr_t OTDeviceAddress::bdaddr_any = {{0,0,0,0,0,0}}; +//const bdaddr_t OTDeviceAddress::bdaddr_local = {{0, 0, 0, 0xff, 0xff, 0xff}}; + +const OTDeviceAddress OTDeviceAddress::invalid = + OTDeviceAddress(); +const OTDeviceAddress OTDeviceAddress::any = + OTDeviceAddress("00:00:00:00:00:00"); +const OTDeviceAddress OTDeviceAddress::local = + OTDeviceAddress("00:00:00:FF:FF:FF"); + +OTDeviceAddress::OTDeviceAddress() { + + IsValid = false; + memset( &BDaddr, 0, sizeof( BDaddr ) ); +} + +OTDeviceAddress::OTDeviceAddress( const bdaddr_t& bdaddr, + bool networkbyteorder) { + setBDAddr( bdaddr, networkbyteorder ); +} + +OTDeviceAddress::OTDeviceAddress(const QString& s) { + + bdaddr_t a; + int ret = str2ba(s.latin1(), &a); + if (ret==0) { + IsValid = true; + bacpy( &BDaddr, &a ); + } else { + IsValid = false; + bacpy( &BDaddr, &(OTDeviceAddress::invalid.getBDAddr()) ) ; + } +} + +QString OTDeviceAddress::toString() const { + char addrbuf[20]; + ba2str(&BDaddr, addrbuf); + return QString(addrbuf); + +} + +void OTDeviceAddress::setBDAddr( const bdaddr_t& bdaddr, + bool networkbyteorder) { + if (networkbyteorder) { + baswap(&BDaddr, &bdaddr); + } else { + bacpy( &BDaddr, &bdaddr ); + } + IsValid = true; +} + +bdaddr_t OTDeviceAddress::getBDAddrInNetworkByteOrder(void) const { + bdaddr_t ret; + baswap(&ret, &BDaddr); + return ret; +} + +bool OTDeviceAddress::operator==(const OTDeviceAddress& b) const { + if ( ! IsValid && ! b.IsValid ) + return true; + return memcmp( &BDaddr, &(b.BDaddr), sizeof( b.BDaddr ) ) == 0; +} + +bool OTDeviceAddress::operator<(const OTDeviceAddress& b) const { + if ( ! IsValid && ! b.IsValid ) + return false; + else if ( ! IsValid && b.IsValid ) + return false; + else if ( IsValid && ! b.IsValid ) + return true; + + if (BDaddr.b[5] != b.BDaddr.b[5]) + return (BDaddr.b[5] < b.BDaddr.b[5]); + + if (BDaddr.b[4] != b.BDaddr.b[4]) + return (BDaddr.b[4] < b.BDaddr.b[4]); + + if (BDaddr.b[3] != b.BDaddr.b[3]) + return (BDaddr.b[3] < b.BDaddr.b[3]); + + if (BDaddr.b[2] != b.BDaddr.b[2]) + return (BDaddr.b[2] < b.BDaddr.b[2]); + + if (BDaddr.b[1] != b.BDaddr.b[1]) + return (BDaddr.b[1] < b.BDaddr.b[1]); + + if (BDaddr.b[0] != b.BDaddr.b[0]) + return (BDaddr.b[0] < b.BDaddr.b[0]); + + return false; +} diff --git a/noncore/settings/networksettings2/opietooth2/OTDeviceAddress.h b/noncore/settings/networksettings2/opietooth2/OTDeviceAddress.h new file mode 100644 index 0000000..8395f37 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTDeviceAddress.h @@ -0,0 +1,108 @@ +//-*-c++-*- +/*************************************************************************** + * Copyright (C) 2003 by Fred Schaettgen * + * kdebluetooth@0xF.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#ifndef OTDEVICEADDRESS_H +#define OTDEVICEADDRESS_H + +#include <qstring.h> +#include <bluezlib.h> + +namespace Opietooth2 { + +/** Represents a Bluetooth device address. + * This class allows easy conversion of Bluetooth addresses + * from and to strings. It also works with the bdaddr_t type + * used by BlueZ. + * The class offers a comparsion and less-than operator, so + * that it can be used a key in an STL map or similar. + * The string conversion functions of BlueZ are used internally, + * so the string format is the same than for BlueZ's ba2str(). + */ +class OTDeviceAddress { + +public: + + /** Default constructor. + The resulting address is equal to DeviceAddress::invalid. + */ + OTDeviceAddress(); + + /** Initialize the object with a BlueZ bdaddr_t. + @param bdaddr address + @param networkbyteorder if true, bdaddr is assumed to be in + network byte order and converted to host byte order first. + */ + explicit OTDeviceAddress( const bdaddr_t& bdaddr, + bool networkbyteorder = false + ); + + /** Initializes the object with an address given as a string. + The string must be in a format which is understood by the + BlueZ str2ba function, like 00:61:58:4C:E6:AD. Case doesn't matter. + @param s address string + */ + explicit OTDeviceAddress(const QString& s); + + /** convert the address to a string. + @return address string + */ + QString toString() const; + + /** Converts the DeviceAddress into a BlueZ bdaddr_t. + @param networkbyteorder if true, the address is returned + in network byte order. + @return the address as bdaddr_t + */ + inline const bdaddr_t & getBDAddr( void ) const + { return BDaddr; } + bdaddr_t getBDAddrInNetworkByteOrder() const; + void setBDAddr( const bdaddr_t& bdaddr, + bool networkbyteorder = false + ); + + /** Less-than-operator. + Mainly there to use DeviceAddress inside STL containers, + like STL sets or as a key in a STL map. + @param b the DeviceAddress to compare to (right hand side) + @return true if this < b, false otherwise. + */ + bool operator<(const OTDeviceAddress& b) const; + + /** Equality operator. + Tests two device addresses for equality. + @param b the DeviceAddress to compare to (right hand side) + @return true if this and b have the same address or + if both are invalid, false otherwise + */ + bool operator==(const OTDeviceAddress& b) const; + + inline bool operator!=(const OTDeviceAddress& b) const + { return ! ( *this == b ); } + + /** The address 00:00:00:FF:FF:FF */ + static const OTDeviceAddress local; + + /** The address 00:00:00:00:00:00 */ + static const OTDeviceAddress any; + + /** An address tagged as invalid */ + static const OTDeviceAddress invalid; + +protected: + + bdaddr_t BDaddr; + bool IsValid; + +}; + +} + +#endif diff --git a/noncore/settings/networksettings2/opietooth2/OTDriver.cpp b/noncore/settings/networksettings2/opietooth2/OTDriver.cpp new file mode 100644 index 0000000..8bd7919 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTDriver.cpp @@ -0,0 +1,744 @@ +/*************************************************************************** + * Copyright (C) 2003 by Mattia Merzi * + * ottobit@ferrara.linux.it * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#include <opie2/odebug.h> +#include <qtimer.h> + +#include <sys/poll.h> +#include <bluezlib.h> + +#include <OTGateway.h> +#include <OTDriver.h> +#include <OTHCISocket.h> + +using namespace Opietooth2; + +static struct { + const char *str; + unsigned short rev; +} csr_map[] = { + { "HCI 11.2 (bc01b)", 114 }, + { "HCI 11.3 (bc01b)", 115 }, + { "HCI 12.1 (bc01b)", 119 }, + { "HCI 12.3 (bc01b)", 134 }, + { "HCI 12.7 (bc01b)", 188 }, + { "HCI 12.8 (bc01b)", 218 }, + { "HCI 12.9 (bc01b)", 283 }, + { "HCI 13.10 (bc01b)", 309 }, + { "HCI 13.11 (bc01b)", 351 }, + { "HCI 16.4 (bc01b)", 523 }, + { "HCI 14.3 (bc02x)", 272 }, + { "HCI 14.6 (bc02x)", 336 }, + { "HCI 14.7 (bc02x)", 373 }, + { "HCI 14.8 (bc02x)", 487 }, + { "HCI 15.3 (bc02x)", 443 }, + { "HCI 16.4 (bc02x)", 525 }, + { NULL, 0} +}; + +static char *services[] = { "Positioning", + "Networking", + "Rendering", + "Capturing", + "Object Transfer", + "Audio", + "Telephony", + "Information" }; + +static char *major_devices[] = { "Miscellaneous", + "Computer", + "Phone", + "LAN Access", + "Audio/Video", + "Peripheral", + "Imaging", + "Uncategorized" }; + + +typedef struct { + short Minor; + const char * Description; +} ClassMap_t; + +static ClassMap_t MapMiscClass[] = { + { -1, "" } +}; + +static ClassMap_t MapUnclassifiedClass[] = { + { -1, "" } +}; + +static ClassMap_t MapComputerClass[] = { + { 0, "Uncategorized" } , + { 1, "Desktop workstation" } , + { 2, "Server" } , + { 3, "Laptop" } , + { 4, "Handheld" } , + { 5, "Palm" } , + { 6, "Wearable" }, + { -1, 0 } +}; + +static ClassMap_t MapPhoneClass[] = { + { 0, "Uncategorized" }, + { 1, "Cellular" }, + { 2, "Cordless" }, + { 3, "Smart phone" }, + { 4, "Wired modem or voice gateway" }, + { 5, "Common ISDN Access" }, + { 6, "Sim Card Reader" }, + { -1, 0 } +}; + +static ClassMap_t MapAVClass[] = { + { 0, "Uncategorized" }, + { 1, "Device conforms to the Headset profile" }, + { 2, "Hands-free" }, + { 3, 0 }, + { 4, "Microphone" }, + { 5, "Loudspeaker" }, + { 6, "Headphones" }, + { 7, "Portable Audio" }, + { 8, "Car Audio" }, + { 9, "Set-top box" }, + { 10, "HiFi Audio Device" }, + { 11, "VCR" }, + { 12, "Video Camera" }, + { 13, "Camcorder" }, + { 14, "Video Monitor" }, + { 15, "Video Display and Loudspeaker" }, + { 16, "Video Conferencing" }, + { 17, 0 }, + { 18, "Gaming/Toy" }, + { -1, 0 } +}; + +static ClassMap_t MapPeripheralClass[] = { + { 16, "Keyboard" }, + { 32, "Pointing device" }, + { 48, "Combo keyboard/pointing device" }, + { -1, 0 } +}; + +typedef struct { + int Major; + ClassMap_t * Map; +} MainClassMap_t; + +static MainClassMap_t MainClasses[] = { + { 0, MapMiscClass }, + { 1, MapComputerClass }, + { 2, MapPhoneClass }, + { 3, 0 }, // special case + { 4, MapAVClass }, + { 5, MapPeripheralClass }, + { 6, 0 }, // special case + { 63, MapUnclassifiedClass }, + { -1, 0 } +}; + +OTDriver::OTDriver( OTGateway * _OT, struct hci_dev_info* di) : QObject( _OT ), Address() { + OT = _OT; + IsUp = 0; + Socket = 0; + + init(di); + owarn << "Driver " << devname() << oendl; + + AutoClose = new QTimer( this ); + connect( AutoClose, + SIGNAL( timeout() ), + this, + SLOT( SLOT_CloseFd() ) + ); +} + +OTDriver::~OTDriver() { + closeSocket(); + SLOT_CloseFd(); +} + +void OTDriver::SLOT_CloseFd( void ){ + if ( isOpen() ) { + AutoClose->stop(); + ::close( fd() ); + setfd( -1 ); + } +} + +void OTDriver::init(struct hci_dev_info* di) { + + Dev = di->name; + + setDevId(di->dev_id); + setType(di->type); + setFlags(di->flags); + Address.setBDAddr( di->bdaddr ); + setFeatures(di->features); + setfd( -1 ); // not open + + Manufacturer = ""; +} + +// internal reinitialize +void OTDriver::reinit() { + bool Old; + Old = IsUp; + + if( currentState() < 0 ) + return; + + if( Old != IsUp ) { + // state changes + emit stateChange( this, IsUp ); + } +} + +// requested by application +int OTDriver::currentState() { + struct hci_dev_info di; + + // uint16_t tmp_dev_id = device_info.dev_id; + // bzero(&device_info,sizeof(struct hci_dev_info)); + // device_info.dev_id = tmp_dev_id; + + memset( &di, 0, sizeof( di ) ); + di.dev_id = Dev_id; + if( ioctl( OT->getSocket(), HCIGETDEVINFO, (void*)&di) < 0 ) { + SLOT_CloseFd(); + return -1; + } else { + // load new info + init(&di); + } + + return IsUp; +} + +bool OTDriver::open() { + + // (re)start single shot close + AutoClose->start( 30000, TRUE ); + + if( isOpen() ) + // is open + return 1; + + setfd(hci_open_dev(devId())); + + if (fd() < 0) { + emit error( tr( "Can't open device %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) + ); + return 0; + } + + return 1; +} + +QString OTDriver::name() { + char name[1000]; + + if( ! open() ) { + return tr("Cannot open"); + } + + if (hci_read_local_name( fd(), sizeof(name), name, 1000) < 0) { + if (errno != ETIMEDOUT) { + emit error( tr("Can't read local name on %1. %2 : %3. Default to %4" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ). + arg( devname() ) + ); + } // ETIMEDOUT error is quite normal, device is down ... I think ! :) + strcpy(name,devname().latin1()); + } + return QString(name); +} + +void OTDriver::setFlags(unsigned long flags) { + + // kdDebug() << "Setting OTDriver Values ..." << endl; + IsUp = BTVALUE(hci_test_bit(HCI_UP, &flags)); + + if (isUp()) { + setIScan(BTVALUE(hci_test_bit(HCI_ISCAN, &flags))); + setPScan(BTVALUE(hci_test_bit(HCI_PSCAN, &flags))); + setAuthentication(BTVALUE(hci_test_bit(HCI_AUTH, &flags))); + setEncryption(BTVALUE(hci_test_bit(HCI_ENCRYPT, &flags))); + } else { + setIScan(BT_UNKNOWN); + setPScan(BT_UNKNOWN); + setAuthentication(BT_UNKNOWN); + setEncryption(BT_UNKNOWN); + } +} + +QString OTDriver::revision() { + + struct hci_version ver; + + if( ! open() ) { + return tr("Cannot open"); + } + + if (hci_read_local_version(fd(), &ver, 1000) < 0) { + emit error( tr( "Can't read revision info on %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + return QString(); + } + + setManufacturer(ver.manufacturer); + + switch (ver.manufacturer) { + case 0: + return getRevEricsson(); + break; + case 10: + return getRevCsr(ver.hci_rev); + break; + default: + return tr( "Unsupported manufacturer" ); + break; + } +} + +QString OTDriver::getRevEricsson() { + + char revision[102]; + struct hci_request rq; + + if( ! open() ) { + return QString( "Cannot open" ); + } + + memset(&rq, 0, sizeof(rq)); + rq.ogf = 0x3f; + rq.ocf = 0x000f; + rq.cparam = NULL; + rq.clen = 0; + rq.rparam = &revision; + rq.rlen = sizeof(revision); + + if (hci_send_req(fd(), &rq, 1000) < 0) { + emit error( tr( "Can't read revision info on %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + return QString(); + } + + return QString( revision+1 ); +} + +QString OTDriver::getRevCsr( unsigned short rev) { + + int i; + + for (i = 0; csr_map[i].str; i++) + if (csr_map[i].rev == rev) { + return QString( csr_map[i].str ); + } + + return tr( "Unknown firmware" ); +} + +int OTDriver::reset() { + + if( ! open() ) { + return 0; + } + + if( ioctl(fd(), HCIDEVRESET, devId()) < 0 ) { + if( errno != EALREADY ) { + emit error( tr( "Reset failed for %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + if (errno == EACCES) { + return EACCES; + } + } + } + return 0; +} + +void OTDriver::setUp( bool M ) { + if( M && ! isUp() ) { + bringUp(); + } else if( ! M && isUp() ) { + bringDown(); + } +} + +void OTDriver::bringUp() { + + owarn << "bringUp : " << Dev << oendl; + + if( ! open() ) { + return; + } + + if (! isUp()) { + if( ioctl(fd(), HCIDEVUP, devId()) < 0 ) { + if( errno != EALREADY ) { + emit error( tr( "Cannot bring interface %1 up. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + } + return; + } + // have to wait a bit for the 'up' to become active + QTimer::singleShot( 3000, this, SLOT( reinit() ) ); + } +} + +void OTDriver::bringDown() { + + owarn << "bringDown : " << Dev << oendl; + + if( ! open() ) { + return; + } + + if ( isUp() ) { + if( ioctl(fd(), HCIDEVDOWN, devId()) < 0 ) { + if( errno != EALREADY ) { + emit error( tr( "Cannot bring interface %1 down. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + } + return; + } + reinit(); + } +} + +void OTDriver::setScanMode(bool iscan, bool pscan) { + + struct hci_dev_req dr; + + if( ! open() ) { + return; + } + + dr.dev_id = devId(); + dr.dev_opt = SCAN_DISABLED; + + if( iscan&&(!pscan) ) + dr.dev_opt = SCAN_INQUIRY; + else if( pscan&&(!iscan) ) + dr.dev_opt = SCAN_PAGE; + else if( pscan&&iscan ) + dr.dev_opt = SCAN_PAGE | SCAN_INQUIRY; + + if( ioctl(fd(), HCISETSCAN, (unsigned long)&dr) < 0 ) { + if( errno != EALREADY ) { + emit error( tr( "Can't set scan mode on %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + } + return; + } + + reinit(); +} + +void OTDriver::changeDevName(const char* name) { + + if( ! open() ) { + return; + } + + if (hci_write_local_name(fd(), name, 1000) < 0) { + emit error( tr( "Can't change local name on %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + } +} + +void OTDriver::changeAuthentication(bool _auth) { + struct hci_dev_req dr; + + if( ! open() ) { + return; + } + + dr.dev_id = devId(); + dr.dev_opt = _auth?AUTH_ENABLED:AUTH_DISABLED; + + if (ioctl(fd(),HCISETAUTH,(unsigned long)&dr) < 0) { + if( errno != EALREADY ) { + emit error( tr( "Can't change authentication on %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + } + return; + } + reinit(); +} + +void OTDriver::changeEncryption(bool _encrypt) { + struct hci_dev_req dr; + + if( ! open() ) { + return; + } + + dr.dev_id = devId(); + dr.dev_opt = _encrypt?ENCRYPT_P2P:ENCRYPT_DISABLED; + + if (ioctl(fd(),HCISETENCRYPT,(unsigned long)&dr) < 0) { + if( errno != EALREADY ) { + emit error( tr( "Can't change encryption on %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + } + return; + } + + reinit(); +} + +void OTDriver::changeClass ( unsigned char service, + unsigned char major, + unsigned char minor ) { + unsigned long cod = 0; + cod = (service << 16) | + (major << 8) | + (minor ) ; + + if( ! open() ) { + return; + } + + if ( hci_write_class_of_dev(fd(),cod,1000) < 0 ) { + emit error( tr( "Can't change class informations for %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + return; + } +} + +void OTDriver::getClass( QString & service, + QString & device ) { + unsigned char cls[3]; + + if( ! open() ) { + return; + } + + if ( hci_read_class_of_dev(fd(),cls,1000) < 0 ) { + emit error( tr( "Can't read class information for %1. %2 : %3" ). + arg( devname() ). + arg( errno ). + arg( strerror(errno) ) ); + return; + } + + if( cls[2] ) { + int first = 1; + for ( unsigned int s = 0; s < sizeof(*services); s++) { + if (cls[2] & (1 << s)) { + if( !first ) + service += ", "; + service += services[s]; + first = 0; + } + } + } else { + service = "unspecified"; + } + + MainClassMap_t * MCM = MainClasses; + int major = cls[1] & 0x1f; + int minor = cls[0] >> 2; + + if( (unsigned)(cls[1] & 0x1f) > sizeof(*major_devices)) { + device = tr("Invalid Device Class"); + return; + } + + device = major_devices[cls[1] & 0x1f]; + + while( MCM->Major != -1 ) { + if( major == MCM->Major ) { + // this class + ClassMap_t * CM = MCM->Map; + if( MCM->Map ) { + while( CM->Minor != -1 ) { + if( minor == CM->Minor ) { + break; + } + CM ++; + } + device = CM->Description; + } else { + // special case + if( major == 3 ) { + /* lan access */ + if( minor == 0 ) { + device = "Uncategorized"; + } else { + switch( minor / 8 ) { + case 0: + device = "Fully available"; + break; + case 1: + device = "1-17% utilized"; + break; + case 2: + device = "17-33% utilized"; + break; + case 3: + device = "33-50% utilized"; + break; + case 4: + device = "50-67% utilized"; + break; + case 5: + device = "67-83% utilized"; + break; + case 6: + device = "83-99% utilized"; + break; + case 7: + device = "No service available"; + break; + } + } + } else if( major == 6 ) { /* imaging */ + if (minor & 4) + device = "Display"; + if (minor & 8) + device = "Camera"; + if (minor & 16) + device = "Scanner"; + if (minor & 32) + device = "Printer"; + } + } + break; + } + MCM ++; + } + + if( MCM->Major == -1 ) { + device = "Unknown (reserved) minor device class"; + } +} + +QString OTDriver::strType() { + return QString( hci_dtypetostr(Type) ); +} + +void OTDriver::setFeatures( unsigned char * _f) { + Features = lmp_featurestostr(_f, NULL, 255); +} + +void OTDriver::setManufacturer(int compid) { + Manufacturer = bt_compidtostr(compid); +} + +OTHCISocket * OTDriver::openSocket( void ) { + if( ! Socket ) { + owarn << "Open HCI socket to " << devname() << oendl; + Socket = new OTHCISocket( this ); + } + return Socket; +} + +void OTDriver::closeSocket( void ) { + if( Socket ) { + owarn << "Close HCI socket to " << devname() << oendl; + delete Socket; + Socket = 0; + } +} + +QString OTDriver::getPeerName( const OTDeviceAddress & PAddr ) { + QString S; + char name[100 ]; + + if( ! open() ) { + return QString("N/A"); + } + + if( hci_read_remote_name( fd(), + &(PAddr.getBDAddr()), + sizeof(name), + name, + 100000 ) < 0 ) { + return QString( "N/A" ); + } + + return QString( name ); +} + +long OTDriver::getLinkQuality( const OTDeviceAddress & Addr ) { + struct hci_conn_info_req *cr; + struct hci_request rq; + read_rssi_rp rp; + uint16_t handle; + + if( ! open() ) { + return 0; + } + + cr = (struct hci_conn_info_req *)malloc( + sizeof(*cr) + sizeof(struct hci_conn_info)); + if (!cr) + return 0; + + bacpy( &(cr->bdaddr), &(Addr.getBDAddr()) ); + cr->type = ACL_LINK; + + if (ioctl( fd(), HCIGETCONNINFO, (unsigned long) cr) < 0) { + owarn << "Get connection info failed" << oendl; + free(cr); + return 0; + } + + handle = htobs(cr->conn_info->handle); + + free(cr); + + memset(&rq, 0, sizeof(rq)); + rq.ogf = OGF_STATUS_PARAM; + rq.ocf = OCF_READ_RSSI; + rq.cparam = &handle; + rq.clen = 2; + rq.rparam = &rp; + rq.rlen = GET_LINK_QUALITY_RP_SIZE; + + if (hci_send_req( fd(), &rq, 100) < 0) { + owarn << "Get connection info failed" << oendl; + return 0; + } + + if( rp.status ) { + owarn << QString().sprintf("HCI get_link_quality cmd failed (0x%2.2X)", rp.status) << oendl; + return 0; + } + + return rp.rssi+50; +} diff --git a/noncore/settings/networksettings2/opietooth2/OTDriver.h b/noncore/settings/networksettings2/opietooth2/OTDriver.h new file mode 100644 index 0000000..b54ffdf --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTDriver.h @@ -0,0 +1,232 @@ +/*************************************************************************** + * Copyright (C) 2003 by Mattia Merzi * + * ottobit@ferrara.linux.it * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#ifndef OTDRIVER_H +#define OTDRIVER_H + +/* + * This class handles the connection with the BlueZ libraries, implements + * most of the bluetooth-related functions and owns the KBTDevice class + * that is a single local bluetooth device representation. + * It is used as a Singleton pattern thru the getDefaultConnector() method. + * + */ +#include <qobject.h> +#include <opie2/odebug.h> +#include <bluezlib.h> + +#include <OTDeviceAddress.h> + +namespace Opietooth2 { + +class OTGateway; +class OTHCISocket; +class OTDeviceAddress; +class OTPeer; + +/* + * This is the representation of a + * Bluetooth device for the local + * machine. + */ +class OTDriver : public QObject { + + Q_OBJECT + +public: + + OTDriver( OTGateway * Ot, struct hci_dev_info* di); + ~OTDriver(); + + inline OTGateway * gateway() const + { return OT; } + + /* + * Initializes the device using the passed hci_dev_info + * struct, contining the basic information in order to + * talk with the pyisical device. + */ + void init(struct hci_dev_info* di); + + /* + * Open the device and obtains a file descriptor to id + * return if open + */ + bool open(); + + OTHCISocket * openSocket(); + + void closeSocket(); + + /* + * Return true if the device is opened. + */ + int isOpen() + { return Fd != -1; }; + + /* + * Calls the ioctl(HCIDEVRESET) in order to + * reset the device. + */ + int reset(); + + // set Up if true and not yet up + void setUp( bool Mode ); + + /* + * Turn the device up and the reinitializes the device. + * If the device is already up, nothing is done. + */ + void bringUp(); + + /* + * Turn the device down and the reinitializes the device. + * If the device is already down, nothing is done. + */ + void bringDown(); + + // is the device UP now + bool isUp() const + { return IsUp; } + + // get current state + // return 1 if UP, 0 if DOWN, -1 if ERROR + int currentState(); + + /* + * Returns the name of the device. If the device is + * down, the device id is returned. + */ + QString name(); + + int devId() const + { return Dev_id; }; + + /* + * Returns the string representation of the device id, + * with the same format of the hciconfig tool. + */ + QString devname() + { return Dev; }; + + /* + * Returns the file descriptor for the local + * connection to this device + */ + int fd() const + { return Fd; }; + void setfd(int _fd) + { Fd = _fd; }; + + void setType(int _type) + { Type = _type; }; + int type() const + { return Type; }; + QString strType(); + + int iscan() const + { return Iscan; } + void setIScan(int _iscan) + { Iscan = _iscan; } + + int pscan() const + { return Pscan; } + void setPScan(int _pscan) + { Pscan = _pscan; } + + int authentication() const + { return Auth; } + void setAuthentication(int _auth) + { Auth = _auth; } + + int encryption() const + { return Encrypt; } + void setEncryption(int _encrypt) + { Encrypt = _encrypt; } + + void setDevId(int _dev_id) + { Dev_id = _dev_id; }; + void setDev(char* _dev) + { Dev = _dev; }; + + void setFlags( unsigned long flags); + + const OTDeviceAddress & address() + { return Address; } + + void setFeatures( unsigned char * _f); + QString features() + { return Features; } + + void setManufacturer(int compid); + QString manufacturer() + { return Manufacturer; } + + QString revision(); + + void setScanMode(bool iscan, bool pscan); + void setClass(unsigned long cls); + + void changeDevName(const char* name); + void changeEncryption(bool _encryption); + void changeAuthentication(bool _auth); + + void getClass( QString & service, + QString & device ); + void changeClass( unsigned char service, + unsigned char major, + unsigned char minor); + + QString getPeerName( const OTDeviceAddress & PAddr ); + + // address must be connected to this driver + long getLinkQuality( const OTDeviceAddress & Address ); + +signals : + + void error( const QString & ); + void stateChange( OTDriver * , bool ); + void driverDisappeared( OTDriver * ); + +private slots : + + /* + * Reinitializes the device, obtaining a fresh + * hci_dev_info structure. + */ + void reinit(); + void SLOT_CloseFd(); + +private: + + QString getRevEricsson(); + QString getRevCsr(unsigned short rev); + + QString Name; + QString Dev; + QString Revision; + QString Manufacturer; + OTDeviceAddress Address; + QString Features; + QTimer * AutoClose; + + int Dev_id,Fd,Type; + bool IsUp; + int Iscan,Pscan,Auth,Encrypt; + + // socket bound to this device + OTHCISocket * Socket; + + // backpointer to opietooth system + OTGateway * OT; +}; + +} +#endif diff --git a/noncore/settings/networksettings2/opietooth2/OTDriverList.cpp b/noncore/settings/networksettings2/opietooth2/OTDriverList.cpp new file mode 100644 index 0000000..f703834 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTDriverList.cpp @@ -0,0 +1,86 @@ +/*************************************************************************** + * Copyright (C) 2003 by Mattia Merzi * + * ottobit@ferrara.linux.it * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#include <malloc.h> +#include <bluezlib.h> + +#include <opie2/odebug.h> + +#include <OTDriverList.h> +#include <OTGateway.h> +#include <OTDriver.h> + +using namespace Opietooth2; + +OTDriverList::OTDriverList( OTGateway * _OT ) : QVector<OTDriver>() { + + OT = _OT; + setAutoDelete( true ); +} + +OTDriverList::~OTDriverList() { +} + +void OTDriverList::update() { + + struct hci_dev_list_req *dl; + struct hci_dev_req *dr; + struct hci_dev_info di; + int cur; + + dl = 0; + cur = 0; + do { + cur += 5; + + dl = (struct hci_dev_list_req*) + ::realloc( dl, sizeof( struct hci_dev_list_req ) + + ( cur * sizeof(struct hci_dev_req) ) + ); + + if( dl == 0 ) { + // memory problem + exit(1); + } + + dl->dev_num = cur; + + if( ioctl( OT->getSocket(), HCIGETDEVLIST, (void*)dl) ) { + owarn << "WARNING : cannot read device list. " + << errno + << strerror( errno ) << oendl; + return; + } + + // if num == cur perhaps we did not get all devices yet + } while( dl->dev_num == cur ); + + if( dl->dev_num != count() ) { + // new or missing devices + clear(); + + dr = dl->dev_req; + resize( dl->dev_num ); + + for( cur=0; cur < dl->dev_num; cur ++) { + memset( &di, 0, sizeof( di ) ); + di.dev_id = (dr+cur)->dev_id; + + // get device info + if( ioctl( OT->getSocket(), HCIGETDEVINFO, (void*)&di) != 0 ) + continue; // uh ? + insert( cur, new OTDriver( OT, &di ) ); + } + + owarn << "Found " << count() << " devices" << oendl; + + ::free( dl ); + } +} diff --git a/noncore/settings/networksettings2/opietooth2/OTDriverList.h b/noncore/settings/networksettings2/opietooth2/OTDriverList.h new file mode 100644 index 0000000..c98ffa0 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTDriverList.h @@ -0,0 +1,40 @@ +/*************************************************************************** + * Copyright (C) 2003 by Mattia Merzi * + * ottobit@ferrara.linux.it * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#ifndef OTDRIVERLIST_H +#define OTDRIVERLIST_H + +#include <qvector.h> + +namespace Opietooth2 { + +class OTDriver; +class OTGateway; + +class OTDriverList : public QVector<OTDriver> { + +public: + + OTDriverList( OTGateway * _OT ); + ~OTDriverList(); + + inline OTGateway * gateway() const + { return OT; } + + void update(); + +private: + + // backpointer + OTGateway * OT; +}; + +} +#endif diff --git a/noncore/settings/networksettings2/opietooth2/OTGateway.cpp b/noncore/settings/networksettings2/opietooth2/OTGateway.cpp new file mode 100644 index 0000000..2d13ce9 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTGateway.cpp @@ -0,0 +1,773 @@ +#include <qmessagebox.h> +#include <qfile.h> +#include <qdir.h> +#include <qtextstream.h> +#include <qpixmap.h> +#include <qvector.h> +#include <qpe/resource.h> + +#include <opie2/odebug.h> + +#include <bluezlib.h> + +#include <OTDevice.h> +#include <OTDriver.h> +#include <OTInquiry.h> +#include <OTDriverList.h> +#include <OTDeviceAddress.h> +#include <OTGateway.h> + +using namespace Opietooth2; + +// single instance +OTGateway * OTGateway::SingleGateway = 0; +int OTGateway::UseCount = 0; + +OTGateway * OTGateway::getOTGateway( void ) { + if(SingleGateway == 0 ) { + SingleGateway = new OTGateway(); + } + + UseCount ++; + return SingleGateway; +} + +void OTGateway::releaseOTGateway( void ) { + UseCount --; + if( UseCount == 0 ) { + delete SingleGateway; + SingleGateway = 0; + } +} + +// open bluetooth system +OTGateway::OTGateway( void ) : QObject( 0, "OTGateway" ), + AllDrivers( this ), + AllPeers() { + + ErrorConnectCount = 0; + TheOTDevice = 0; + Scanning = 0; + AllPeersModified = 0; + AllPeers.setAutoDelete( TRUE ); + + if ( ( HciCtl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI)) < 0) { + SLOT_ShowError( tr( "error opening hci socket" ) ); + return; + } + + // load all known devices + updateDrivers(); + + // load all peers we have ever seen + loadKnownPeers(); + + // iterate over drivers and find active connections + // adding/updating peers + loadActiveConnections(); + + // check every 4 seconds the state of BT + timerEvent(0); + RefreshTimer = -1; + setRefreshTimer( 4000 ); + + // load known link keys + readLinkKeys(); +} + +// close bluetooth system +OTGateway::~OTGateway( void ) { + + if( AllPeersModified ) { + saveKnownPeers(); + } + + if( Scanning ) + delete Scanning; + + if( TheOTDevice ) + delete TheOTDevice; + + if( HciCtl >= 0 ) { + ::close( HciCtl ); + } +} + +void OTGateway::setRefreshTimer( int T ) { + if( RefreshTimer != -1 ) { + killTimer( RefreshTimer ); + } + + if( T == 0 ) + T = 4000; + RefreshTimer = startTimer( T ); +} + +OTDevice * OTGateway::getOTDevice( ) { + if( TheOTDevice == 0 ) { + // load bluetooth device and check state + TheOTDevice = new OTDevice( this ); + connect( TheOTDevice, + SIGNAL( isEnabled( int, bool ) ), + this, + SLOT( SLOT_Enabled( int, bool ) ) ); + + connect( TheOTDevice, + SIGNAL( error( const QString & ) ), + this, + SLOT( SLOT_ShowError( const QString & ) ) ); + } + + return TheOTDevice; +} + +// start bluetooth (if stopped) +// return TRUE if started +void OTGateway::SLOT_SetEnabled( bool Mode ) { + if( Mode ) { + SLOT_Enable(); + return; + } + SLOT_Disable(); +} + +void OTGateway::SLOT_Enable() { + getOTDevice()->attach(); +} + +void OTGateway::SLOT_Disable() { + getOTDevice()->detach(); +} + +bool OTGateway::needsEnabling() { + return getOTDevice()->needsAttach(); +} + +bool OTGateway::isEnabled() { + if( getOTDevice()->deviceNr() >= 0 && + driver( getOTDevice()->deviceNr() )->isUp() ) + return TRUE; + + // else check system + return getOTDevice()->isAttached(); +} + +void OTGateway::SLOT_ShowError( const QString & S ) { + + owarn << S << oendl; + + if( ErrorConnectCount > 0 ) { + // pass error + emit error( QString( "<p>" ) + S + "</p>" ); + return; + } + + QMessageBox::warning( 0, + tr("OTGateway error"), + S ); +} + +void OTGateway::connectNotify( const char * S ) { + if( strcmp( S, "error(const QString&)" ) == 0 ) { + ErrorConnectCount ++; + } +} + +void OTGateway::disconnectNotify( const char * S ) { + if( strcmp( S, "error(const QString&)" ) == 0 ) { + ErrorConnectCount --; + } +} + +void OTGateway::timerEvent( QTimerEvent * ) { + + OTDriver * D; + unsigned int oldc = AllDrivers.count(); + bool old; + + AllDrivers.update(); + + if( oldc != AllDrivers.count() ) { + updateDrivers(); + } else { + for( unsigned int i = 0; + i < AllDrivers.count(); + i ++ ) { + D = AllDrivers[i]; + old = D->isUp(); + if( D->currentState() >= 0 ) { + if( old != D->isUp() ) { + emit stateChange( D, D->isUp() ); + } + } else { + // if one driver is unable to provide info + // we refresh all devices + updateDrivers(); + return; + } + } + } +} + +void OTGateway::SLOT_Enabled( int id, bool Up ) { + owarn << "device " << id << " state " << Up << oendl; + if( Up ) { + // device is up -> detect it + updateDrivers(); + if( (unsigned)id >= AllDrivers.count() ) { + // to make sure that the driver really IS detected + AllDrivers[id]->bringUp(); + } + } // if DOWN device already down + emit deviceEnabled( Up ); +} + +void OTGateway::updateDrivers( void ) { + OTDriver * D; + + AllDrivers.update(); + + owarn << "updated drivers. now " << AllDrivers.count() << oendl; + + // connect signals for each driver + for( unsigned int i = 0; + i < AllDrivers.count(); + i ++ ) { + D = AllDrivers[i]; + + connect( D, + SIGNAL( error( const QString & ) ), + this, + SLOT( SLOT_ShowError( const QString & ) ) + ); + + connect( D, + SIGNAL( stateChange( OTDriver *, bool ) ), + this, + SIGNAL( stateChange( OTDriver *, bool ) ) + ); + + connect( D, + SIGNAL( driverDisappeared( OTDriver * ) ), + this, + SLOT( SLOT_DriverDisappeared( OTDriver * ) ) + ); + } + + // verify main device too + if( TheOTDevice ) + TheOTDevice->checkAttach(); + + // set to default scanning hardware + setScanWith( 0 ); + + emit driverListChanged(); +} + +void OTGateway::SLOT_DriverDisappeared( OTDriver * D ) { + owarn << "Driver " << D->devname() << " when offline" << oendl; + updateDrivers(); +} + +void OTGateway::scanNeighbourhood( OTDriver * D ) { + + if( Scanning ) { + stopScanOfNeighbourhood(); + } + + if( D ) { + setScanWith( D ); + } + + Scanning = new OTInquiry( scanWith() ); + + connect( Scanning, + SIGNAL( peerFound( OTPeer *, bool )), + this, + SLOT( SLOT_PeerDetected( OTPeer *, bool ) ) + ); + connect( Scanning, + SIGNAL( finished()), + this, + SLOT( SLOT_FinishedDetecting() ) + ); + + // start scanning + Scanning->inquire( 30.0 ); +} + +OTPeer* OTGateway::findPeer( const OTDeviceAddress & Addr ) { + for( unsigned int i = 0 ; i < AllPeers.count(); i ++ ) { + if( AllPeers[i]->address() == Addr ) { + return AllPeers[i]; + } + } + return 0; +} + +OTDriver* OTGateway::findDriver( const OTDeviceAddress & Addr ) { + for( unsigned int i = 0 ; i < AllDrivers.count(); i ++ ) { + if( AllDrivers[i]->address() == Addr ) { + return AllDrivers[i]; + } + } + return 0; +} + +void OTGateway::SLOT_PeerDetected( OTPeer * P, bool IsNew ) { + + if( IsNew ) { + // new peer + owarn << "New peer " << P->name() << oendl; + addPeer( P ); + } + + emit detectedPeer( P, IsNew ); +} + +void OTGateway::addPeer( OTPeer * P ) { + AllPeers.resize( AllPeers.size()+1); + AllPeers.insert( AllPeers.size()-1, P ); + AllPeersModified = 1; +} + +void OTGateway::removePeer( OTPeer * P ) { + int i = AllPeers.find( P ); + if( i ) { + AllPeers.remove( i ); + AllPeersModified = 1; + } +} + +void OTGateway::stopScanOfNeighbourhood( void ) { + if( Scanning ) { + delete Scanning; + Scanning = 0; + } +} + +void OTGateway::SLOT_FinishedDetecting() { + stopScanOfNeighbourhood(); + emit finishedDetecting(); +} + +const char * OTGateway::deviceTypeToName( int cls ) { + switch ( (cls & 0x001F00) >> 8) { + case 0x00: + return "misc"; + case 0x01: + return "computer"; + case 0x02: + return "phone"; + case 0x03: + return "lan"; + case 0x04: + return "av"; + case 0x05: + return "peripheral"; + case 0x06: + return "imaging"; + case 0x07: + default : + break; + } + return "unknown"; +} + +PANConnectionVector OTGateway::getPANConnections( void ) { + PANConnectionVector V; + + struct bnep_connlist_req req; + struct bnep_conninfo ci[48]; + + V.setAutoDelete(TRUE); + + int ctl = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_BNEP); + if (ctl < 0) { + owarn << "Failed to open control socket" << oendl; + return V; + } + + req.cnum = 48; + req.ci = ci; + if (ioctl(ctl, BNEPGETCONNLIST, &req)) { + owarn << "Failed to get connection list" << oendl; + ::close( ctl ); + return V; + } + + for ( unsigned i=0; i < req.cnum; i++) { + V.resize( V.size() + 1 ); + if( ci[i].role == BNEP_SVC_PANU ) { + // we are the client + V.insert( V.size()-1, new OTPANConnection( + ci[i].device, + batostr((bdaddr_t *) ci[i].dst) + ) ); + } + } + + ::close( ctl ); + return V; +} + +struct link_key { + bdaddr_t sba; + bdaddr_t dba; + uint8_t key[16]; + uint8_t type; + time_t time; +}; + +void OTGateway::readLinkKeys( void ) { + + struct link_key k; + int rv; + + AllKeys.truncate(0); + + QFile F( "/etc/bluetooth/link_key" ); + + if( ! F.open( IO_ReadOnly ) ) { + emit error( tr("Cannot open link_key file") ); + return; + } + + while( 1 ) { + rv = F.readBlock( (char *)&k, sizeof( k ) ); + if( rv == 0 ) + // EOF + break; + + if( rv < 0 ) { + emit error( tr("Read error in link key file") ); + } + + AllKeys.resize( AllKeys.size()+1 ); + AllKeys[ AllKeys.size()-1 ].From.setBDAddr( k.sba ); + AllKeys[ AllKeys.size()-1 ].To.setBDAddr( k.dba ); + } +} + +bool OTGateway::removeLinkKey( unsigned int Index ) { + OTLinkKey & LK = AllKeys[Index]; + + struct link_key k; + int rv; + + QFile F( "/etc/bluetooth/link_key" ); + QFile OutF( "/etc/bluetooth/newlink_key" ); + + if( ! F.open( IO_ReadOnly ) ) { + emit error( tr("Cannot open link_key file") ); + return 0; + } + + if( ! OutF.open( IO_WriteOnly | IO_Truncate ) ) { + emit error( tr("Cannot open temporary link_key file") ); + return 0; + } + + while( 1 ) { + rv = F.readBlock( (char *)&k, sizeof( k ) ); + if( rv == 0 ) + // EOF + break; + + if( rv < 0 ) { + emit error( tr("Read error in link key file") ); + return 0; + } + + if( LK.from() != OTDeviceAddress( k.sba ) || + LK.to() != OTDeviceAddress( k.dba ) ) { + // copy + OutF.writeBlock( (char *)&k, sizeof( k ) ); + } // else remove this key + } + + // rename files + QDir D( "/etc/bluetooth" ); + + D.remove( "link_key" ); + D.rename( "newlink_key", "link_key" ); + + // restart hcid + system( "/etc/init.d/hcid stop" ); + system( "/etc/init.d/hcid start" ); + + // remove from table + if( Index < (AllKeys.size()-1) ) { + // collapse array + AllKeys[Index] = AllKeys[AllKeys.size()-1]; + } + + // remove last element + AllKeys.resize( AllKeys.size()-1 ); + + return 1; +} + +#define MAXCONNECTIONS 10 +void OTGateway::loadActiveConnections( void ) { + + struct hci_conn_list_req *cl; + struct hci_conn_info *ci; + OTDeviceAddress Addr; + OTPeer * P; + + if (!(cl = (struct hci_conn_list_req *)malloc( + MAXCONNECTIONS * sizeof(*ci) + sizeof(*cl)))) { + emit error( tr("Can't allocate memory") ); + return; + } + memset( cl, 0, MAXCONNECTIONS * sizeof(*ci) + sizeof(*cl) ); + + for( unsigned int i = 0; + i < AllDrivers.count(); + i ++ ) { + + if( ! AllDrivers[i]->isUp() ) { + continue; + } + + // driver is up -> check connections + cl->dev_id = AllDrivers[i]->devId(); + cl->conn_num = MAXCONNECTIONS; + ci = cl->conn_info; + + if (ioctl( getSocket(), HCIGETCONNLIST, (void *) cl)) { + emit error( tr("Can't get connection list") ); + break; + } + + for ( int k = 0; k < cl->conn_num; k++, ci++) { + + if( ci->state != BT_CONNECTED ) { + // not yet connected + continue; + } + + Addr.setBDAddr( ci->bdaddr ); + P = findPeer( Addr ); + if( ! P ) { + // peer not yet known -> add + P = new OTPeer( this ); + addPeer( P ); + P->setAddress( Addr ); + // infoQueue.push_back(info); + P->setName( AllDrivers[i]->getPeerName( Addr ) ); + } + P->setState( OTPeer::Peer_Up ); + P->setConnectedTo( AllDrivers[i] ); + } + } + + free( cl ); +} + +void OTGateway::loadKnownPeers( void ) { + QDir SaveDir = QDir::home(); + + if( ! SaveDir.exists( "Settings" ) ) { + return; + } + SaveDir.cd( "Settings" ); + + if( ! SaveDir.exists( "opietooth" ) ) { + return; + } + SaveDir.cd( "opietooth" ); + + QFile F( SaveDir.path() + "/SeenDevices.conf" ); + + if( F.open( IO_ReadOnly ) ) { + QTextStream TS(&F); + long count; + + count = TS.readLine().toLong(); + + while( count > 0 ) { + addPeer( new OTPeer( TS, this ) ); + count --; + } + } + + AllPeersModified = 0; +} + +void OTGateway::saveKnownPeers( void ) { + QDir SaveDir = QDir::home(); + + if( ! SaveDir.exists( "Settings" ) ) { + SaveDir.mkdir( "Settings" ); + } + SaveDir.cd( "Settings" ); + + if( ! SaveDir.exists( "opietooth" ) ) { + SaveDir.mkdir( "opietooth" ); + } + SaveDir.cd( "opietooth" ); + + QFile F( SaveDir.path() + "/SeenDevices.conf" ); + + if( F.open( IO_WriteOnly | IO_Truncate ) ) { + QTextStream TS(&F); + QString S; + + TS << AllPeers.count() << endl; + + for( unsigned int i = 0; + i < AllPeers.count(); + i ++ ) { + AllPeers[i]->save( TS ); + } + AllPeersModified = 0; + } + AllPeersModified = 0; +} + +int OTGateway::connectedToRFCommChannel( const OTDeviceAddress & Addr, + int channel ) { + + int s; + + if( (s = ::socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM)) < 0 ) { + emit error( tr("Can't open RFCOMM control socket") ); + return 0; + } + + // get all rfcomm devices + { struct rfcomm_dev_list_req *dl; + struct rfcomm_dev_info *di, *dr; + int i; + + dl = (struct rfcomm_dev_list_req *)alloca( + sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di)); + memset( dl, 0, sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di) ); + dl->dev_num = RFCOMM_MAX_DEV; + di = dl->dev_info; + + if( ::ioctl(s, RFCOMMGETDEVLIST, (void *) dl) < 0) { + emit error( tr("Can't get device list") ); + ::close( s ); + return 0; + } + + dr = di; + for (i = 0; i < dl->dev_num; i++, dr++) { + // connected to Peer + if( Addr == OTDeviceAddress( dr->dst ) && + channel == dr->channel && + ( dr->state != 0 ) + ) { + // return device ID + return dr->id; + } + } + } + + // no device + return -1; +} + +static int byID( struct rfcomm_dev_info * d1, + struct rfcomm_dev_info * d2 ) { + return d1->id - d2->id; +} + +int OTGateway::getFreeRFCommDevice( void ) { + + int s; + + if( (s = ::socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM)) < 0 ) { + emit error( tr("Can't open RFCOMM control socket") ); + return 0; + } + + // get all rfcomm devices + { struct rfcomm_dev_list_req *dl; + struct rfcomm_dev_info *di, *dr; + int i; + + dl = (struct rfcomm_dev_list_req *)alloca( + sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di)); + + dl->dev_num = RFCOMM_MAX_DEV; + di = dl->dev_info; + + if( ::ioctl(s, RFCOMMGETDEVLIST, (void *) dl) < 0) { + emit error( tr("Can't get device list") ); + ::close( s ); + return 0; + } + + // s + if( dl->dev_num ) { + qsort( di, sizeof(struct rfcomm_dev_info), + dl->dev_num, (int(*)(const void*,const void*))byID ); + int id = 0; + + dr = di; + // find lowest free device number + for (i = 0; i < dl->dev_num; i++, dr++) { + if( id != dr->id ) { + return id; + } + id ++; + } + return id; + } else { + return 0; + } + } +} + +int OTGateway::releaseRFCommDevice( int devnr ) { + + int s; + + if( (s = ::socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM)) < 0 ) { + emit error( tr("Can't open RFCOMM control socket") ); + return 0; + } + + // get all rfcomm devices + { struct rfcomm_dev_list_req *dl; + struct rfcomm_dev_info *di, *dr; + int i; + + dl = (struct rfcomm_dev_list_req *)alloca( + sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di)); + memset( dl, 0, sizeof(*dl) + RFCOMM_MAX_DEV * sizeof(*di) ); + dl->dev_num = RFCOMM_MAX_DEV; + di = dl->dev_info; + + if( ::ioctl(s, RFCOMMGETDEVLIST, (void *) dl) < 0) { + emit error( tr("Can't get device list") ); + ::close( s ); + return 0; + } + + dr = di; + for (i = 0; i < dl->dev_num; i++, dr++) { + if( dr->id == devnr ) { + // still in connection list + struct rfcomm_dev_req req; + int err; + + memset(&req, 0, sizeof(req)); + req.dev_id = devnr; + + if ((err = ioctl(s, RFCOMMRELEASEDEV, &req)) < 0 ) { + return err; + } + return 0; + } + } + } + + // no device -> nothing to release eiterh + return 0; +} + diff --git a/noncore/settings/networksettings2/opietooth2/OTGateway.h b/noncore/settings/networksettings2/opietooth2/OTGateway.h new file mode 100644 index 0000000..a47cefb --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTGateway.h @@ -0,0 +1,200 @@ +#ifndef OTGATEWAY_H +#define OTGATEWAY_H + +#include <qobject.h> +#include <qvector.h> +#include <qmap.h> + +#include <OTDriverList.h> +#include <OTInquiry.h> + +class QPixmap; + +namespace Opietooth2 { + +class OTDriverList; +class OTDriver; +class OTDevice; +class OTPeer; +class OTInquiry; +class OTPANConnection; +class OTLinkKey; + +typedef QVector<OTPeer> PeerVector; +typedef QVector<OTPANConnection> PANConnectionVector; +typedef QArray<OTLinkKey> LinkKeyArray; + +class OTLinkKey { + +public : + + OTLinkKey( const OTDeviceAddress & F, + const OTDeviceAddress & T ) { + From = F; + To = T; + } + + const OTDeviceAddress & to() + { return To; } + const OTDeviceAddress & from() + { return From; } + + OTDeviceAddress From; + OTDeviceAddress To; +}; + +class OTPANConnection { + +public : + + OTPANConnection( const QString & Dev, const QString & CT ) { + Device = Dev; + ConnectedTo = CT; + } + + QString Device; + QString ConnectedTo; +}; + + +class OTGateway : public QObject { + + Q_OBJECT + +public : + + // single instance + static OTGateway * getOTGateway( void ); + static void releaseOTGateway( void ); + // convert device type as class to name for that class + static const char * deviceTypeToName( int Cls ); + + // open bluetooth system + OTGateway( void ); + // close bluetooth system + ~OTGateway( void ); + + // get access to system device + OTDevice * getOTDevice(); + + // return true if this device needs enabling of bluetooth + bool needsEnabling(); + // return true if system is running + bool isEnabled(); + void setRefreshTimer( int MilleSecs ); + // return socket to HCI raw layer + inline int getSocket() + { return HciCtl; } + + OTDriverList & getDriverList() + { return AllDrivers; } + OTDriver * driver( int nr ) + { return AllDrivers[nr]; } + void updateDrivers(); + + PANConnectionVector getPANConnections(); + + // scan neighbourhood using device + void scanNeighbourhood( OTDriver * D = 0 ); + void stopScanOfNeighbourhood(void ); + void setScanWith( OTDriver * D = 0 ) + { ScanWith = (D) ? D : + (AllDrivers.count() ) ? AllDrivers[0] : 0; } + OTDriver * scanWith( void ) + { return ScanWith; } + + // get list of all detected peers + inline const PeerVector & peers( void ) + { return AllPeers; } + // ping peer to see if it is up + bool isPeerUp( const OTDeviceAddress & PAddr, + int timeoutInSec = 1, + int timeoutInUSec = 0, + int retry = 1 ); + OTPeer * findPeer( const OTDeviceAddress & Addr ); + void removePeer( OTPeer * P ); + void addPeer( OTPeer * P ); + + OTDriver * findDriver( const OTDeviceAddress & Addr ); + + inline const LinkKeyArray & getLinkKeys() const + { return AllKeys; } + bool removeLinkKey( unsigned int index ); + + // return device number if we are connected over any device + // to the channel + // else returns -1 + int connectedToRFCommChannel( const OTDeviceAddress & Addr, int channel ); + int getFreeRFCommDevice( void ); + // return 0 if properly released + int releaseRFCommDevice( int DevNr ); + +public slots : + + // start bluetooth system + void SLOT_SetEnabled( bool ); + void SLOT_Enable(); + void SLOT_Disable(); + + // show error + void SLOT_ShowError( const QString & ); + + void SLOT_Enabled( int, bool ); + void SLOT_DriverDisappeared( OTDriver * ); + void SLOT_PeerDetected( OTPeer *, bool ); + void SLOT_FinishedDetecting(); + +signals : + + // any error + void error( const QString & ); + + // signal state of bluetooth driver + void stateChange( OTDriver * D, bool State ); + + // sent when list of drivers changees + void driverListChanged(); + + // sent when bluetooth on device is enabled + void deviceEnabled( bool ); + + // sent when a (new if bool = TRUE) peer is detected + void detectedPeer( OTPeer *, bool ); + + // end of detection process + void finishedDetecting(); + +protected : + + void connectNotify( const char * Signal ); + void disconnectNotify( const char * Signal ); + + void timerEvent( QTimerEvent * ); + +private : + + void loadActiveConnections( void ); + void loadKnownPeers( void ); + void saveKnownPeers( void ); + bool isConnectedTo( int devid, + const OTDeviceAddress & Address ); + + void readLinkKeys(); + + static OTGateway * SingleGateway; + static int UseCount; + + OTDriver * ScanWith; + OTDriverList AllDrivers; + OTDevice * TheOTDevice; + int HciCtl; + int ErrorConnectCount; + int RefreshTimer; + OTInquiry * Scanning; + bool AllPeersModified; + PeerVector AllPeers; + LinkKeyArray AllKeys; +}; +}; + +#endif diff --git a/noncore/settings/networksettings2/opietooth2/OTHCISocket.cpp b/noncore/settings/networksettings2/opietooth2/OTHCISocket.cpp new file mode 100644 index 0000000..471c3bf --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTHCISocket.cpp @@ -0,0 +1,274 @@ +//-*-c++-*- +/*************************************************************************** + * Copyright (C) 2003 by Fred Schaettgen * + * kdebluetooth@schaettgen.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#include <qbuffer.h> +#include <qtimer.h> +#include <qdatastream.h> +#include <opie2/odebug.h> + +#include <bluezlib.h> + +// #include "deviceaddress.h" +#include <OTHCISocket.h> +#include <OTDriver.h> + +using namespace Opietooth2; + +OTHCISocket::OTHCISocket( OTDriver * D ) : + QObject( D, D->devname() ) { + BStatusSet = false; + Driver = D; + HCIReadNotifier = 0; +} + +OTHCISocket::~OTHCISocket() { + close(); +} + +void OTHCISocket::close() { + owarn << "OTHCISocket::close()" << oendl; + if( HCIReadNotifier ) { + delete HCIReadNotifier; + } + + if( HCISocket.isValid() ) { + HCISocket.close(); + } +} + +bool OTHCISocket::open() { + + owarn << "OTHCISocket::open()" << oendl; + int s; + + s = ::socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); + + if (s < 0) { + emit error( tr( "Error creating socket on %1 : %2 %3"). + arg( Driver->devname() ). + arg( errno ). + arg( strerror(errno) ) + ); + return false; + } + + /* Bind socket to the HCI device */ + struct sockaddr_hci sa; + sa.hci_family = AF_BLUETOOTH; + sa.hci_dev = Driver->devId(); + if (bind(s, (struct sockaddr *)&sa, sizeof(sa)) < 0) { + ::close(s); + emit error( tr( "Error binding to socket to %1 : %2 %3"). + arg( Driver->devname() ). + arg( errno ). + arg( strerror(errno) ) + ); + return false; + } + + struct hci_filter flt; + hci_filter_clear(&flt); + hci_filter_set_ptype(HCI_EVENT_PKT, &flt); + hci_filter_all_events(&flt); + if( setsockopt(s, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0 ) { + ::close(s); + emit error( tr( "HCI filter setup failed on %1 : %2 %3"). + arg( Driver->devname() ). + arg( errno ). + arg( strerror(errno) ) + ); + return false; + } + + if( HCIReadNotifier ) { + delete HCIReadNotifier; + } + + HCISocket.setSocket(s, QSocketDevice::Datagram); + HCIReadNotifier = new QSocketNotifier( + s, QSocketNotifier::Read, this); + + connect( HCIReadNotifier, + SIGNAL(activated(int)), + this, + SLOT(slotSocketActivated()) + ); + + //connect(hciSocket, SIGNAL(error(int)), + // this, SLOT(slotSocketError(int))); + //connect(hciSocket, SIGNAL(connectionClosed()), + // this, SLOT(slotConnectionClosed())); + //hciSocket->setSocket(s); + + return true; +} + +void OTHCISocket::slotSocketError(int e) { + close(); + emit error( tr( "HCI socket error 0x%1 on %1 : %2 %3"). + arg(e,2,16). + arg( Driver->devname() ). + arg( errno ). + arg( strerror(errno) ) + ); +} + +void OTHCISocket::slotSocketActivated() { + + QSocketDevice::Error err = HCISocket.error(); + + if( (err == QSocketDevice::NoError ) && + ( HCISocket.isValid() ) ) { + //kdDebug() << "HCI socket ready read." << endl; + + unsigned char buf[512]; + int psize = HCISocket.readBlock((char*)buf, 512); + + if (psize <= 0) { + slotSocketError(HCISocket.error()); + HCISocket.close(); + return; + } + + //unsigned char packetType = buf[0]; + unsigned char eventCode = buf[1]; + unsigned char len = buf[2]; + + if (psize-3 == len) { + + QByteArray databuf; + databuf.duplicate((char*)(buf+3), len); + emit event(eventCode, databuf); + if (eventCode == EVT_CMD_STATUS) { + updateStatus( databuf ); + } + } else { + owarn << "Error reading hci packet: packetSize(" + << psize + << ")-3 != dataSize(" + << len + << ")" + << oendl; + } + } else if (err == QSocketDevice::NoError) { + slotConnectionClosed(); + } else { + HCISocket.close(); + slotSocketError(err); + } +} + +void OTHCISocket::updateStatus(const QByteArray& data) { + + QDataStream stream(data, IO_ReadOnly); + stream.setByteOrder(QDataStream::LittleEndian); + Q_UINT8 status, dummy; + Q_UINT16 opcode; + + BStatusSet = true; + + stream >> status >> dummy >> opcode; + //kdDebug() << "updatestatus opcode=" << uint32_t(opcode) << endl; + LastStatus = status; + LastStatusOgf = cmd_opcode_ogf(opcode); + LastStatusOcf = cmd_opcode_ocf(opcode); +} + +void OTHCISocket::slotConnectionClosed() { + owarn << "HCI connection closed." << oendl; + emit connectionClosed(); +} + +void OTHCISocket::readEvent() { + + if (HCIReadNotifier) { + slotSocketActivated(); + } +} + +bool OTHCISocket::sendCommand( unsigned char ogf, + unsigned short ocf, + QByteArray buf + ) { + QBuffer packet; + QDataStream stream(&packet); + + stream.setByteOrder(QDataStream::LittleEndian); + packet.open(IO_WriteOnly); + + if (buf.size() > 255) return false; + + //kdDebug() << "sendCommand. ogf=" << ogf << " ocf=" << ocf << endl; + Q_UINT16 opcode = cmd_opcode_pack(ogf, ocf); + Q_UINT8 pType = HCI_COMMAND_PKT; + Q_UINT8 buflen = buf.size(); + + stream << pType << opcode << buflen; + stream.writeRawBytes(buf.data(), buflen); + packet.close(); + HCISocket.writeBlock((const char*)packet.buffer(), + packet.buffer().size()); + return true; +} + +bool OTHCISocket::readStatus( unsigned char ogf, + unsigned short ocf, + int *status, + int timeout_ms) { + QTimer timer; + + timer.start(timeout_ms, true); + BStatusSet = false; + + while (timer.isActive() && HCISocket.isValid()) { + + owarn << "OTHCISocket::readStatus()" << oendl; + bool timeout = false; + + if( HCISocket.bytesAvailable() == 0) { + int rv = HCISocket.waitForMore(timeout_ms); + timeout = (rv == 0); + } + + if (!timeout) { + slotSocketActivated(); + } + + if( BStatusSet == true && + ogf == LastStatusOgf && + ocf == LastStatusOcf) { + *status = LastStatus; + owarn << "OTHCISocket::readStatus(ogf=" + << ogf + << ",ocf=" + << ocf + << ",timeout=" + << LastStatus + << ")" + << oendl; + return true; + } + } + + owarn << "OTHCISocket::readStatus(ogf=" + << ogf + << ",ocf=" + << ocf + << ",timeout=" + << LastStatus + << ") : timeout " + << oendl; + return false; +} + +int OTHCISocket::socket() { + return HCISocket.socket(); +} diff --git a/noncore/settings/networksettings2/opietooth2/OTHCISocket.h b/noncore/settings/networksettings2/opietooth2/OTHCISocket.h new file mode 100644 index 0000000..d508078 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTHCISocket.h @@ -0,0 +1,116 @@ +//-*-c++-*- +/*************************************************************************** + * Copyright (C) 2003 by Fred Schaettgen * + * kdebluetooth@schaettgen.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#ifndef OTHCISOCKET_H +#define OTHCISOCKET_H + +#include <qobject.h> +#include <qsocketnotifier.h> +#include <qsocketdevice.h> +#include <qguardedptr.h> + +class QSocket; + +namespace Opietooth2 { + +/** Bluetooth HCI Socket class. + * This class provides socket level access to the Bluez HCI layer. + * It is set up to filter out all but HCI event packets, since more + * is only allowed for privileged users. + * @todo writeHciEvent() function + * @todo error handling + */ + +class OTDriver; + +class OTHCISocket : public QObject { + + Q_OBJECT + +public: + + OTHCISocket( OTDriver * ConnectTo ); + virtual ~OTHCISocket(); + + /** Opens a HCI socket for the given + @return true if sucessfully opened, false otherwise + */ + virtual bool open(); + + /** Closes the HCI socket. */ + virtual void close(); + + bool sendCommand( unsigned char ogf, + unsigned short ocf, + QByteArray buf + ); + bool readStatus( unsigned char ogf, + unsigned short ocf, + int *status, + int timeout_ms = 1000); + + /** Reads whole HCI packet. + @param packetType [out] The packet type. Should always be ... + @param eventCode [out] The event code. + @param buflen [in/out] The maximum size of the buffer / the number of + bytes written into the buffer. + @param paramBuf pointer to a buffer for the HCI event packet + @return true if successful + */ + /*bool readEvent(unsigned char &packetType, + unsigned char &eventCode, unsigned char &buflen, + char* paramBuf);*/ + + enum Error { ErrSocket = 1 }; + + /** Forces reading the next event packet. */ + void readEvent( void ); + + /** Returns the internal socket */ + int socket( void ); + + inline QSocketDevice & socketDevice() + { return HCISocket; } + + inline OTDriver * driver() const + { return Driver; } + +signals: + + void event( unsigned char eventCode, QByteArray buf); + void error( QString message ); + void connectionClosed( ); + +private: + + void updateStatus( const QByteArray& data ); + + //QSocketDevice hciSocket; + QGuardedPtr<QSocketNotifier> HCIReadNotifier; + QSocketDevice HCISocket; + OTDriver * Driver ; + + bool BStatusSet; + unsigned short LastStatusOcf; + unsigned char LastStatusOgf; + int LastStatus; + +private slots: + + void slotSocketActivated(); + void slotSocketError(int); + void slotConnectionClosed(); + +}; + +}; + +#endif diff --git a/noncore/settings/networksettings2/opietooth2/OTIcons.cpp b/noncore/settings/networksettings2/opietooth2/OTIcons.cpp new file mode 100644 index 0000000..8b58b75 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTIcons.cpp @@ -0,0 +1,120 @@ +#include <OTIcons.h> + +#include <opie2/odebug.h> +#include <qpe/resource.h> + +using namespace Opietooth2; + +OTIcons::OTIcons() : deviceIcons(), serviceIcons() { + + // still need to find out real ids + deviceIcons.insert( "unknown", "unknown_16" ); + deviceIcons.insert( "misc", "misc_16" ); + deviceIcons.insert( "computer", "computer_16" ); + deviceIcons.insert( "phone", "phone_16" ); + deviceIcons.insert( "lan", "network_16" ); + deviceIcons.insert( "audiovideo", "audio_16" ); + deviceIcons.insert( "peripheral", "print_16" ); + deviceIcons.insert( "imaging", "other_16" ); + + serviceIcons.insert( 0x1101 , "serial_16" ); //SerialPort + serviceIcons.insert( 0x1102 , "network_16" ); //LANAccessUsingPPP + serviceIcons.insert( 0x1103 , "network_16"); //DialupNetworking + serviceIcons.insert( 0x1104 , "sync_16" ); //IrMCSync + serviceIcons.insert( 0x1105 , "obex_16" ); //OBEXObjectPush + serviceIcons.insert( 0x1106 , "obex_16" ); //OBEXFileTransfer + serviceIcons.insert( 0x1107 , "sync_16" ); //IrMCSyncCommand + serviceIcons.insert( 0x1108 , "phone_16"); // Headset + serviceIcons.insert( 0x1109 , "phone_16"); // CordlessTelephony + serviceIcons.insert( 0x110A , "audio_16"); // AudioSource + serviceIcons.insert( 0x110B , "audio_16"); // AudioSink + //serviceIcons.insert( 0x110C , "remotecontrol_16" ); // remote control target --- + //serviceIcons.insert( 0x110D , "audio_16" ); // advanced audio distribution --- + //serviceIcons.insert( 0x110E , "remotecontrol_16" ); // remote control --- + //serviceIcons.insert( 0x110F , "video_16" ); // video conferencing --- + //serviceIcons.insert( 0x1110 , "audio_16" ); // intercom --- + serviceIcons.insert( 0x1111 , "fax_16" ); //Fax + serviceIcons.insert( 0x1112 , "audio_16"); //HeadsetAudioGateway + //serviceIcons.insert( 0x1113 , "wap_16" ); // WAP --- + //serviceIcons.insert( 0x1114 , "wap_16" ); // WAP client --- + serviceIcons.insert( 0x1115 , "network_16"); // Network Access Point (PANU) + serviceIcons.insert( 0x1116 , "network_16"); // Network Access Point (NAP) + serviceIcons.insert( 0x1117 , "network_16"); // Network Access Point (GN) + serviceIcons.insert( 0x1118 , "print_16" ); // direct printing + serviceIcons.insert( 0x1119 , "print_16" ); // reference printing + //serviceIcons.insert( 0x111A , "image_16" ); // imaging --- + //serviceIcons.insert( 0x111B , "image_16" ); // imaging responder --- + //serviceIcons.insert( 0x111C , "image_16" ); // imaging automatic archive --- + //serviceIcons.insert( 0x111D , "image_16" ); // imaging referenced objects --- + //serviceIcons.insert( 0x111E , "handsfree_16" ); // handsfree --- + //serviceIcons.insert( 0x111F , "handsfree_16" ); // handsfree audio gateway --- + serviceIcons.insert( 0x1120 , "print_16" ); // direct printing referenced object service + //serviceIcons.insert( 0x1121 , "handsfree_16" ); // reflected UI --- + serviceIcons.insert( 0x1122 , "print_16" ); // basic printing + serviceIcons.insert( 0x1123 , "print_16" ); // printing status + //serviceIcons.insert( 0x1124 , "handsfree_16" ); // human interface device service --- + //serviceIcons.insert( 0x1125 , "handsfree_16" ); // hardcopy cable replacement --- + serviceIcons.insert( 0x1126 , "print_16" ); // HCR print + serviceIcons.insert( 0x1127 , "print_16" ); // HCR scan + serviceIcons.insert( 0x1128 , "phone_16" ); // Common_ISDN_Access + //serviceIcons.insert( 0x1129 , "audio_16" ); // video conferencing GW --- + //serviceIcons.insert( 0x112C , "audio_16" ); // audio video --- + //serviceIcons.insert( 0x112D , "phone_16" ); // SIM access --- + serviceIcons.insert( 0x1201 , "network_16" ); //GenericNetworking + serviceIcons.insert( 0x1202 , "folder_16" ); //GenericFileTransfer + serviceIcons.insert( 0x1203 , "audio_16" ); //GenericAudio + serviceIcons.insert( 0x1204 , "phone_16" ); //GenericTelephony + //serviceIcons.insert( 0x1303 , "video_16" ); // video source --- + //serviceIcons.insert( 0x1304 , "video_16" ); // video sink --- + + Modems.resize( 3 ); + Modems[0].setUUID32( 0x1101 ); // SerialPort + Modems[1].setUUID32( 0x1102 ); // Lan access using PPP + Modems[2].setUUID32( 0x1103 ); // DialupNetworking + + Networks.resize( 3 ); + Networks[0].setUUID32( 0x1115 ); // PANU + Networks[1].setUUID32( 0x1116 ); // NAP + Networks[2].setUUID32( 0x1117 ); // GN +} + +OTIcons::~OTIcons() { +} + +QPixmap OTIcons::deviceIcon( const QString & deviceClass ) { + + QString iconName; + + QMap<QString, QString>::Iterator it; + + it = deviceIcons.find( deviceClass ); + iconName = it.data(); + + if ( iconName.isEmpty() ) { + iconName = "unknown_16"; + } + return loadPixmap( iconName, 1 ); +} + +QPixmap OTIcons::serviceIcon( int serviceClass, bool & found ) { + + QString iconName; + + QMap<int, QString>::Iterator it; + + it = serviceIcons.find( serviceClass ); + iconName = it.data(); + + if ( iconName.isEmpty() ) { + iconName = "unknown_16"; + found = 0 ; + } else + found = 1 ; + return loadPixmap( iconName, 1 ); +} + +QPixmap OTIcons::loadPixmap( const QString & name, bool Sub ) { + return( Resource::loadPixmap( "opietooth/" + + QString( (Sub) ? "icons/" : "" ) + + name ) ); +} diff --git a/noncore/settings/networksettings2/opietooth2/OTIcons.h b/noncore/settings/networksettings2/opietooth2/OTIcons.h new file mode 100644 index 0000000..ee10831 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTIcons.h @@ -0,0 +1,54 @@ +#ifndef OTICONLOADER_H +#define OTICONLOADER_H + +#include <OTUUID.h> +#include <qpixmap.h> +#include <qmap.h> + +namespace Opietooth2 { + +class OTIcons { + +public: + + OTIcons(); + ~OTIcons(); + + /** + * Returns an icon depending on device class + * @param deviceClass the device class name + * @return the pixmap + */ + QPixmap deviceIcon( const QString & ); + + /** + * Returns an icon depending on service id + * @param serviceClass the service id + * @return the pixmap + * @return true if found + */ + QPixmap serviceIcon( int, bool & ); + + // returns all UUID that represent channels with modem function + const UUIDVector & modems() + { return Modems; } + + // returns all UUID that represent channels with network + const UUIDVector & network() + { return Networks; } + + // set Sub to find icons in .../Icons dir + QPixmap loadPixmap( const QString &, bool Sub = 0 ); + +private: + + // first ist id, second is icon name + QMap<QString,QString> deviceIcons; + QMap<int,QString> serviceIcons; + UUIDVector Modems; + UUIDVector Networks; + +}; +} + +#endif diff --git a/noncore/settings/networksettings2/opietooth2/OTInquiry.cpp b/noncore/settings/networksettings2/opietooth2/OTInquiry.cpp new file mode 100644 index 0000000..8e94bbc --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTInquiry.cpp @@ -0,0 +1,219 @@ +//-*-c++-*- +/*************************************************************************** + * Copyright (C) 2003 by Fred Schaettgen * + * kdebluetooth@schaettgen.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + + +#include <qcstring.h> +#include <qsocket.h> +#include <qdatetime.h> +#include <qtimer.h> +#include <qthread.h> +#include <qapplication.h> + +#include <bluezlib.h> + +#include <OTGateway.h> +#include <OTDriver.h> +#include <OTPeer.h> +#include <OTHCISocket.h> +#include <OTInquiry.h> + +#include <opie2/odebug.h> + +using namespace Opietooth2; + +#define max(a,b) (((a)>(b)) ? (a) : (b)) +#define min(a,b) (((a)>(b)) ? (b) : (a)) + +OTInquiry::OTInquiry( OTDriver * Drv ) : QObject( Drv ) { + + reset(); + + InquiryTimeoutTimer = new QTimer(this); + + connect( InquiryTimeoutTimer, + SIGNAL(timeout()), + this, + SLOT(slotInquiryTimeout())); + + Driver = Drv; + Socket = Drv->openSocket(); + Socket->open(); + + connect( Socket, + SIGNAL( event(unsigned char, QByteArray)), + this, + SLOT(slotHCIEvent(unsigned char, QByteArray))); +} + +OTInquiry::~OTInquiry() { + stopInquiring(); +} + +void OTInquiry::stopInquiring( void ) { + if( Socket ) { + owarn << "Stop inquiry" << oendl; + Driver->closeSocket(); + Socket = 0; + } +} + +bool OTInquiry::inquire( double timeout, int numResponses, int lap) { + + QByteArray cmdBuf(5); + + cmdBuf[0] = lap & 0xFF; + cmdBuf[1] = (lap >> 8) & 0xFF; + cmdBuf[2] = (lap >> 16) & 0xFF; + cmdBuf[3] = max(0x01, min(0x30, int(timeout/1.28))); + cmdBuf[4] = (unsigned char)numResponses; + + owarn << "Send HCI inquiry command. wait for " << cmdBuf[3] << oendl; + + Socket->sendCommand(0x01, 0x0001, cmdBuf); + + int status; + + if( Socket->readStatus(0x01, 0x0001, &status)) { + if (status == 0) { + SuccessfullyStarted = true; + InquiryTimeoutTimer->start( int(1000*(timeout+1.0)), true); + return true; + } + else { + QString S =QString().sprintf( "%x", status ); + owarn << "OTInquiry::inquiry() failed: 0x" << S << oendl; + emit finished(); + return false; + } + } else { + owarn << "OTInquiry::inquiry(): Timeout." << oendl; + return false; + } +} + +bool OTInquiry::isInquiring() { + return InquiryTimeoutTimer->isActive(); +} + +bool OTInquiry::isFinished() { + return SuccessfullyStarted && SuccessfullyEnded; +} + +void OTInquiry::reset() { + + SuccessfullyStarted = false; + SuccessfullyEnded = false; + //addrCache.clear(); + //infoQueue.clear(); +} + + +void OTInquiry::onPeerFound( OTPeer * Peer, bool IsNew ) { + emit peerFound( Peer, IsNew ); +} + +void OTInquiry::slotInquiryTimeout() { + emit error( tr( "Timeout while waiting for end of inquiry.") ); +} + +void OTInquiry::slotHCIEvent(unsigned char eventCode, QByteArray buf) { + + owarn << "OTInquiry: hci packet received: eventCode=" + << (unsigned int)eventCode + << " packetLength=" + << (unsigned int)buf.size() + << oendl; + + unsigned char *data = (unsigned char*)buf.data(); + switch (eventCode) { + case EVT_INQUIRY_COMPLETE: + { unsigned char status = data[0]; + owarn << "EVT_INQUIRY_COMPLETE status=" << status << oendl; + InquiryTimeoutTimer->stop(); + if (status == 0) { + if( SuccessfullyStarted == true) { + owarn << "OTInquiry ended successfully" << oendl; + SuccessfullyEnded = true; + } + emit finished(); + } + else { + emit error( tr( "OTInquiry completed with error (code %1)" ). + arg(status)); + } + } + break; + case EVT_INQUIRY_RESULT: + { int numResults = data[0]; + OTPeer * P = 0; + bool IsNew; + OTDeviceAddress Addr; + QString N; + + inquiry_info *results = (inquiry_info*)(data+1); + + for (int n=0; n<numResults; n++) { + Addr.setBDAddr( results[n].bdaddr ); + + owarn << "INQUIRY_RESULT: " + << Addr.toString() + << oendl; + + P = Driver->gateway()->findPeer( Addr ); + + if( P ) { + // peer known + if( P->state() != OTPeer::Peer_Up ) { + P->setState( OTPeer::Peer_Up ); + } + IsNew = 0; + } else { + IsNew = 1; + // push the address to the address queue + // where it can be consumed by nextNeighbour() + P = new OTPeer( Driver->gateway() ); + P->setState( OTPeer::Peer_Up ); // we just detected it + P->setAddress( Addr ); + //if( addrCache.find(info.addr) == addrCache.end()) { + // addrCache.insert(info.addr); + + P->setDeviceClass( (results[n].dev_class[0] << 16) | + (results[n].dev_class[1] << 8) | + (results[n].dev_class[2] << 0) ); + // infoQueue.push_back(info); + P->setName( Driver->getPeerName( Addr ) ); + } + + // call the handler. Emits a signal if not overwritten + onPeerFound( P, IsNew ); + + // } + } + } + break; + case EVT_CMD_STATUS : + { int status = data[0]; + int numHciCmdPkts = data[1]; + int cmdOpcode = *((uint16_t*)(data+2)); + owarn << "EVT_CMD_STATUS status=" + << status + << " numPkts=" + << numHciCmdPkts + << " cmdOpcode=" + << cmdOpcode + << oendl; + if (cmdOpcode == OCF_INQUIRY) { + + } + } + break; + } +} diff --git a/noncore/settings/networksettings2/opietooth2/OTInquiry.h b/noncore/settings/networksettings2/opietooth2/OTInquiry.h new file mode 100644 index 0000000..f7bdeec --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTInquiry.h @@ -0,0 +1,178 @@ +//-*-c++-*- +/*************************************************************************** + * Copyright (C) 2003 by Fred Schaettgen * + * kdebluetooth@schaettgen.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#ifndef OTINQUIRY_H +#define OTINQUIRY_H + +#include <qstring.h> +#include <qobject.h> + +#include <qguardedptr.h> +#include <qtimer.h> + +#include <OTPeer.h> + +// #include <set> +// #include <deque> + +namespace Opietooth2 { + +class QSocket; +class QDateTime; + +class OTDriver; +class OTHCISocket; + +/** Scans for nearby bluetooth devices. + * This class provides an asynchronous interface to the + * inquriy HCI command. To scan for other devices, connect + * to the signals neighbourFound() and finished() and call + * inquiry(). Inquiry results are signalled as soon as they arrive, + * so the information can be displayed before the whole inquiry + * process is finished. + * Still no connections should be set up before + * the finished() signal was sent (hmm, is this always true..?) + */ + +class OTInquiry : public QObject { + + Q_OBJECT + +public: + + /** Constructor. + @param owner The owning parent object + */ + OTInquiry( OTDriver* Drv ); + + /** Destructor. */ + virtual ~OTInquiry(); + + // General/Unlimited Inquiry Access Code + static const int GIAC = 0x9E8B33; + + // Limited Dedicated Inquiry Access Code + static const int LIAC = 0x9E8B00; + + /** Starts the inquiry. + if you start inquiry several times without calling clear(), + you will receive each result only once. + @param timeout duration of the inquiry in seconds. + It will be rounded to the next multiple of 1.28 sec, + with a maximum of 61.44 sec. + @param lap + */ + bool inquire( double timeout = 8.0, + int numResponses = 0, + int lap = GIAC); + + void stopInquiring( ); + + /** Enters periodic inquiry mode. + An inquiry will be started at a random time in the intervall + between minduration and maxduration. + @param minduration minimum time between two inquiries. Rounded to + a multiple of 1.28, (3.84 <= d <= 83884.8) + @param maxduration maximum time between two inquiries. Rounded to + a multiple of 1.28, (3.84 <= d <= 83884.8) + @param timeout duration of the inquiry in seconds. + It will be rounded to the next multiple of 1.28 sec, + with a maximum of 61.44 sec. + @param numResponses Number of responses after which the inquiry + will be stopped. 0 means no limit. + @param lap + */ + /* + void inquirePeriodically( double minduration, + double maxduration, + double timeout = 8.0, + int numResponses = 0, + int lap = LIAC + ); +*/ + /** checks if there the inquiry is running currently + @return true if there is an inquiry running + which was started by this object. + @todo possibility to check for "foreign" inquiries. Deal with + the fact that we can receive foreign inquiry results. + */ + bool isInquiring(); + + /** This function returns true after after an inquiry was + started, results were received and the inquiry ended successfully. + This can be the case without calling inquiry() at all, because + results of inquiries started by other programs are also processed. + */ + bool isFinished(); + + /** Resets the list of received results and sets + isInquiryComplete() to false. + */ + void reset(); + + inline OTDriver * driver() const + { return Driver; } + +protected: + + /** Called when a new neighbour was found. The default + implementation emits the neighbourFound signal. + @param bdaddr the address found. + */ + virtual void onPeerFound( OTPeer * Peer, bool ); + + enum ErrorCode { + InquiryFinishedTimeout = 0x0100 + }; + +signals : + + void peerFound( OTPeer *, bool ); + + /** Emitted after an inquiry has finished successfully. + If the inquiry was canceled, no finished signals is emitted. + This signal can be emitted without having called inquiry, since + other processes may have started an inquiry. + */ + void finished(); + + /** Emitted instead of finished if an error occured after + calling inquiry() or periodicInquiryMode() + @param code error code. + @param message Error message + */ + void error( QString message ); + +private: + + // std::set<DeviceAddress> addrCache; + // double currentTimeout; + // QByteArray* buf; + // QSocket* hciSocket; + QGuardedPtr<OTHCISocket> Socket; + OTDriver * Driver; + + //QDateTime *startTime; + QTimer *InquiryTimeoutTimer; + + // std::deque<InquiryInfo> infoQueue; + bool SuccessfullyStarted; + bool SuccessfullyEnded; + +private slots: + + void slotInquiryTimeout(); + void slotHCIEvent(unsigned char eventCode, QByteArray buf); + +}; + +} +#endif diff --git a/noncore/settings/networksettings2/opietooth2/OTMainGUI.ui b/noncore/settings/networksettings2/opietooth2/OTMainGUI.ui new file mode 100644 index 0000000..5584cd9 --- a/dev/null +++ b/noncore/settings/networksettings2/opietooth2/OTMainGUI.ui @@ -0,0 +1,378 @@ +<!DOCTYPE UI><UI> +<class>OTMainGUI</class> +<widget> + <class>QWidget</class> + <property stdset="1"> + <name>name</name> + <cstring>OTMainGUI</cstring> + </property> + <property stdset="1"> + <name>geometry</name> + <rect> + <x>0</x> + <y>0</y> + <width>240</width> + <height>385</height> + </rect> + </property> + <property stdset="1"> + <name>caption</name> + <string>Bluetooth Manager</string> + </property> + <grid> + <property stdset="1"> + <name>margin</name> + <number>11</number> + </property> + <property stdset="1"> + <name>spacing</name> + <number>6</number> + </property> + <widget row="7" column="0" rowspan="1" colspan="5" > + <class>QLayoutWidget</class> + <property stdset="1"> + <name>name</name> + <cstring>Layout4</cstring> + </property> + <hbox> + <property stdset="1"> + <name>margin</name> + <number>0</number> + </property> + <property stdset="1"> + <name>spacing</name> + <number>6</number> + </property> + <spacer> + <property> + <name>name</name> + <cstring>Spacer4_2</cstring> + </property> + <property stdset="1"> + <name>orientation</name> + <enum>Horizontal</enum> + </property> + <property stdset="1"> + <name>sizeType</name> + <enum>Expanding</enum> + </property> + <property> + <name>sizeHint</name> + <size> + <width>20</width> + <height>20</height> + </size> + </property> + </spacer> + <widget> + <class>QCheckBox</class> + <property stdset="1"> + <name>name</name> + <cstring>MustBeEnabled_CB</cstring> + </property> + <property stdset="1"> + <name>text</name> + <string>Bluetooth Enabled</string> + </property> + </widget> + </hbox> + </widget> + <widget row="3" column="2" > + <class>QLabel</class> + <property stdset="1"> + <name>name</name> + <cstring>TextLabel5</cstring> + </property> + <property stdset="1"> + <name>sizePolicy</name> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>1</vsizetype> + </sizepolicy> + </property> + <property stdset="1"> + <name>text</name> + <string>Use device :</string> + </property> + </widget> + <spacer row="4" column="0" > + <property> + <name>name</name> + <cstring>Spacer7</cstring> + </property> + <property stdset="1"> + <name>orientation</name> + <enum>Horizontal</enum> + </property> + <property stdset="1"> + <name>sizeType</name> + <enum>Fixed</enum> + </property> + <property> + <name>sizeHint</name> + <size> + <width>20</width> + <height>20</height> + </size> + </property> + </spacer> + <spacer row="1" column="0" > + <property> + <name>name</name> + <cstring>Spacer7_2</cstring> + </property> + <property stdset="1"> + <name>orientation</name> + <enum>Horizontal</enum> + </property> + <property stdset="1"> + <name>sizeType</name> + <enum>Fixed</enum> + </property> + <property> + <name>sizeHint</name> + <size> + <width>20</width> + <height>20</height> + </size> + </property> + </spacer> + <spacer row="6" column="0" > + <property> + <name>name</name> + <cstring>Spacer7_3</cstring> + </property> + <property stdset="1"> + <name>orientation</name> + <enum>Horizontal</enum> + </property> + <property stdset="1"> + <name>sizeType</name> + <enum>Fixed</enum> + </property> + <property> + <name>sizeHint</name> + <size> + <width>20</width> + <height>20</height> + </size> + </property> + </spacer> + <widget row="1" column="1" rowspan="1" colspan="4" > + <class>QLabel</class> + <property stdset="1"> + <name>name</name> + <cstring>TextLabel1</cstring> + </property> + <property stdset="1"> + <name>sizePolicy</name> + <sizepolicy> + <hsizetype>7</hsizetype> + <vsizetype>1</vsizetype> + </sizepolicy> + </property> + <property stdset="1"> + <name>text</name> + <string>Select to manage your local Bluetooth hardware</string> + </property> + <property stdset="1"> + <name>alignment</name> + <set>WordBreak|AlignVCenter|AlignLeft</set> + </property> + <property> + <name>wordwrap</name> + </property> + </widget> + <widget row="4" column="1" rowspan="1" colspan="4" > + <class>QLabel</class> + <property stdset="1"> + <name>name</name> + <cstring>TextLabel1_2</cstring> + </property> + <property stdset="1"> + <name>sizePolicy</name> + <sizepolicy> + <hsizetype>7</hsizetype> + <vsizetype>1</vsizetype> + </sizepolicy> + </property> + <property stdset="1"> + <name>text</name> + <string>Select to scan the bluetooth network for reachable devices using the selected local device</string> + </property> + <property stdset="1"> + <name>alignment</name> + <set>WordBreak|AlignVCenter|AlignLeft</set> + </property> + <property> + <name>wordwrap</name> + </property> + </widget> + <spacer row="3" column="0" rowspan="1" colspan="2" > + <property> + <name>name</name> + <cstring>Spacer4</cstring> + </property> + <property stdset="1"> + <name>orientation</name> + <enum>Horizontal</enum> + </property> + <property stdset="1"> + <name>sizeType</name> + <enum>Expanding</enum> + </property> + <property> + <name>sizeHint</name> + <size> + <width>20</width> + <height>20</height> + </size> + </property> + </spacer> + <widget row="3" column="3" rowspan="1" colspan="2" > + <class>QComboBox</class> + <property stdset="1"> + <name>name</name> + <cstring>DeviceList_CB</cstring> + </property> + <property stdset="1"> + <name>sizePolicy</name> + <sizepolicy> + <hsizetype>7</hsizetype> + <vsizetype>0</vsizetype> + </sizepolicy> + </property> + </widget> + <widget row="6" column="1" rowspan="1" colspan="4" > + <class>QLabel</class> + <property stdset="1"> + <name>name</name> + <cstring>TextLabel1_2_2</cstring> + </property> + <property stdset="1"> + <name>sizePolicy</name> + <sizepolicy> + <hsizetype>7</hsizetype> + <vsizetype>1</vsizetype> + </sizepolicy> + </property> + <property stdset="1"> + <name>text</name> + <string>Select to manage all pairings known on the local device to any remote device regardless if it is currently reachable or not</string> + </property> + <property stdset="1"> + <name>alignment</name> + <set>WordBreak|AlignVCenter|AlignLeft</set> + </property> + <property> + <name>wordwrap</name> + </property> + </widget> + <spacer row="2" column="4" > + <property> + <name>name</name> + <cstring>Spacer5_2</cstring> + </property> + <property stdset="1"> + <name>orientation</name> + <enum>Horizontal</enum> + </property> + <property stdset="1"> + <name>sizeType</name> + <enum>Expanding</enum> + </property> + <property> + <name>sizeHint</name> + <size> + <width>20</width> + <height>20</height> + </size> + </property> + </spacer> + <widget row="2" column="0" rowspan="1" colspan="4" > + <class>QPushButton</class> + <property stdset="1"> + <name>name</name> + <cstring>Scan_But</cstring> + </property> + <property stdset="1"> + <name>text</name> + <string>Scan Neighbourhood</string> + </property> + </widget> + <widget row="5" column="0" rowspan="1" colspan="4" > + <class>QPushButton</class> + <property stdset="1"> + <name>name</name> + <cstring>Pairing_But</cstring> + </property> + <property stdset="1"> + <name>text</name> + <string>Manage Pairing</string> + </property> + </widget> + <widget row="0" column="0" rowspan="1" colspan="4" > + <class>QPushButton</class> + <property stdset="1"> + <name>name</name> + <cstring>ManageLocalHW_But</cstring> + </property> + <property stdset="1"> + <name>text</name> + <string>Local Bluetooth hardware</string> + </property> + </widget> + <spacer row="0" column="4" > + <property> + <name>name</name> + <cstring>Spacer5_2_2</cstring> + </property> + <property stdset="1"> + <name>orientation</name> + <enum>Horizontal</enum> + </property> + <property stdset="1"> + <name>sizeType</name> + <enum>Expanding</enum> + </property> + <property> + <name>sizeHint</name> + <size> + <width>20</width> + <height>20</height> + </size> + </property> + </spacer> + </grid> +</widget> +<connections> + <connection> + <sender>ManageLocalHW_But</sender> + <signal>clicked()</signal> + <receiver>OTMainGUI</receiver> + <slot>SLOT_Manage()</slot> + </connection> + <connection> + <sender>Scan_But</sender> + <signal>clicked()</signal> + <receiver>OTMainGUI</receiver> + <slot>SLOT_Scan()</slot> + </connection> + <connection> + <sender>MustBeEnabled_CB</sender> + <signal>toggled(bool)</signal> + <receiver>OTMainGUI</receiver> + <slot>SLOT_EnableBluetooth(bool)</slot> + </connection> + <connection> + <sender>Pairing_But</sender> + <signal>clicked()</signal> + <receiver>OTMainGUI</receiver> + <slot>SLOT_Pairing()</slot> + </connection> + <slot access="public">SLOT_EnableBluetooth(bool)</slot> + <slot access="public">SLOT_Manage()</slot> + <slot access="public">SLOT_Scan()</slot> + <slot access="public">SLOT_Pairing()</slot> +</connections> +</UI> diff --git a/pics/networksettings2/Devices/ppp-large.png b/pics/networksettings2/Devices/ppp-large.png Binary files differindex ca41693..cfb9129 100644 --- a/pics/networksettings2/Devices/ppp-large.png +++ b/pics/networksettings2/Devices/ppp-large.png diff --git a/pics/networksettings2/Devices/ppp.png b/pics/networksettings2/Devices/ppp.png Binary files differindex 4271e18..9de4c89 100644 --- a/pics/networksettings2/Devices/ppp.png +++ b/pics/networksettings2/Devices/ppp.png diff --git a/pics/networksettings2/check.png b/pics/networksettings2/check.png Binary files differindex 4ed65a9..c52af91 100644 --- a/pics/networksettings2/check.png +++ b/pics/networksettings2/check.png diff --git a/pics/opietooth/connected.png b/pics/opietooth/connected.png Binary files differindex 4ba4084..9465e0e 100644 --- a/pics/opietooth/connected.png +++ b/pics/opietooth/connected.png diff --git a/pics/opietooth/notconnected.png b/pics/opietooth/notconnected.png Binary files differindex c964fa3..0b752fc 100644 --- a/pics/opietooth/notconnected.png +++ b/pics/opietooth/notconnected.png |
