Revision control
++ // Copyright (C) 2022 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qbluetoothservicediscoveryagent.h"
++ // The order is important (the first header contains
++ // the base class for a private socket) - workaround for
++ // dependencies problem.
++ #include "qbluetoothsocketbase_p.h"
++ #include "qbluetoothsocket_macos_p.h"
++
++ #include "darwin/btrfcommchannel_p.h"
++ #include "darwin/btl2capchannel_p.h"
++ #include "qbluetoothlocaldevice.h"
++ #include "qbluetoothdeviceinfo.h"
++ #include "darwin/btutility_p.h"
++ #include "darwin/uistrings_p.h"
++ #include "qbluetoothsocket.h"
++
++ #include <QtCore/qloggingcategory.h>
++ #include <QtCore/qcoreapplication.h>
++ #include <QtCore/qmetaobject.h>
++ #include <QtCore/q26numeric.h>
++
++ #include <algorithm>
++ #include <limits>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace {
++
++ using DarwinBluetooth::RetainPolicy;
++
++ } // unnamed namespace
++
++ QBluetoothSocketPrivateDarwin::QBluetoothSocketPrivateDarwin(QBluetoothSocket *qq)
++ : QBluetoothSocketBasePrivate{qq},
++ writeChunk(std::numeric_limits<UInt16>::max())
++ {
++ }
++
++ QBluetoothSocketPrivateDarwin::~QBluetoothSocketPrivateDarwin()
++ {
++ }
++
++ bool QBluetoothSocketPrivateDarwin::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
++ {
++ // For now - very simplistic, we don't call it in this file, public class
++ // only calls it in a ctor, setting the protocol RFCOMM (in case of Android)
++ // or, indeed, doing, socket-related initialization in BlueZ backend.
++ Q_ASSERT(socketType == QBluetoothServiceInfo::UnknownProtocol);
++ socketType = type;
++ return type != QBluetoothServiceInfo::UnknownProtocol;
++ }
++
++ QString QBluetoothSocketPrivateDarwin::localName() const
++ {
++ const QBluetoothLocalDevice device;
++ return device.name();
++ }
++
++ QBluetoothAddress QBluetoothSocketPrivateDarwin::localAddress() const
++ {
++ const QBluetoothLocalDevice device;
++ return device.address();
++ }
++
++ quint16 QBluetoothSocketPrivateDarwin::localPort() const
++ {
++ return 0;
++ }
++
++ QString QBluetoothSocketPrivateDarwin::peerName() const
++ {
++ QT_BT_MAC_AUTORELEASEPOOL;
++
++ NSString *nsName = nil;
++ if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
++ if (rfcommChannel)
++ nsName = [rfcommChannel.getAs<DarwinBTRFCOMMChannel>() peerName];
++ } else if (socketType == QBluetoothServiceInfo::L2capProtocol) {
++ if (l2capChannel)
++ nsName = [l2capChannel.getAs<DarwinBTL2CAPChannel>() peerName];
++ }
++
++ if (nsName)
++ return QString::fromNSString(nsName);
++
++ return QString();
++ }
++
++ QBluetoothAddress QBluetoothSocketPrivateDarwin::peerAddress() const
++ {
++ BluetoothDeviceAddress addr = {};
++ if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
++ if (rfcommChannel)
++ addr = [rfcommChannel.getAs<DarwinBTRFCOMMChannel>() peerAddress];
++ } else if (socketType == QBluetoothServiceInfo::L2capProtocol) {
++ if (l2capChannel)
++ addr = [l2capChannel.getAs<DarwinBTL2CAPChannel>() peerAddress];
++ }
++
++ return DarwinBluetooth::qt_address(&addr);
++ }
++
++ quint16 QBluetoothSocketPrivateDarwin::peerPort() const
++ {
++ if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
++ if (rfcommChannel)
++ return [rfcommChannel.getAs<DarwinBTRFCOMMChannel>() getChannelID];
++ } else if (socketType == QBluetoothServiceInfo::L2capProtocol) {
++ if (l2capChannel)
++ return [l2capChannel.getAs<DarwinBTL2CAPChannel>() getPSM];
++ }
++
++ return 0;
++ }
++
++ void QBluetoothSocketPrivateDarwin::abort()
++ {
++ // Can never be called while we're in connectToService:
++ Q_ASSERT_X(!isConnecting, Q_FUNC_INFO, "internal inconsistency - "
++ "still in connectToService()");
++
++ if (socketType == QBluetoothServiceInfo::RfcommProtocol)
++ rfcommChannel.reset();
++ else if (socketType == QBluetoothServiceInfo::L2capProtocol)
++ l2capChannel.reset();
++
++ Q_ASSERT(q_ptr);
++
++ q_ptr->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
++ emit q_ptr->readChannelFinished();
++
++ }
++
++ void QBluetoothSocketPrivateDarwin::close()
++ {
++ // Can never be called while we're in connectToService:
++ Q_ASSERT_X(!isConnecting, Q_FUNC_INFO, "internal inconsistency - "
++ "still in connectToService()");
++
++ if (!txBuffer.size())
++ abort();
++ }
++
++
++ qint64 QBluetoothSocketPrivateDarwin::writeData(const char *data, qint64 maxSize)
++ {
++ Q_ASSERT_X(data, Q_FUNC_INFO, "invalid data (null)");
++ Q_ASSERT_X(maxSize > 0, Q_FUNC_INFO, "invalid data size");
++
++ if (state != QBluetoothSocket::SocketState::ConnectedState) {
++ errorString = QCoreApplication::translate(SOCKET, SOC_NOWRITE);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::OperationError);
++ return -1;
++ }
++
++ // We do not have a real socket API under the hood,
++ // IOBluetoothL2CAPChannel is buffered (writeAsync).
++
++ if (!txBuffer.size())
++ QMetaObject::invokeMethod(this, [this](){_q_writeNotify();}, Qt::QueuedConnection);
++
++ const int adjustedMaxSize = q26::saturate_cast<int>(maxSize);
++ char *dst = txBuffer.reserve(adjustedMaxSize);
++ std::copy(data, data + adjustedMaxSize, dst);
++
++ return adjustedMaxSize;
++ }
++
++ qint64 QBluetoothSocketPrivateDarwin::readData(char *data, qint64 maxSize)
++ {
++ if (!data)
++ return 0;
++
++ if (state != QBluetoothSocket::SocketState::ConnectedState) {
++ errorString = QCoreApplication::translate(SOCKET, SOC_NOREAD);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::OperationError);
++ return -1;
++ }
++
++ if (!rxBuffer.isEmpty())
++ return rxBuffer.read(data, int(maxSize));
++
++ return 0;
++ }
++
++ qint64 QBluetoothSocketPrivateDarwin::bytesAvailable() const
++ {
++ return rxBuffer.size();
++ }
++
++ bool QBluetoothSocketPrivateDarwin::canReadLine() const
++ {
++ return rxBuffer.canReadLine();
++ }
++
++ qint64 QBluetoothSocketPrivateDarwin::bytesToWrite() const
++ {
++ return txBuffer.size();
++ }
++
++ bool QBluetoothSocketPrivateDarwin::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
++ QBluetoothSocket::SocketState socketState, QIODevice::OpenMode openMode)
++ {
++ Q_UNUSED(socketDescriptor);
++ Q_UNUSED(socketType);
++ Q_UNUSED(socketState);
++ Q_UNUSED(openMode);
++
++ qCWarning(QT_BT_DARWIN) << "setting a socket descriptor is not supported by IOBluetooth";
++ // Noop on macOS.
++ return false;
++ }
++
++ void QBluetoothSocketPrivateDarwin::connectToServiceHelper(const QBluetoothAddress &address, quint16 port,
++ QIODevice::OpenMode openMode)
++ {
++ Q_UNUSED(address);
++ Q_UNUSED(port);
++ Q_UNUSED(openMode);
++ }
++
++ void QBluetoothSocketPrivateDarwin::connectToService(const QBluetoothServiceInfo &service, QIODevice::OpenMode openMode)
++ {
++ Q_ASSERT(q_ptr);
++
++ DarwinBluetooth::qt_test_iobluetooth_runloop();
++
++ if (state!= QBluetoothSocket::SocketState::UnconnectedState && state != QBluetoothSocket::SocketState::ServiceLookupState) {
++ qCWarning(QT_BT_DARWIN) << "called on a busy socket";
++ errorString = QCoreApplication::translate(SOCKET, SOC_CONNECT_IN_PROGRESS);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::OperationError);
++ return;
++ }
++
++ // Report this problem early, potentially avoid device discovery:
++ if (service.socketProtocol() == QBluetoothServiceInfo::UnknownProtocol) {
++ qCWarning(QT_BT_DARWIN) << Q_FUNC_INFO << "cannot connect with 'UnknownProtocol' type";
++ errorString = QCoreApplication::translate(SOCKET, SOC_NETWORK_ERROR);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::UnsupportedProtocolError);
++ return;
++ }
++
++ socketType = service.socketProtocol();
++
++ if (service.protocolServiceMultiplexer() > 0) {
++ connectToService(service.device().address(),
++ quint16(service.protocolServiceMultiplexer()),
++ openMode);
++ } else if (service.serverChannel() > 0) {
++ connectToService(service.device().address(),
++ quint16(service.serverChannel()),
++ openMode);
++ } else {
++ // Try service discovery.
++ if (service.serviceUuid().isNull()) {
++ qCWarning(QT_BT_DARWIN) << "No port, no PSM, and no "
++ "UUID provided, unable to connect";
++ return;
++ }
++
++ q_ptr->doDeviceDiscovery(service, openMode);
++ }
++ }
++
++ void QBluetoothSocketPrivateDarwin::connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
++ QIODevice::OpenMode openMode)
++ {
++ Q_ASSERT(q_ptr);
++
++ DarwinBluetooth::qt_test_iobluetooth_runloop();
++
++ // Report this problem early, avoid device discovery:
++ if (socketType == QBluetoothServiceInfo::UnknownProtocol) {
++ qCWarning(QT_BT_DARWIN) << Q_FUNC_INFO << "cannot connect with 'UnknownProtocol' type";
++ errorString = QCoreApplication::translate(SOCKET, SOC_NETWORK_ERROR);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::UnsupportedProtocolError);
++ return;
++ }
++
++ if (state != QBluetoothSocket::SocketState::UnconnectedState) {
++ qCWarning(QT_BT_DARWIN) << "called on a busy socket";
++ errorString = QCoreApplication::translate(SOCKET, SOC_CONNECT_IN_PROGRESS);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::OperationError);
++ return;
++ }
++
++ QBluetoothDeviceInfo device(address, QString(), QBluetoothDeviceInfo::MiscellaneousDevice);
++ QBluetoothServiceInfo service;
++ service.setDevice(device);
++ service.setServiceUuid(uuid);
++ q_ptr->doDeviceDiscovery(service, openMode);
++ }
++
++ void QBluetoothSocketPrivateDarwin::connectToService(const QBluetoothAddress &address, quint16 port,
++ QIODevice::OpenMode mode)
++ {
++ Q_ASSERT(q_ptr);
++
++ DarwinBluetooth::qt_test_iobluetooth_runloop();
++
++ if (socketType == QBluetoothServiceInfo::UnknownProtocol) {
++ qCWarning(QT_BT_DARWIN) << Q_FUNC_INFO << "cannot connect with 'UnknownProtocol' type";
++ errorString = QCoreApplication::translate(SOCKET, SOC_NETWORK_ERROR);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::UnsupportedProtocolError);
++ return;
++ }
++
++ Q_ASSERT_X(state == QBluetoothSocket::SocketState::ServiceLookupState || state == QBluetoothSocket::SocketState::UnconnectedState,
++ Q_FUNC_INFO, "invalid state");
++
++ q_ptr->setOpenMode(mode);
++
++ socketError = QBluetoothSocket::SocketError::NoSocketError;
++ errorString.clear();
++ rxBuffer.clear();
++ txBuffer.clear();
++
++ IOReturn status = kIOReturnError;
++ // Setting socket state on q_ptr will emit a signal,
++ // we'd like to avoid any signal until this function completes.
++ const QBluetoothSocket::SocketState oldState = state;
++ // To prevent other connectToService calls (from QBluetoothSocket):
++ // and also avoid signals in delegate callbacks.
++ state = QBluetoothSocket::SocketState::ConnectingState;
++ // We're still inside this function:
++ isConnecting = true;
++
++ // We'll later (or now) have to set an open mode on QBluetoothSocket.
++ openMode = mode;
++
++ if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
++ rfcommChannel.reset([[DarwinBTRFCOMMChannel alloc] initWithDelegate:this], RetainPolicy::noInitialRetain);
++ if (rfcommChannel)
++ status = [rfcommChannel.getAs<DarwinBTRFCOMMChannel>() connectAsyncToDevice:address withChannelID:port];
++ else
++ status = kIOReturnNoMemory;
++ } else if (socketType == QBluetoothServiceInfo::L2capProtocol) {
++ l2capChannel.reset([[DarwinBTL2CAPChannel alloc] initWithDelegate:this], RetainPolicy::noInitialRetain);
++ if (l2capChannel)
++ status = [l2capChannel.getAs<DarwinBTL2CAPChannel>() connectAsyncToDevice:address withPSM:port];
++ else
++ status = kIOReturnNoMemory;
++ }
++
++ // We're probably still connecting, but at least are leaving this function:
++ isConnecting = false;
++
++ // QBluetoothSocket will change the state and also emit
++ // a signal later if required.
++ if (status == kIOReturnSuccess && socketError == QBluetoothSocket::SocketError::NoSocketError) {
++ if (state == QBluetoothSocket::SocketState::ConnectedState) {
++ // Callback 'channelOpenComplete' fired before
++ // connectToService finished:
++ state = oldState;
++ // Connected, setOpenMode on a QBluetoothSocket.
++ q_ptr->setOpenMode(openMode);
++ q_ptr->setSocketState(QBluetoothSocket::SocketState::ConnectedState);
++ if (rxBuffer.size()) // We also have some data already ...
++ emit q_ptr->readyRead();
++ } else if (state == QBluetoothSocket::SocketState::UnconnectedState) {
++ // Even if we have some data, we can not read it if
++ // state != ConnectedState.
++ rxBuffer.clear();
++ state = oldState;
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::UnknownSocketError);
++ } else {
++ // No error and we're connecting ...
++ state = oldState;
++ q_ptr->setSocketState(QBluetoothSocket::SocketState::ConnectingState);
++ }
++ } else {
++ state = oldState;
++ if (status != kIOReturnSuccess)
++ errorString = DarwinBluetooth::qt_error_string(status);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::UnknownSocketError);
++ }
++ }
++
++ void QBluetoothSocketPrivateDarwin::_q_writeNotify()
++ {
++ Q_ASSERT_X(socketType == QBluetoothServiceInfo::L2capProtocol
++ || socketType == QBluetoothServiceInfo::RfcommProtocol,
++ Q_FUNC_INFO, "invalid socket type");
++ Q_ASSERT_X(l2capChannel || rfcommChannel, Q_FUNC_INFO,
++ "invalid socket (no open channel)");
++ Q_ASSERT_X(q_ptr, Q_FUNC_INFO, "invalid q_ptr (null)");
++
++ if (txBuffer.size()) {
++ const bool isL2CAP = socketType == QBluetoothServiceInfo::L2capProtocol;
++ writeChunk.resize(isL2CAP ? std::numeric_limits<UInt16>::max() :
++ [rfcommChannel.getAs<DarwinBTRFCOMMChannel>() getMTU]);
++
++ const auto size = txBuffer.read(writeChunk.data(), writeChunk.size());
++ IOReturn status = kIOReturnError;
++ if (!isL2CAP)
++ status = [rfcommChannel.getAs<DarwinBTRFCOMMChannel>() writeAsync:writeChunk.data() length:UInt16(size)];
++ else
++ status = [l2capChannel.getAs<DarwinBTL2CAPChannel>() writeAsync:writeChunk.data() length:UInt16(size)];
++
++ if (status != kIOReturnSuccess) {
++ errorString = QCoreApplication::translate(SOCKET, SOC_NETWORK_ERROR);
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::NetworkError);
++ return;
++ } else {
++ emit q_ptr->bytesWritten(size);
++ }
++ }
++
++ if (!txBuffer.size() && state == QBluetoothSocket::SocketState::ClosingState)
++ close();
++ }
++
++ bool QBluetoothSocketPrivateDarwin::setRFCOMChannel(void *generic)
++ {
++ // A special case "constructor": on OS X we do not have a real listening socket,
++ // instead a bluetooth server "listens" for channel open notifications and
++ // creates (if asked by a user later) a "socket" object
++ // for this connection. This function initializes
++ // a "socket" from such an external channel (reported by a notification).
++ auto channel = static_cast<IOBluetoothRFCOMMChannel *>(generic);
++ // It must be a newborn socket!
++ Q_ASSERT_X(socketError == QBluetoothSocket::SocketError::NoSocketError
++ && state == QBluetoothSocket::SocketState::UnconnectedState && !rfcommChannel && !l2capChannel,
++ Q_FUNC_INFO, "unexpected socket state");
++
++ openMode = QIODevice::ReadWrite;
++ rfcommChannel.reset([[DarwinBTRFCOMMChannel alloc] initWithDelegate:this channel:channel],
++ RetainPolicy::noInitialRetain);
++ if (rfcommChannel) {// We do not handle errors, up to an external user.
++ q_ptr->setOpenMode(QIODevice::ReadWrite);
++ state = QBluetoothSocket::SocketState::ConnectedState;
++ socketType = QBluetoothServiceInfo::RfcommProtocol;
++ }
++
++ return rfcommChannel;
++ }
++
++ bool QBluetoothSocketPrivateDarwin::setL2CAPChannel(void *generic)
++ {
++ // A special case "constructor": on OS X we do not have a real listening socket,
++ // instead a bluetooth server "listens" for channel open notifications and
++ // creates (if asked by a user later) a "socket" object
++ // for this connection. This function initializes
++ // a "socket" from such an external channel (reported by a notification).
++ auto channel = static_cast<IOBluetoothL2CAPChannel *>(generic);
++
++ // It must be a newborn socket!
++ Q_ASSERT_X(socketError == QBluetoothSocket::SocketError::NoSocketError
++ && state == QBluetoothSocket::SocketState::UnconnectedState && !l2capChannel && !rfcommChannel,
++ Q_FUNC_INFO, "unexpected socket state");
++
++ openMode = QIODevice::ReadWrite;
++ l2capChannel.reset([[DarwinBTL2CAPChannel alloc] initWithDelegate:this channel:channel], RetainPolicy::noInitialRetain);
++ if (l2capChannel) {// We do not handle errors, up to an external user.
++ q_ptr->setOpenMode(QIODevice::ReadWrite);
++ state = QBluetoothSocket::SocketState::ConnectedState;
++ socketType = QBluetoothServiceInfo::L2capProtocol;
++ }
++
++ return l2capChannel;
++ }
++
++ void QBluetoothSocketPrivateDarwin::setChannelError(IOReturn errorCode)
++ {
++ Q_UNUSED(errorCode);
++
++ Q_ASSERT_X(q_ptr, Q_FUNC_INFO, "invalid q_ptr (null)");
++
++ if (isConnecting) {
++ // The delegate's method was called while we are still in
++ // connectToService ... will emit a moment later.
++ socketError = QBluetoothSocket::SocketError::UnknownSocketError;
++ } else {
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::UnknownSocketError);
++ }
++ }
++
++ void QBluetoothSocketPrivateDarwin::channelOpenComplete()
++ {
++ Q_ASSERT_X(q_ptr, Q_FUNC_INFO, "invalid q_ptr (null)");
++
++ if (!isConnecting) {
++ q_ptr->setOpenMode(openMode);
++ q_ptr->setSocketState(QBluetoothSocket::SocketState::ConnectedState);
++ } else {
++ state = QBluetoothSocket::SocketState::ConnectedState;
++ // We are still in connectToService, it'll care
++ // about signals!
++ }
++ }
++
++ void QBluetoothSocketPrivateDarwin::channelClosed()
++ {
++ Q_ASSERT_X(q_ptr, Q_FUNC_INFO, "invalid q_ptr (null)");
++
++ // Channel was closed by IOBluetooth and we can not write any data
++ // (thus close/abort probably will not work).
++
++ if (!isConnecting) {
++ if (state == QBluetoothSocket::SocketState::ConnectedState)
++ q_ptr->setSocketError(QBluetoothSocket::SocketError::RemoteHostClosedError);
++ q_ptr->setOpenMode(QIODevice::NotOpen);
++ q_ptr->setSocketState(QBluetoothSocket::SocketState::UnconnectedState);
++ emit q_ptr->readChannelFinished();
++ } else {
++ state = QBluetoothSocket::SocketState::UnconnectedState;
++ // We are still in connectToService and do not want
++ // to emit any signals yet.
++ }
++ }
++
++ void QBluetoothSocketPrivateDarwin::readChannelData(void *data, std::size_t size)
++ {
++ Q_ASSERT_X(data, Q_FUNC_INFO, "invalid data (null)");
++ Q_ASSERT_X(size, Q_FUNC_INFO, "invalid data size (0)");
++ Q_ASSERT_X(q_ptr, Q_FUNC_INFO, "invalid q_ptr (null)");
++
++ const char *src = static_cast<char *>(data);
++
++ if (size > std::numeric_limits<int>::max())
++ qCWarning(QT_BT_DARWIN) << Q_FUNC_INFO << "Truncating the incoming data to INT_MAX";
++
++ const int adjustedSize = q26::saturate_cast<int>(size);
++ char *dst = rxBuffer.reserve(adjustedSize);
++ std::copy(src, src + adjustedSize, dst);
++
++ if (!isConnecting) {
++ // If we're still in connectToService, do not emit.
++ emit q_ptr->readyRead();
++ } // else connectToService must check and emit readyRead!
++ }
++
++ void QBluetoothSocketPrivateDarwin::writeComplete()
++ {
++ _q_writeNotify();
++ }
++
++ QT_END_NAMESPACE