Differential D21970 Diff 61224 src/util/externalcommand_polkitbackend.cpp

Changeset View

Standalone View

src/util/externalcommand_polkitbackend.cpp

This file was added.

1		/*************************************************************************
2		* Copyright (C) 2019 by Shubham <shubham.jangra@kdemail.net> *
3		* *
4		* This program is free software; you can redistribute it and/or *
5		* modify it under the terms of the GNU General Public License as *
6		* published by the Free Software Foundation; either version 3 of *
7		* the License, or (at your option) any later version. *
8		* *
9		* This program is distributed in the hope that it will be useful, *
10		* but WITHOUT ANY WARRANTY; without even the implied warranty of *
11		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12		* GNU General Public License for more details. *
13		* *
14		* You should have received a copy of the GNU General Public License *
15		* along with this program. If not, see <http://www.gnu.org/licenses/>.*
16		*************************************************************************/
17
18		#include "util/externalcommand_polkitbackend.h"
19
20		#include <QApplication>
21		#include <QByteArray>
22		#include <QDebug>
23		#include <QDBusConnection>
24		#include <QDBusConnectionInterface>
25		#include <QEventLoop>
26		#include <QString>
27		#include <QTimer>
28		#include <QWidget>
29
30		#include <PolkitQt1/Authority>
31		#include <PolkitQt1/Subject>
32
33		using namespace PolkitQt1;
34
35		namespace Auth
36		{
37
38		PolkitEventLoop::PolkitEventLoop(QObject *parent)
39		: QEventLoop(parent),
40		m_result(Authority::No)
41		{
42
43		}
44
45		PolkitEventLoop::~PolkitEventLoop()
46		{
47
48		}
49
50		void PolkitEventLoop::requestQuit(const Authority::Result &result)
51		{
52		m_result = result;
53		}
54
55		Authority::Result PolkitEventLoop::result() const
56		{
57		return m_result;
58		}
59
60		PolkitQt1Backend::PolkitQt1Backend()
61		: m_flyingActions(false)
62		{
63		// Connect various useful Polkit signals
64		connect(Authority::instance(), &Authority::configChanged, this, &Auth::PolkitQt1Backend::authStatusChanged);
65		connect(Authority::instance(), &Authority::consoleKitDBChanged, this, &Auth::PolkitQt1Backend::authStatusChanged);
66
67		// Take the current action into account.
68		m_flyingActions = true;
69		}
70
71		PolkitQt1Backend::~PolkitQt1Backend()
72		{
73
74		}
75
76		void PolkitQt1Backend::initPolkitAgent(const QString &action, QWidget parent /= nullptr*/) const
77		{
78		if (!parent) {
79		qWarning() << "Parent widget does not exists, can not proceed further";
80		return;
81		}
82
83		// Check if we are running terminal session or GUI session
84		if (!qApp) {
85		qWarning() << "We are running a TTY (Terminal) session";
86		qDebug() << "Can not proceed further since we do not support Text based Polkit Authentication Agent";
87		return;
88		}
89
90		// Get the dialog parent window Id
91		quint64 parentWindowID = parent->effectiveWinId();
92
93		// Make a call to the KDE polkit Authentication Agent asking for it's services
	stikonasUnsubmitted Done I'll have to read a bit more about polkit, but this requirement sounds strange. It shouldn't be necessary to have kde-authentication-agent-1. Some users might be on other desktop environments and use their own polkit authentication agent, e.g. `polkit-gnome-authentication-agent-1`. stikonas: I'll have to read a bit more about polkit, but this requirement sounds strange. It shouldn't…
94		QDBusMessage callAgent = QDBusMessage::createMethodCall(QLatin1String("org.kde.polkit-kde-authentication-agent-1"), QLatin1String("/org/kde/Polkit1AuthAgent"), QLatin1String("org.kde.Polkit1AuthAgent"),
95		QLatin1String("setWindowIdForAction"));
96
97		callAgent << action;
98		callAgent << parentWindowID;
99
100		QDBusPendingCall call = QDBusConnection::sessionBus().asyncCall(callAgent);
101		call.waitForFinished();
102
103		auto watcher = new QDBusPendingCallWatcher(call);
104
105		connect(watcher, &QDBusPendingCallWatcher::finished, this, [this, action, watcher](){
106
107		const QDBusMessage reply = watcher->reply();
108
109		if (reply.type() == QDBusMessage::ErrorMessage) {
110		qWarning() << "Could not call the Authentication Agent, Error:" << reply.errorMessage();
111		}
112
113		watcher->deleteLater();
114		});
115		}
116
117		Authority::Result PolkitQt1Backend::actionStatus(const QString &action, QByteArray &callerID) const
118		{
119		SystemBusNameSubject subject(QString::fromUtf8(callerID));
120
121		auto authority = PolkitQt1::Authority::instance();
122
123		auto result = authority->checkAuthorizationSync(action, subject, Authority::None);
124
125		if (authority->hasError()) {
126		qDebug() << "Encountered error while checking action status, Error code:" << authority->lastError() << "\nError Details:" << authority->errorDetails();
127		authority->clearError();
128		}
129
130		return result;
131		}
132
133		QByteArray PolkitQt1Backend::callerID() const
134		{
135		return QDBusConnection::systemBus().baseService().toUtf8();
136		}
137
138		bool PolkitQt1Backend::authorizeAction(const QString &action, QByteArray &callerID)
139		{
140		SystemBusNameSubject subject(QString::fromUtf8(callerID));
141
142		auto authority = Authority::instance();
143
144		PolkitEventLoop event(qobject_cast<QObject *>(qApp));
145
146		connect(authority, &Authority::checkAuthorizationFinished, &event, &PolkitEventLoop::requestQuit);
147
148		authority->checkAuthorizationSync(action, subject, Authority::AllowUserInteraction);
149
150		event.exec();
151
152		if (authority->hasError()) {
153		qWarning() << "Encountered error while checking authorization, Error code:" << authority->lastError() << "\n" <<"Error details:" << authority->errorDetails();
154
155		// Clear all the errors from the buffer so that hasError() does not give previous error as a result when called later
156		authority->clearError();
157		}
158
159		if (event.result() == Authority::Yes) {
160		// Emit signal signalling that current action is authorized by the authority instance
161		emit actionAuthorized(true);
162		return true;
163		} else {
164		emit actionAuthorized(false);
165		return false;
166		}
167		}
168
169		bool stopAction(const QString &action, const QByteArray &callerID)
170		{
171		Q_UNUSED(action)
172
173		SystemBusNameSubject subject(QString::fromUtf8(callerID));
174
175		auto authority = Authority::instance();
176
177		PolkitEventLoop event(qobject_cast<QObject *>(qApp));
178
179		//connect(authority, &Authority::revokeTemporaryAuthorizationsFinished, &event, &PolkitEventLoop::requestQuit);
180
181		event.exec();
182
183		return authority->revokeTemporaryAuthorizationsSync(subject);
184		}
185
186		void PolkitQt1Backend::quit() const
187		{
188
189		}
190
191		void PolkitQt1Backend::authStatusChanged()
192		{
193		for (auto it = m_cachedResults.begin(); it != m_cachedResults.end(); ++it) {
194		const QString action = it.key();
195		QByteArray pid = QDBusConnection::systemBus().baseService().toUtf8();
196		if (it.value() != actionStatus(action, pid)) {
197		*it = actionStatus(action, pid);
198		}
199		}
200
201		// Force updating known actions
202		Authority::instance()->enumerateActions();
203		m_flyingActions = true;
204		}
205
206		void PolkitQt1Backend::updateCachedActions(const ActionDescription::List &actions)
207		{
208		Q_UNUSED(actions)
209		}
210
211		} // namespace Auth
212
213		#include "moc_externalcommand_polkitbackend.cpp"