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_QBluetoothAddress::tst_assignment()
{
QBluetoothAddress address(Q_UINT64_C(0x112233445566));
{
QBluetoothAddress copy = address;
QCOMPARE(address.toUInt64(), copy.toUInt64());
}
{
QBluetoothAddress copy1;
QBluetoothAddress copy2;
QVERIFY(copy1.isNull());
QVERIFY(copy2.isNull());
copy1 = copy2 = address;
QVERIFY(!copy1.isNull());
QVERIFY(!copy2.isNull());
QVERIFY(address.toUInt64() == copy1.toUInt64());
QVERIFY(address.toUInt64() == copy2.toUInt64());
copy1.clear();
QVERIFY(copy1.isNull());
QVERIFY2(copy1 != address, "Verify that copy1 is a copy of address, the d_ptr are being copied");
}
}
void QBluetoothServiceDiscoveryAgentPrivate::initL(const QBluetoothAddress &address)
{
TBTDevAddr btAddress(address.toUInt64());
stop();
//Trapped in Start
m_sdpAgent = q_check_ptr(CSdpAgent::NewL(*this, btAddress));
m_filter = q_check_ptr(CSdpSearchPattern::NewL());
m_attributes = q_check_ptr(CSdpAttrIdMatchList::NewL());
m_attributes->AddL(KAttrRangeAll);
}
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;
}
void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
{
Q_Q(QBluetoothSocket);
int result = -1;
if (socket == -1 && !ensureNativeSocket(socketType)) {
errorString = QBluetoothSocket::tr("Unknown socket error");
q->setSocketError(QBluetoothSocket::UnknownSocketError);
return;
}
if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
sockaddr_rc addr;
memset(&addr, 0, sizeof(addr));
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = port;
convertAddress(address.toUInt64(), addr.rc_bdaddr.b);
connectWriteNotifier->setEnabled(true);
readNotifier->setEnabled(true);QString();
result = ::connect(socket, (sockaddr *)&addr, sizeof(addr));
} else if (socketType == QBluetoothServiceInfo::L2capProtocol) {
sockaddr_l2 addr;
memset(&addr, 0, sizeof(addr));
addr.l2_family = AF_BLUETOOTH;
// This is an ugly hack but the socket class does what's needed already.
// For L2CP GATT we need a channel rather than a socket and the LE address type
// We don't want to make this public API offering for now especially since
// only Linux (of all platforms supported by this library) supports this type
// of socket.
#if defined(QT_BLUEZ_BLUETOOTH) && !defined(QT_BLUEZ_NO_BTLE)
if (lowEnergySocketType) {
addr.l2_cid = htobs(port);
addr.l2_bdaddr_type = lowEnergySocketType;
} else {
addr.l2_psm = htobs(port);
}
#else
addr.l2_psm = htobs(port);
#endif
convertAddress(address.toUInt64(), addr.l2_bdaddr.b);
connectWriteNotifier->setEnabled(true);
readNotifier->setEnabled(true);
result = ::connect(socket, (sockaddr *)&addr, sizeof(addr));
}
if (result >= 0 || (result == -1 && errno == EINPROGRESS)) {
connecting = true;
q->setSocketState(QBluetoothSocket::ConnectingState);
q->setOpenMode(openMode);
} else {
errorString = qt_error_string(errno);
q->setSocketError(QBluetoothSocket::UnknownSocketError);
}
}
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;
}
}
