1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
// Copyright (C) 2017 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 "qbluetoothserver.h"
#include "qbluetoothserver_p.h"
#include "qbluetoothsocket.h"
#include "qbluetoothlocaldevice.h"
#include "qbluetoothsocket_winrt_p.h"
#include "qbluetoothutils_winrt_p.h"
#include <QtCore/QLoggingCategory>
#include <QtCore/private/qfunctions_winrt_p.h>
#include <windows.networking.h>
#include <windows.networking.connectivity.h>
#include <windows.networking.sockets.h>
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
using namespace ABI::Windows::Devices;
using namespace ABI::Windows::Devices::Enumeration;
using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::Networking;
using namespace ABI::Windows::Networking::Sockets;
using namespace ABI::Windows::Networking::Connectivity;
typedef ITypedEventHandler<StreamSocketListener *, StreamSocketListenerConnectionReceivedEventArgs *> ClientConnectedHandler;
QT_BEGIN_NAMESPACE
Q_DECLARE_LOGGING_CATEGORY(QT_BT_WINDOWS)
QHash<QBluetoothServerPrivate *, int> __fakeServerPorts;
QBluetoothServerPrivate::QBluetoothServerPrivate(QBluetoothServiceInfo::Protocol sType,
QBluetoothServer *parent)
: serverType(sType), q_ptr(parent)
{
mainThreadCoInit(this);
}
QBluetoothServerPrivate::~QBluetoothServerPrivate()
{
deactivateActiveListening();
__fakeServerPorts.remove(this);
// If we do not reset that pointer, socketListener will go out of scope after CoUninitialize was
// called, which will lead to a crash.
socketListener = nullptr;
mainThreadCoUninit(this);
}
bool QBluetoothServerPrivate::isListening() const
{
return __fakeServerPorts.contains(const_cast<QBluetoothServerPrivate *>(this));
}
bool QBluetoothServerPrivate::initiateActiveListening(const QString &serviceName)
{
HStringReference serviceNameRef(reinterpret_cast<LPCWSTR>(serviceName.utf16()));
ComPtr<IAsyncAction> bindAction;
HRESULT hr = socketListener->BindServiceNameAsync(serviceNameRef.Get(), &bindAction);
Q_ASSERT_SUCCEEDED(hr);
hr = QWinRTFunctions::await(bindAction);
Q_ASSERT_SUCCEEDED(hr);
return true;
}
bool QBluetoothServerPrivate::deactivateActiveListening()
{
if (!isListening())
return true;
HRESULT hr;
hr = socketListener->remove_ConnectionReceived(connectionToken);
Q_ASSERT_SUCCEEDED(hr);
return true;
}
HRESULT QBluetoothServerPrivate::handleClientConnection(IStreamSocketListener *listener,
IStreamSocketListenerConnectionReceivedEventArgs *args)
{
Q_Q(QBluetoothServer);
if (!socketListener || socketListener.Get() != listener) {
qCDebug(QT_BT_WINDOWS) << "Accepting connection from wrong listener. We should not be here.";
Q_UNREACHABLE();
return S_OK;
}
HRESULT hr;
ComPtr<IStreamSocket> socket;
hr = args->get_Socket(&socket);
Q_ASSERT_SUCCEEDED(hr);
QMutexLocker locker(&pendingConnectionsMutex);
if (pendingConnections.size() < maxPendingConnections) {
qCDebug(QT_BT_WINDOWS) << "Accepting connection";
pendingConnections.append(socket);
locker.unlock();
q->newConnection();
} else {
qCDebug(QT_BT_WINDOWS) << "Refusing connection";
}
return S_OK;
}
void QBluetoothServer::close()
{
Q_D(QBluetoothServer);
d->deactivateActiveListening();
__fakeServerPorts.remove(d);
}
bool QBluetoothServer::listen(const QBluetoothAddress &address, quint16 port)
{
Q_UNUSED(address);
Q_D(QBluetoothServer);
if (serverType() != QBluetoothServiceInfo::RfcommProtocol) {
d->m_lastError = UnsupportedProtocolError;
emit errorOccurred(d->m_lastError);
return false;
}
if (isListening())
return false;
HRESULT hr = RoActivateInstance(HString::MakeReference(RuntimeClass_Windows_Networking_Sockets_StreamSocketListener).Get(),
&d->socketListener);
Q_ASSERT_SUCCEEDED(hr);
hr = d->socketListener->add_ConnectionReceived(Callback<ClientConnectedHandler>(d, &QBluetoothServerPrivate::handleClientConnection).Get(),
&d->connectionToken);
Q_ASSERT_SUCCEEDED(hr);
//We can not register an actual Rfcomm port, because the platform does not allow it
//but we need a way to associate a server with a service
if (port == 0) { //Try to assign a non taken port id
for (int i = 1; ; i++){
if (__fakeServerPorts.key(i) == 0) {
port = i;
break;
}
}
}
if (__fakeServerPorts.key(port) == 0) {
__fakeServerPorts[d] = port;
qCDebug(QT_BT_WINDOWS) << "Port" << port << "registered";
} else {
qCWarning(QT_BT_WINDOWS) << "server with port" << port << "already registered or port invalid";
d->m_lastError = ServiceAlreadyRegisteredError;
emit errorOccurred(d->m_lastError);
return false;
}
return true;
}
void QBluetoothServer::setMaxPendingConnections(int numConnections)
{
Q_D(QBluetoothServer);
QMutexLocker locker(&d->pendingConnectionsMutex);
if (d->pendingConnections.size() > numConnections) {
qCWarning(QT_BT_WINDOWS) << "There are currently more than" << numConnections << "connections"
<< "pending. Number of maximum pending connections was not changed.";
return;
}
d->maxPendingConnections = numConnections;
}
bool QBluetoothServer::hasPendingConnections() const
{
Q_D(const QBluetoothServer);
QMutexLocker locker(&d->pendingConnectionsMutex);
return !d->pendingConnections.isEmpty();
}
QBluetoothSocket *QBluetoothServer::nextPendingConnection()
{
Q_D(QBluetoothServer);
if (d->pendingConnections.isEmpty())
return nullptr;
ComPtr<IStreamSocket> socket = d->pendingConnections.takeFirst();
QBluetoothSocket *newSocket = new QBluetoothSocket();
bool success = newSocket->d_ptr->setSocketDescriptor(socket, d->serverType);
if (!success) {
delete newSocket;
newSocket = nullptr;
}
return newSocket;
}
QBluetoothAddress QBluetoothServer::serverAddress() const
{
QList<QBluetoothHostInfo> hosts = QBluetoothLocalDevice::allDevices();
if (hosts.isEmpty())
return QBluetoothAddress();
else
return hosts.at(0).address();
}
quint16 QBluetoothServer::serverPort() const
{
//We return the fake port
Q_D(const QBluetoothServer);
return __fakeServerPorts.value((QBluetoothServerPrivate*)d, 0);
}
void QBluetoothServer::setSecurityFlags(QBluetooth::SecurityFlags security)
{
Q_UNUSED(security);
}
QBluetooth::SecurityFlags QBluetoothServer::securityFlags() const
{
return QBluetooth::Security::NoSecurity;
}
QT_END_NAMESPACE
|
