void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
{
Q_Q(QBluetoothSocket);
Q_UNUSED(openMode);
TBTSockAddr a;
if(address.isNull())
{
socketError = QBluetoothSocket::UnknownSocketError;
emit q->error(socketError);
return;
}
TInt err = KErrNone;
a.SetPort(port);
// Trap TBTDevAddr constructor which may panic
TRAP(err, a.SetBTAddr(TBTDevAddr(address.toUInt64())));
if(err == KErrNone)
err = iSocket->Connect(a);
if (err == KErrNone) {
q->setSocketState(QBluetoothSocket::ConnectingState);
} else {
socketError = QBluetoothSocket::UnknownSocketError;
emit q->error(socketError);
}
}
void tst_QBluetoothHostInfo::tst_construction()
{
QFETCH(QString, btAddress);
QFETCH(QString, name);
QFETCH(bool, validBtAddress);
QBluetoothAddress empty;
QVERIFY(empty.isNull());
QBluetoothHostInfo setter;
QBluetoothAddress addr(btAddress);
setter.setName(name);
setter.setAddress(addr);
QCOMPARE(setter.name(), name);
QCOMPARE(setter.address().toString(), btAddress);
QCOMPARE(setter.address().isNull(), !validBtAddress);
setter.setAddress(empty);
QCOMPARE(setter.name(), name);
QCOMPARE(setter.address().toString(), QString("00:00:00:00:00:00"));
QCOMPARE(setter.address().isNull(), true);
setter.setName(QString());
QCOMPARE(setter.name(), QString());
QCOMPARE(setter.address().toString(), QString("00:00:00:00:00:00"));
QCOMPARE(setter.address().isNull(), true);
setter.setAddress(addr);
QCOMPARE(setter.name(), QString());
QCOMPARE(setter.address().toString(), btAddress);
QCOMPARE(setter.address().isNull(), !validBtAddress);
}
void tst_QBluetoothAddress::tst_construction()
{
QFETCH(quint64, addressUInt);
QFETCH(QString, addressS12);
QFETCH(QString, addressS17);
{
QBluetoothAddress address;
QVERIFY(address.isNull());
}
{
/* construct from quint64 */
QBluetoothAddress address(addressUInt);
QVERIFY(!address.isNull());
QVERIFY(address.toUInt64() == addressUInt);
QCOMPARE(address.toString(), addressS17);
}
{
/* construct from string without colons */
QBluetoothAddress address(addressS12);
QVERIFY(!address.isNull());
QVERIFY(address.toUInt64() == addressUInt);
QCOMPARE(address.toString(), addressS17);
}
{
/* construct from string with colons */
QBluetoothAddress address(addressS17);
QVERIFY(!address.isNull());
QVERIFY(address.toUInt64() == addressUInt);
QCOMPARE(address.toString(), addressS17);
}
{
QString empty;
QBluetoothAddress address(empty);
QVERIFY(address.isNull());
}
{
QBluetoothAddress address(addressUInt);
QBluetoothAddress copy(address);
QVERIFY(address.toUInt64() == copy.toUInt64());
}
}
QString QBluetoothSocketPrivate::localName() const
{
const QBluetoothAddress address = localAddress();
if (address.isNull())
return QString();
QBluetoothLocalDevice device(address);
return device.name();
}
/*!
Sets the remote device address to \a address. If \a address is default constructed,
services will be discovered on all contactable Bluetooth devices. A new remote
address can only be set while there is no service discovery in progress; otherwise
this function returns false.
On some platforms such as Blackberry the service discovery might lead to pairing requests.
Therefore it is not recommended to do service discoveries on all devices.
\sa remoteAddress()
*/
bool QBluetoothServiceDiscoveryAgent::setRemoteAddress(const QBluetoothAddress &address)
{
if (isActive())
return false;
if (!address.isNull())
d_ptr->singleDevice = true;
d_ptr->deviceAddress = address;
return true;
}
/*!
Finds the path for the local adapter with \a wantedAddress or an empty string
if no local adapter with the given address can be found.
If \a wantedAddress is \c null it returns the first/default adapter or an empty
string if none is available.
If \a ok is false the lookup was aborted due to a dbus error and this function
returns an empty string.
*/
QString findAdapterForAddress(const QBluetoothAddress &wantedAddress, bool *ok = 0)
{
OrgFreedesktopDBusObjectManagerInterface manager(QStringLiteral("org.bluez"),
QStringLiteral("/"),
QDBusConnection::systemBus());
QDBusPendingReply<ManagedObjectList> reply = manager.GetManagedObjects();
reply.waitForFinished();
if (reply.isError()) {
if (ok)
*ok = false;
return QString();
}
typedef QPair<QString, QBluetoothAddress> AddressForPathType;
QList<AddressForPathType> localAdapters;
ManagedObjectList managedObjectList = reply.value();
for (ManagedObjectList::const_iterator it = managedObjectList.constBegin(); it != managedObjectList.constEnd(); ++it) {
const QDBusObjectPath &path = it.key();
const InterfaceList &ifaceList = it.value();
for (InterfaceList::const_iterator jt = ifaceList.constBegin(); jt != ifaceList.constEnd(); ++jt) {
const QString &iface = jt.key();
if (iface == QStringLiteral("org.bluez.Adapter1")) {
AddressForPathType pair;
pair.first = path.path();
pair.second = QBluetoothAddress(ifaceList.value(iface).value(
QStringLiteral("Address")).toString());
if (!pair.second.isNull())
localAdapters.append(pair);
break;
}
}
}
if (ok)
*ok = true;
if (localAdapters.isEmpty())
return QString(); // -> no local adapter found
if (wantedAddress.isNull())
return localAdapters.front().first; // -> return first found adapter
foreach (const AddressForPathType &pair, localAdapters) {
if (pair.second == wantedAddress)
return pair.first; // -> found local adapter with wanted address
}
return QString(); // nothing matching found
}
void HciManager::handleHciEventPacket(const quint8 *data, int size)
{
if (size < HCI_EVENT_HDR_SIZE) {
qCWarning(QT_BT_BLUEZ) << "Unexpected HCI event packet size:" << size;
return;
}
hci_event_hdr *header = (hci_event_hdr *) data;
size -= HCI_EVENT_HDR_SIZE;
data += HCI_EVENT_HDR_SIZE;
if (header->plen != size) {
qCWarning(QT_BT_BLUEZ) << "Invalid HCI event packet size";
return;
}
qCDebug(QT_BT_BLUEZ) << "HCI event triggered, type:" << hex << header->evt;
switch (header->evt) {
case EVT_ENCRYPT_CHANGE:
{
const evt_encrypt_change *event = (evt_encrypt_change *) data;
qCDebug(QT_BT_BLUEZ) << "HCI Encrypt change, status:"
<< (event->status == 0 ? "Success" : "Failed")
<< "handle:" << hex << event->handle
<< "encrypt:" << event->encrypt;
QBluetoothAddress remoteDevice = addressForConnectionHandle(event->handle);
if (!remoteDevice.isNull())
emit encryptionChangedEvent(remoteDevice, event->status == 0);
}
break;
case EVT_CMD_COMPLETE: {
auto * const event = reinterpret_cast<const evt_cmd_complete *>(data);
static_assert(sizeof *event == 3, "unexpected struct size");
// There is always a status byte right after the generic structure.
Q_ASSERT(size > static_cast<int>(sizeof *event));
const quint8 status = data[sizeof *event];
const auto additionalData = QByteArray(reinterpret_cast<const char *>(data)
+ sizeof *event + 1, size - sizeof *event - 1);
emit commandCompleted(event->opcode, status, additionalData);
}
break;
case LeMetaEvent:
handleLeMetaEvent(data);
break;
default:
break;
}
}
/*!
* Process all incoming HCI events. Function cannot process anything else but events.
*/
void HciManager::_q_readNotify()
{
unsigned char buffer[HCI_MAX_EVENT_SIZE];
int size;
size = ::read(hciSocket, buffer, sizeof(buffer));
if (size < 0) {
if (errno != EAGAIN && errno != EINTR)
qCWarning(QT_BT_BLUEZ) << "Failed reading HCI events:" << qt_error_string(errno);
return;
}
const unsigned char *data = buffer;
// Not interested in anything but valid HCI events
if ((size < HCI_EVENT_HDR_SIZE + 1) || buffer[0] != HCI_EVENT_PKT)
return;
hci_event_hdr *header = (hci_event_hdr *)(&buffer[1]);
size = size - HCI_EVENT_HDR_SIZE - 1;
data = data + HCI_EVENT_HDR_SIZE + 1;
if (header->plen != size) {
qCWarning(QT_BT_BLUEZ) << "Invalid HCI event packet size";
return;
}
qCDebug(QT_BT_BLUEZ) << "HCI event triggered, type:" << hex << header->evt;
switch (header->evt) {
case EVT_ENCRYPT_CHANGE:
{
const evt_encrypt_change *event = (evt_encrypt_change *) data;
qCDebug(QT_BT_BLUEZ) << "HCI Encrypt change, status:"
<< (event->status == 0 ? "Success" : "Failed")
<< "handle:" << hex << event->handle
<< "encrypt:" << event->encrypt;
QBluetoothAddress remoteDevice = addressForConnectionHandle(event->handle);
if (!remoteDevice.isNull())
emit encryptionChangedEvent(remoteDevice, event->status == 0);
}
break;
default:
break;
}
}
/*!
Constructs a new QBluetoothServiceDiscoveryAgent for \a deviceAdapter and with \a parent.
It uses \a deviceAdapter for the service search. If \a deviceAdapter is default constructed
the resulting QBluetoothServiceDiscoveryAgent object will use the local default Bluetooth adapter.
If a \a deviceAdapter is specified that is not a local adapter \l error() will be set to
\l InvalidBluetoothAdapterError. Therefore it is recommended to test the error flag immediately after
using this constructor.
\sa error()
*/
QBluetoothServiceDiscoveryAgent::QBluetoothServiceDiscoveryAgent(const QBluetoothAddress &deviceAdapter, QObject *parent)
: QObject(parent), d_ptr(new QBluetoothServiceDiscoveryAgentPrivate(deviceAdapter))
{
d_ptr->q_ptr = this;
if (!deviceAdapter.isNull()) {
const QList<QBluetoothHostInfo> localDevices = QBluetoothLocalDevice::allDevices();
foreach (const QBluetoothHostInfo &hostInfo, localDevices) {
if (hostInfo.address() == deviceAdapter)
return;
}
d_ptr->error = InvalidBluetoothAdapterError;
d_ptr->errorString = tr("Invalid Bluetooth adapter address");
}
}
void tst_QBluetoothHostInfo::tst_address()
{
QFETCH(QString, addressString);
QBluetoothAddress address(addressString);
QVERIFY(!address.isNull());
QCOMPARE(address.toString(), addressString);
QBluetoothHostInfo info;
QBluetoothAddress result = info.address();
QVERIFY(result.isNull());
info.setAddress(address);
QCOMPARE(info.address().toString(), addressString);
}
void QBluetoothLocalDevice::requestPairing(const QBluetoothAddress &address, Pairing pairing)
{
if (address.isNull()) {
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error,
QBluetoothLocalDevice::PairingError));
return;
}
const Pairing current_pairing = pairingStatus(address);
if (current_pairing == pairing) {
QMetaObject::invokeMethod(this, "pairingFinished", Qt::QueuedConnection,
Q_ARG(QBluetoothAddress, address),
Q_ARG(QBluetoothLocalDevice::Pairing, pairing));
return;
}
d_ptr->requestPairing(address, pairing);
}
int HciManager::hciForAddress(const QBluetoothAddress &deviceAdapter)
{
if (hciSocket < 0)
return -1;
bdaddr_t adapter;
convertAddress(deviceAdapter.toUInt64(), adapter.b);
struct hci_dev_req *devRequest = 0;
struct hci_dev_list_req *devRequestList = 0;
struct hci_dev_info devInfo;
const int devListSize = sizeof(struct hci_dev_list_req)
+ HCI_MAX_DEV * sizeof(struct hci_dev_req);
devRequestList = (hci_dev_list_req *) malloc(devListSize);
if (!devRequestList)
return -1;
QScopedPointer<hci_dev_list_req, QScopedPointerPodDeleter> p(devRequestList);
memset(p.data(), 0, devListSize);
p->dev_num = HCI_MAX_DEV;
devRequest = p->dev_req;
if (ioctl(hciSocket, HCIGETDEVLIST, devRequestList) < 0)
return -1;
for (int i = 0; i < devRequestList->dev_num; i++) {
devInfo.dev_id = (devRequest+i)->dev_id;
if (ioctl(hciSocket, HCIGETDEVINFO, &devInfo) < 0) {
continue;
}
int result = memcmp(&adapter, &devInfo.bdaddr, sizeof(bdaddr_t));
if (result == 0 || deviceAdapter.isNull()) // addresses match
return devInfo.dev_id;
}
return -1;
}
QBluetoothLocalDevice::Pairing QBluetoothLocalDevice::pairingStatus(const QBluetoothAddress &address) const
{
if (address.isNull())
return Unpaired;
OrgBluezDeviceInterface *device = getDevice(address, d_ptr);
if(!device)
return Unpaired;
QDBusPendingReply<QVariantMap> deviceReply = device->GetProperties();
deviceReply.waitForFinished();
if (deviceReply.isError())
return Unpaired;
QVariantMap map = deviceReply.value();
if (map.value(QLatin1String("Trusted")).toBool() && map.value(QLatin1String("Paired")).toBool())
return AuthorizedPaired;
else if (map.value(QLatin1String("Paired")).toBool())
return Paired;
else
return Unpaired;
}
void QBluetoothServiceDiscoveryAgentPrivate::_q_processFetchedUuids(
const QBluetoothAddress &address, const QList<QBluetoothUuid> &uuids)
{
//don't leave more data through if we are not interested anymore
if (discoveredDevices.count() == 0)
return;
//could not find any service for the current address/device -> go to next one
if (address.isNull() || uuids.isEmpty()) {
_q_serviceDiscoveryFinished();
return;
}
if (QT_BT_ANDROID().isDebugEnabled()) {
qCDebug(QT_BT_ANDROID) << "Found UUID for" << address.toString()
<< "\ncount: " << uuids.count();
QString result;
for (int i = 0; i<uuids.count(); i++)
result += uuids.at(i).toString() + QStringLiteral("**");
qCDebug(QT_BT_ANDROID) << result;
}
/* In general there are two uuid events per device.
* We'll wait for the second event to arrive before we process the UUIDs.
* We utilize a timeout to catch cases when the second
* event doesn't arrive at all.
* Generally we assume that the second uuid event carries the most up-to-date
* set of uuids and discard the first events results.
*/
if (sdpCache.contains(address)) {
//second event
QPair<QBluetoothDeviceInfo,QList<QBluetoothUuid> > pair = sdpCache.take(address);
//prefer second uuid set over first
populateDiscoveredServices(pair.first, uuids);
if (discoveredDevices.count() == 1 && sdpCache.isEmpty()) {
//last regular uuid data set from OS -> we finish here
_q_serviceDiscoveryFinished();
}
} else {
//first event
QPair<QBluetoothDeviceInfo,QList<QBluetoothUuid> > pair;
pair.first = discoveredDevices.at(0);
pair.second = uuids;
if (pair.first.address() != address)
return;
sdpCache.insert(address, pair);
//the discovery on the last device cannot immediately finish
//we have to grant the 2 seconds timeout delay
if (discoveredDevices.count() == 1) {
Q_Q(QBluetoothServiceDiscoveryAgent);
QTimer::singleShot(4000, q, SLOT(_q_fetchUuidsTimeout()));
return;
}
_q_serviceDiscoveryFinished();
}
}
bool QRfcommServer::listen(const QBluetoothAddress &address, quint16 port)
{
Q_D(QRfcommServer);
// listen has already been called before
if(d->socket)
return true;
d->socket = new QBluetoothSocket(QBluetoothSocket::RfcommSocket,this);
if(!d->socket)
{
return false;
}
d->ds = d->socket->d_ptr;
if(!d->ds)
{
delete d->socket;
d->socket = 0;
return false;
}
d->ds->ensureNativeSocket(QBluetoothSocket::RfcommSocket);
TRfcommSockAddr addr;
if(!address.isNull())
{
// TBTDevAddr constructor may panic
TRAPD(err,addr.SetBTAddr(TBTDevAddr(address.toUInt64())));
if(err != KErrNone)
{
delete d->socket;
d->socket = 0;
return false;
}
}
if (port == 0)
addr.SetPort(KRfcommPassiveAutoBind);
else
addr.SetPort(port);
TBTServiceSecurity security;
switch (d->securityFlags) {
case QBluetooth::Authentication:
security.SetAuthentication(EMitmDesired);
break;
case QBluetooth::Authorization:
security.SetAuthorisation(ETrue);
break;
case QBluetooth::Encryption:
// "Secure" is BlueZ specific we just make sure the code remain compatible
case QBluetooth::Secure:
// authentication required
security.SetAuthentication(EMitmDesired);
security.SetEncryption(ETrue);
break;
case QBluetooth::NoSecurity:
default:
break;
}
if(d->ds->iSocket->Bind(addr) == KErrNone)
{
d->socket->setSocketState(QBluetoothSocket::BoundState);
}
else
{
delete d->socket;
d->socket = 0;
return false;
}
if(d->ds->iSocket->Listen(d->maxPendingConnections) != KErrNone)
{
delete d->socket;
d->socket = 0;
return false;
}
QBluetoothSocket *pendingSocket = new QBluetoothSocket(QBluetoothSocket::UnknownSocketType, this);
if(!pendingSocket)
{
delete d->socket;
d->socket = 0;
return false;
}
QBluetoothSocketPrivate *pd = pendingSocket->d_ptr;
pd->ensureBlankNativeSocket(QBluetoothSocket::RfcommSocket);
connect(d->socket, SIGNAL(disconnected()), this, SLOT(_q_disconnected()));
connect(d->socket, SIGNAL(connected()), this, SLOT(_q_connected()));
connect(d->socket, SIGNAL(error(QBluetoothSocket::SocketError)), this, SLOT(_q_socketError(QBluetoothSocket::SocketError)));
if (d->ds->iSocket->Accept(*pd->iSocket) == KErrNone)
{
d->socket->setSocketState(QBluetoothSocket::ListeningState);
d->activeSockets.append(pendingSocket);
return true;
}
else
{
delete d->socket, pendingSocket;
d->socket = 0;
return false;
}
}
void QBluetoothLocalDevice::requestPairing(const QBluetoothAddress &address, Pairing pairing)
{
if (address.isNull()) {
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error, QBluetoothLocalDevice::PairingError));
return;
}
const Pairing current_pairing = pairingStatus(address);
if (current_pairing == pairing) {
QMetaObject::invokeMethod(this, "pairingFinished", Qt::QueuedConnection, Q_ARG(QBluetoothAddress, address),
Q_ARG(QBluetoothLocalDevice::Pairing, pairing));
return;
}
if(pairing == Paired || pairing == AuthorizedPaired) {
d_ptr->address = address;
d_ptr->pairing = pairing;
if(!d_ptr->agent) {
d_ptr->agent = new OrgBluezAgentAdaptor(d_ptr);
bool res = QDBusConnection::systemBus().registerObject(d_ptr->agent_path, d_ptr);
if(!res) {
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error, QBluetoothLocalDevice::PairingError));
qWarning() << "Failed to register agent";
return;
}
}
if(current_pairing == Paired && pairing == AuthorizedPaired) {
OrgBluezDeviceInterface *device = getDevice(address, d_ptr);
if (!device) {
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error, QBluetoothLocalDevice::PairingError));
return;
}
QDBusPendingReply<> deviceReply = device->SetProperty(QLatin1String("Trusted"), QDBusVariant(true));
deviceReply.waitForFinished();
if(deviceReply.isError()) {
qWarning() << Q_FUNC_INFO << "reply failed" << deviceReply.error();
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error, QBluetoothLocalDevice::PairingError));
return;
}
delete device;
QMetaObject::invokeMethod(this, "pairingFinished", Qt::QueuedConnection, Q_ARG(QBluetoothAddress, address),
Q_ARG(QBluetoothLocalDevice::Pairing, QBluetoothLocalDevice::AuthorizedPaired));
}
else if(current_pairing == AuthorizedPaired && pairing == Paired) {
OrgBluezDeviceInterface *device = getDevice(address, d_ptr);
if (!device) {
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error, QBluetoothLocalDevice::PairingError));
return;
}
QDBusPendingReply<> deviceReply = device->SetProperty(QLatin1String("Trusted"), QDBusVariant(false));
deviceReply.waitForFinished();
if(deviceReply.isError()) {
qWarning() << Q_FUNC_INFO << "reply failed" << deviceReply.error();
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error, QBluetoothLocalDevice::PairingError));
return;
}
delete device;
QMetaObject::invokeMethod(this, "pairingFinished", Qt::QueuedConnection, Q_ARG(QBluetoothAddress, address),
Q_ARG(QBluetoothLocalDevice::Pairing, QBluetoothLocalDevice::Paired));
}
else {
QDBusPendingReply<QDBusObjectPath> reply =
d_ptr->adapter->CreatePairedDevice(address.toString(),
QDBusObjectPath(d_ptr->agent_path),
QLatin1String("NoInputNoOutput"));
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this);
connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), d_ptr, SLOT(pairingCompleted(QDBusPendingCallWatcher*)));
if(reply.isError())
qWarning() << Q_FUNC_INFO << reply.error() << d_ptr->agent_path;
}
}
else if(pairing == Unpaired) {
QDBusPendingReply<QDBusObjectPath> reply = this->d_ptr->adapter->FindDevice(address.toString());
reply.waitForFinished();
if(reply.isError()) {
qWarning() << Q_FUNC_INFO << "failed to find device" << reply.error();
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error, QBluetoothLocalDevice::PairingError));
return;
}
QDBusPendingReply<> removeReply = this->d_ptr->adapter->RemoveDevice(reply.value());
removeReply.waitForFinished();
if(removeReply.isError()) {
qWarning() << Q_FUNC_INFO << "failed to remove device" << removeReply.error();
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QBluetoothLocalDevice::Error, QBluetoothLocalDevice::PairingError));
} else {
QMetaObject::invokeMethod(this, "pairingFinished", Qt::QueuedConnection, Q_ARG(QBluetoothAddress, address),
Q_ARG(QBluetoothLocalDevice::Pairing, QBluetoothLocalDevice::Unpaired));
}
}
return;
}
