Differential D1231 Diff 15553 src/server/remote_access_interface.cpp

Changeset View

Standalone View

src/server/remote_access_interface.cpp

This file was added.

1		/****************************************************************************
2		Copyright 2016 Oleg Chernovskiy <kanedias@xaker.ru>
3
4		This library is free software; you can redistribute it and/or
5		modify it under the terms of the GNU Lesser General Public
6		License as published by the Free Software Foundation; either
7		version 2.1 of the License, or (at your option) version 3, or any
8		later version accepted by the membership of KDE e.V. (or its
9		successor approved by the membership of KDE e.V.), which shall
10		act as a proxy defined in Section 6 of version 3 of the license.
11
12		This library is distributed in the hope that it will be useful,
13		but WITHOUT ANY WARRANTY; without even the implied warranty of
14		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15		Lesser General Public License for more details.
16
17		You should have received a copy of the GNU Lesser General Public
18		License along with this library. If not, see <http://www.gnu.org/licenses/>.
19		****************************************************************************/
20		#include "remote_access_interface.h"
21		#include "remote_access_interface_p.h"
22		#include "display.h"
23		#include "global_p.h"
24		#include "resource_p.h"
25		#include "logging_p.h"
26
27		#include <wayland-remote-access-server-protocol.h>
28
29		#include <QHash>
	graesslinUnsubmitted Done you can just include "logging_p.h" graesslin: you can just include "logging_p.h"
	KanediasAuthorUnsubmitted Not Done Noted, re-using categories from there. Kanedias: Noted, re-using categories from there.
30		#include <QMutableHashIterator>
31
32		#include <functional>
33
34		namespace KWayland
35		{
36		namespace Server
37		{
38
39		class BufferHandle::Private // @see gbm_import_fd_data
40		{
41		public:
42		// Note that on client side received fd number will be different
43		// and meaningful only for client process!
44		// Thus we can use server-side fd as an implicit unique id
45		qint32 fd = 0; ///< also internal buffer id for client
46		quint32 width = 0;
47		quint32 height = 0;
48		quint32 stride = 0;
49		quint32 format = 0;
50		};
51
52		BufferHandle::BufferHandle()
53		: d(new Private)
54		{
55		}
56
57		BufferHandle::~BufferHandle()
58		{
59		}
60
61		void BufferHandle::setFd(qint32 fd)
62		{
63		d->fd = fd;
64		}
65
66		qint32 BufferHandle::fd() const
67		{
68		return d->fd;
69		}
70
71		void BufferHandle::setSize(quint32 width, quint32 height)
72		{
73		d->width = width;
74		d->height = height;
75		}
76
77		quint32 BufferHandle::width() const
78		{
79		return d->width;
80		}
81
82		quint32 BufferHandle::height() const
83		{
84		return d->height;
85		}
86
87		void BufferHandle::setStride(qint32 stride)
88		{
89		d->stride = stride;
90		}
91
92
93		quint32 BufferHandle::stride() const
94		{
95		return d->stride;
96		}
97
98		void BufferHandle::setFormat(quint32 format)
99		{
100		d->format = format;
101		}
102
103		quint32 BufferHandle::format() const
104		{
105		return d->format;
106		}
107
108		/**
109		* @brief helper struct for manual reference counting.
110		* automatic counting via QSharedPointer is no-go here as we hold strong reference in sentBuffers.
111		*/
112		struct BufferHolder
113		{
114		const BufferHandle *buf;
115		quint32 counter;
116		};
117
118		class RemoteAccessManagerInterface::Private : public Global::Private
119		{
	romanggUnsubmitted Not Done rm whitespace romangg: rm whitespace
120		public:
121		Private(RemoteAccessManagerInterface q, Display d);
122		virtual ~Private();
123
124		/**
125		* @brief Send buffer ready notification to all connected clients
126		* @param buf buffer containing GBM-related params
127		*/
128		void sendBufferReady(const BufferHandle *buf);
129		/**
130		* @brief Release all bound buffers associated with this resource
131		* @param resource one of bound clients
132		*/
133		void release(wl_resource *resource);
134
135		/**
136		* Clients of this interface.
137		* This may be screenshot app, video capture app,
138		* remote control app etc.
139		*/
140		QList<wl_resource *> clients;
141		private:
142		// methods
143		static void unbind(wl_resource *resource);
144		static Private cast(wl_resource r) {
145		return reinterpret_cast<Private*>(wl_resource_get_user_data(r));
146		}
147		static void getBufferCallback(wl_client client, wl_resource resource, uint32_t buffer, uint32_t internalBufId);
148		static void releaseCallback(wl_client client, wl_resource resource);
149		void bind(wl_client *client, uint32_t version, uint32_t id) override;
150
	graesslinUnsubmitted Done if really only one client should be allowed (why?) it would be better to send a dedicated error state to inform it instead of "abusing" no memory. graesslin: if really only one client should be allowed (why?) it would be better to send a dedicated error…
	KanediasAuthorUnsubmitted Not Done Added ability to have multiple clients in the same time Kanedias: Added ability to have multiple clients in the same time
151		/**
152		* @brief Unreferences counter and frees buffer when it reaches zero
153		* @param buf holder to decrease reference counter on
154		* @return true if buffer was released, false otherwise
155		*/
156		bool unref(BufferHolder &buf);
157
158		// fields
159		static const struct org_kde_kwin_remote_access_manager_interface s_interface;
	graesslinUnsubmitted Not Done this allows to have only one client bind it. As soon as a second client binds the protocol it will get overwritten and breaks the existing one. I think you need a QVector<wl_resource> here. graesslin:* this allows to have only one client bind it. As soon as a second client binds the protocol it…
	KanediasAuthorUnsubmitted Not Done Reimplemented Kanedias: Reimplemented
160		static const quint32 s_version;
161
162		RemoteAccessManagerInterface *q;
163
164		/**
165		* Buffers that were sent but still not acked by server
166		* Keys are fd numbers as they are unique
167		**/
168		QHash<qint32, BufferHolder> sentBuffers;
169		};
170
171		const quint32 RemoteAccessManagerInterface::Private::s_version = 1;
172
173		RemoteAccessManagerInterface::Private::Private(RemoteAccessManagerInterface q, Display d)
174		: Global::Private(d, &org_kde_kwin_remote_access_manager_interface, s_version)
175		, q(q)
176		{
177		}
178
179		void RemoteAccessManagerInterface::Private::bind(wl_client *client, uint32_t version, uint32_t id)
180		{
181		// create new client resource
182		auto c = display->getConnection(client);
183		wl_resource *resource = c->createResource(&org_kde_kwin_remote_access_manager_interface, qMin(version, s_version), id);
184		if (!resource) {
185		wl_client_post_no_memory(client);
186		return;
187		}
188		wl_resource_set_implementation(resource, &s_interface, this, unbind);
189
190		// add newly created client resource to the list
191		clients << resource;
192		}
193
194		void RemoteAccessManagerInterface::Private::sendBufferReady(const BufferHandle *buf)
195		{
196		BufferHolder holder {buf, 0};
197		// notify clients
198		qCDebug(KWAYLAND_SERVER) << "Server buffer sent: fd" << buf->fd();
199		for (auto res : clients) {
200		org_kde_kwin_remote_access_manager_send_buffer_ready(res, buf->fd());
201		holder.counter++;
202		}
203		// store buffer locally, clients will ask it later
204		sentBuffers[buf->fd()] = holder;
205		}
206
207		#ifndef DOXYGEN_SHOULD_SKIP_THIS
	romanggUnsubmitted Done Can a rogue client do it though? This would crash the server then? romangg: Can a rogue client do it though? This would crash the server then?
	KanediasAuthorUnsubmitted Not Done Can a rogue client do it though? This would crash the server then? Yes, I guess so... What would you propose? Should we send it only to first bound? Or last one? P.S. Even more: this interface has no authentication/authorization at all, so any client can connect and steal our video buffers. Martin said that first version of protocol can go without it and we can readd it later (as with fakeinput protocol). Kanedias: > Can a rogue client do it though? This would crash the server then? Yes, I guess so... What…
	romanggUnsubmitted Not Done Only first bound like you do it now. Just remove the Q_ASSERT (and make sure `boundScreens.size() >= 1`, otherwise continue). no authentication/authorization at all That's a generic problem yet to be solved on Wayland / the Linux desktop. This also correlates with the push to containerized apps. I would just want something like the permission system in Android, but there might be better solutions. It's a bigger project for sure. Also see here for some early thoughts on it, which to my knowledge until now did not lead to anything more: http://www.mupuf.org/blog/2014/02/19/wayland-compositors-why-and-how-to-handle/ romangg: Only first bound like you do it now. Just remove the Q_ASSERT (and make sure `boundScreens.size…
	romanggUnsubmitted Done Use braces: https://techbase.kde.org/Policies/Frameworks_Coding_Style#Braces romangg: Use braces: https://techbase.kde.org/Policies/Frameworks_Coding_Style#Braces
208		const struct org_kde_kwin_remote_access_manager_interface RemoteAccessManagerInterface::Private::s_interface = {
209		getBufferCallback,
210		releaseCallback
211		};
212		#endif
213
214		void RemoteAccessManagerInterface::Private::getBufferCallback(wl_client client, wl_resource resource, uint32_t buffer, uint32_t internalBufId)
215		{
216		Private *p = cast(resource);
217
218		// client asks for buffer we earlier announced, we must have it
219		if (Q_UNLIKELY(!p->sentBuffers.contains(internalBufId))) { // no such buffer (?)
220		wl_resource_post_no_memory(resource);
221		return;
222		}
223
224		BufferHolder &bh = p->sentBuffers[internalBufId];
225		auto rbuf = new RemoteBufferInterface(p->q, resource, bh.buf);
226		rbuf->create(p->display->getConnection(client), wl_resource_get_version(resource), buffer);
227		if (!rbuf->resource()) {
228		wl_resource_post_no_memory(resource);
229		delete rbuf;
230		return;
231		}
232
233		QObject::connect(rbuf, &QObject::destroyed, [p, rbuf, resource, &bh] {
234		if (!p->clients.contains(resource)) {
235		// remote buffer destroy confirmed after client is already gone
236		// all relevant buffers are already unreferenced
237		return;
238		}
239
240		qCDebug(KWAYLAND_SERVER) << "Remote buffer returned, client" << wl_resource_get_id(resource)
241		<< ", id" << rbuf->id()
	graesslinUnsubmitted Done qCDebug graesslin: qCDebug
	KanediasAuthorUnsubmitted Not Done Done Kanedias: Done
242		<< ", fd" << bh.buf->fd();
243		if (p->unref(bh)) {
244		p->sentBuffers.remove(bh.buf->fd());
245		}
246		});
247
248		// send buffer params
249		rbuf->passFd();
250		}
251
252		void RemoteAccessManagerInterface::Private::releaseCallback(wl_client client, wl_resource resource)
253		{
254		Q_UNUSED(client);
255		unbind(resource);
256		}
257
258		bool RemoteAccessManagerInterface::Private::unref(BufferHolder &bh)
259		{
260		bh.counter--;
261		if (!bh.counter) {
262		// no more clients using this buffer
263		qCDebug(KWAYLAND_SERVER) << "Buffer released, fd" << bh.buf->fd();
264		emit q->bufferReleased(bh.buf);
	graesslinUnsubmitted Done qCDebug graesslin: qCDebug
	KanediasAuthorUnsubmitted Not Done Done Kanedias: Done
265		return true;
266		}
267
268		return false;
269		}
270
271		void RemoteAccessManagerInterface::Private::unbind(wl_resource *resource)
272		{
273		// we're unbinding, all sent buffers for this client are now effectively invalid
274		Private *p = cast(resource);
275		p->release(resource);
276		}
277
278		void RemoteAccessManagerInterface::Private::release(wl_resource *resource)
279		{
280		// all holders should decrement their counter as one client is gone
281		QMutableHashIterator<qint32, BufferHolder> itr(sentBuffers);
282		while (itr.hasNext()) {
283		BufferHolder &bh = itr.next().value();
284		if (unref(bh)) {
285		itr.remove();
286		}
287		}
288
289		clients.removeAll(resource);
290		}
291
292		RemoteAccessManagerInterface::Private::~Private()
293		{
294		// server deletes created interfaces, release all held buffers
295		auto c = clients; // shadow copy
296		for (auto res : c) {
297		release(res);
298		}
299		}
300
301		RemoteAccessManagerInterface::RemoteAccessManagerInterface(Display display, QObject parent)
302		: Global(new Private(this, display), parent)
303		{
304		}
305
306		void RemoteAccessManagerInterface::sendBufferReady(const BufferHandle *buf)
307		{
308		Private priv = reinterpret_cast<Private >(d.data());
309		priv->sendBufferReady(buf);
310		}
311
312		bool RemoteAccessManagerInterface::isBound() const
313		{
314		Private priv = reinterpret_cast<Private >(d.data());
315		return !priv->clients.isEmpty();
316		}
317
318		class RemoteBufferInterface::Private : public Resource::Private
319		{
320		public:
321		Private(RemoteAccessManagerInterface ram, RemoteBufferInterface q, wl_resource pResource, const BufferHandle buf);
322		~Private();
323
324		void passFd();
325
326		private:
327		static const struct org_kde_kwin_remote_buffer_interface s_interface;
328
329		const BufferHandle *wrapped;
330		};
331
332		#ifndef DOXYGEN_SHOULD_SKIP_THIS
333		const struct org_kde_kwin_remote_buffer_interface RemoteBufferInterface::Private::s_interface = {
334		resourceDestroyedCallback
335		};
336		#endif
337
	graesslinUnsubmitted Done you can use the new resourceDestroyedCallback in resource_p.h. It handles the destroy correctly and that will trigger the unbind and deleteLater automatically. graesslin: you can use the new resourceDestroyedCallback in resource_p.h. It handles the destroy correctly…
	KanediasAuthorUnsubmitted Not Done Reused, thanks Kanedias: Reused, thanks
338		RemoteBufferInterface::Private::Private(RemoteAccessManagerInterface ram, RemoteBufferInterface q, wl_resource pResource, const BufferHandle buf)
339		: Resource::Private(q, ram, pResource, &org_kde_kwin_remote_buffer_interface, &s_interface), wrapped(buf)
340		{
341		}
342
343		RemoteBufferInterface::Private::~Private()
344		{
345		}
346
347		void RemoteBufferInterface::Private::passFd()
	graesslinUnsubmitted Done that would trigger a double delete as I had to learn very painfully lately. graesslin: that would trigger a double delete as I had to learn very painfully lately.
	KanediasAuthorUnsubmitted Not Done Removed that code completely, thanks to `resourceDestroyedCallback` Kanedias: Removed that code completely, thanks to `resourceDestroyedCallback`
348		{
349		org_kde_kwin_remote_buffer_send_gbm_handle(resource, wrapped->fd(),
350		wrapped->width(), wrapped->height(), wrapped->stride(), wrapped->format());
351		}
352
353		RemoteBufferInterface::RemoteBufferInterface(RemoteAccessManagerInterface ram, wl_resource pResource, const BufferHandle *buf)
354		: Resource(new Private(ram, this, pResource, buf), ram)
355		{
356		}
357
358		RemoteBufferInterface::Private *RemoteBufferInterface::d_func() const
359		{
360		return reinterpret_cast<Private*>(d.data());
	graesslinUnsubmitted Done you don't need that, it's already in Resource graesslin: you don't need that, it's already in Resource
	KanediasAuthorUnsubmitted Not Done Removed Kanedias: Removed
361		}
362
363
364		void RemoteBufferInterface::passFd()
365		{
366		d_func()->passFd();
367		}
368
369		}
370		}