workspace/kcontrol/kfontinst/kio/PolicyKitMechanism.cpp

   1 /*
   2  * KFontInst - KDE Font Installer
   3  *
   4  * Copyright 2003-2008 Craig Drummond <craig@kde.org>
   5  *
   6  * ----
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; see the file COPYING.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #include "PolicyKitMechanism.h"
  25 #include <QtCore/QDebug>
  26 #include <QtCore/QHash>
  27 #include <QtCore/QSocketNotifier>
  28 #include <QtCore/QCoreApplication>
  29 #include <KDE/KGlobal>
  30 #include <polkit-dbus/polkit-dbus.h>
  31
  32 K_GLOBAL_STATIC(PolicyKitMechanism, instancePtr)
  33 //
  34 // We have another 'theInstance' pointer, because during the
  35 // init() of PolicyKitMechanismPrivate, the  polkitContextAddWatch
  36 // callback is triggered. This function cant use
  37 // PolicyKitMechanism::instance() - as this would cause another instance
  38 // to be created, causing a recursion...
  39 static PolicyKitMechanism *theInstance=0L;
  40
  41 static int polkitContextAddWatch(PolKitContext *, int fd)
  42 {
  43     qDebug() << "PolicyKitMechanism - Adding watch " << fd;
  44     if(theInstance)
  45         theInstance->addWatch(fd);
  46     return 1;
  47 }
  48
  49 static void polkitContextRemoveWatch(PolKitContext *, int fd)
  50 {
  51     qDebug() << "PolicyKitMechanism - Removing watch " << fd;
  52     if(theInstance)
  53         theInstance->removeWatch(fd);
  54 }
  55
  56 class PolicyKitMechanismPrivate
  57 {
  58     public:
  59
  60     PolicyKitMechanismPrivate()
  61     {
  62     }
  63
  64     void init()
  65     {
  66         pkContext = polkit_context_new();
  67
  68         if (0L==pkContext)
  69         {
  70             qDebug() << "PolicyKitMechanism - Could not get a new PolKitContext.";
  71             QCoreApplication::quit();
  72         }
  73
  74         //TODO: handle name owner changed signal
  75
  76         polkit_context_set_load_descriptions(pkContext);
  77
  78         //TODO: polkit_context_set_config_changed
  79
  80         polkit_context_set_io_watch_functions(pkContext, polkitContextAddWatch, polkitContextRemoveWatch);
  81
  82         PolKitError * pkError;
  83
  84         if (!polkit_context_init(pkContext, &pkError))
  85         {
  86             QString msg("PolicyKitMechanism -  Could not initialize PolKitContext");
  87             if (polkit_error_is_set(pkError))
  88                 qDebug() << msg <<  ": " << polkit_error_get_error_message(pkError);
  89             else
  90                 qDebug() << msg;
  91             QCoreApplication::quit();
  92         }
  93
  94         polkit_context_ref(pkContext);
  95
  96         DBusError      dbusError;
  97         DBusConnection *dbusCon;
  98
  99         dbus_error_init(&dbusError);
 100         dbusCon = dbus_bus_get(DBUS_BUS_SYSTEM, &dbusError);
 101
 102         pkTracker = polkit_tracker_new();
 103         polkit_tracker_set_system_bus_connection(pkTracker, dbusCon);
 104         polkit_tracker_init(pkTracker);
 105         polkit_tracker_ref(pkTracker);
 106     }
 107
 108     virtual ~PolicyKitMechanismPrivate()
 109     {
 110         QHash<QString, PolKitAction *>::iterator it(pkActions.begin()),
 111                                                  end(pkActions.end());
 112
 113         for(; it!=end; ++it)
 114             polkit_action_unref(it.value());
 115
 116         QHash<int, QSocketNotifier *>::iterator wit(contextWatches.begin()),
 117                                                 wend(contextWatches.end());
 118
 119         for(; wit!=wend; ++wit)
 120             delete (*wit);
 121
 122         polkit_context_unref(pkContext);
 123         polkit_tracker_unref(pkTracker);
 124     }
 125
 126     PolKitContext                  *pkContext;
 127     PolKitTracker                  *pkTracker;
 128     QHash<QString, PolKitAction *> pkActions;
 129     QHash<int, QSocketNotifier *>  contextWatches;
 130 };
 131
 132 PolicyKitMechanism * PolicyKitMechanism::instance()
 133 {
 134     return instancePtr;
 135 }
 136
 137 PolicyKitMechanism::PolicyKitMechanism()
 138                   : d_ptr(new PolicyKitMechanismPrivate())
 139 {
 140     theInstance=this;
 141     d_ptr->init();
 142 }
 143
 144 PolicyKitMechanism::~PolicyKitMechanism()
 145 {
 146     delete d_ptr;
 147     theInstance=0L;
 148 }
 149
 150 PolKitResult PolicyKitMechanism::canDoAction(const QString &action, unsigned int pid)
 151 {
 152     Q_D(PolicyKitMechanism);
 153
 154     qDebug() << "PolicyKitMechanism - canDoAction " << action << ' ' << pid;
 155
 156     PolKitAction *pkAction=getAction(action);
 157
 158     if(!pkAction)
 159     {
 160         qWarning() << "PolicyKitMechanism - Could not create action.";
 161         return POLKIT_RESULT_NO;
 162     }
 163
 164     DBusError    dbusError;
 165     dbus_error_init(&dbusError);
 166     PolKitCaller *pkCaller=polkit_tracker_get_caller_from_pid(d->pkTracker, pid, &dbusError);
 167     if (!pkCaller)
 168     {
 169         qWarning() << "PolicyKitMechanism - Could not define caller from pid";
 170         return POLKIT_RESULT_NO;
 171     }
 172     PolKitResult pkResult;
 173     PolKitError *pkError = NULL;
 174
 175     pkResult = polkit_context_is_caller_authorized(d->pkContext, pkAction, pkCaller, true, &pkError);
 176     polkit_caller_unref(pkCaller);
 177
 178     if (polkit_error_is_set(pkError))
 179     {
 180         qWarning() << "PolicyKitMechanism - Could not determine if caller is authorized for this action.";
 181         return POLKIT_RESULT_NO;
 182     }
 183
 184     return pkResult;
 185 }
 186
 187 PolKitResult PolicyKitMechanism::canDoAction(const QString &action, const QString &dbusName)
 188 {
 189     Q_D(PolicyKitMechanism);
 190
 191     qDebug() << "PolicyKitMechanism - canDoAction " << action << ' ' << dbusName;
 192
 193     PolKitAction *pkAction=getAction(action);
 194
 195     if(!pkAction)
 196     {
 197         qWarning() << "PolicyKitMechanism - Could not create action.";
 198         return POLKIT_RESULT_NO;
 199     }
 200
 201     DBusError    dbusError;
 202     dbus_error_init(&dbusError);
 203     PolKitCaller *pkCaller=polkit_tracker_get_caller_from_dbus_name(d->pkTracker, dbusName.toLatin1().constData(), &dbusError);
 204     if (!pkCaller)
 205     {
 206         qWarning() << "PolicyKitMechanism - Could not define caller from pid";
 207         return POLKIT_RESULT_NO;
 208     }
 209     PolKitResult pkResult;
 210     PolKitError *pkError = NULL;
 211
 212     pkResult = polkit_context_is_caller_authorized(d->pkContext, pkAction, pkCaller, true, &pkError);
 213     polkit_caller_unref(pkCaller);
 214
 215     if (polkit_error_is_set(pkError))
 216     {
 217         qWarning() << "PolicyKitMechanism - Could not determine if caller is authorized for this action.";
 218         return POLKIT_RESULT_NO;
 219     }
 220
 221     return pkResult;
 222 }
 223
 224 void PolicyKitMechanism::removeAction(const QString &action)
 225 {
 226     Q_D(PolicyKitMechanism);
 227
 228     QHash<QString, PolKitAction *>::iterator it(d->pkActions.find(action));
 229
 230     if(d->pkActions.end()!=it)
 231     {
 232         polkit_action_unref(it.value());
 233         d->pkActions.erase(it);
 234     }
 235 }
 236
 237 PolKitAction * PolicyKitMechanism::getAction(const QString &action)
 238 {
 239     Q_D(PolicyKitMechanism);
 240
 241     QHash<QString, PolKitAction *>::iterator it(d->pkActions.find(action));
 242     PolKitAction                             *pkAction=0L;
 243
 244     if(d->pkActions.end()==it)
 245     {
 246         pkAction=polkit_action_new();
 247         if(!pkAction || !polkit_action_set_action_id(pkAction, action.toLatin1().constData()))
 248             pkAction=0L;
 249         else
 250             d->pkActions[action]=pkAction;
 251     }
 252     else
 253         pkAction=it.value();
 254
 255     return pkAction;
 256 }
 257
 258 void PolicyKitMechanism::contextWatchActivated(int fd)
 259 {
 260     Q_D(PolicyKitMechanism);
 261     Q_ASSERT(d->contextWatches.contains(fd));
 262     qDebug() << "PolicyKitMechanism - Context watch activated";
 263     polkit_context_io_func(d->pkContext, fd);
 264 }
 265
 266 void PolicyKitMechanism::addWatch(int fd)
 267 {
 268     Q_D(PolicyKitMechanism);
 269
 270     QSocketNotifier *notify = new QSocketNotifier(fd, QSocketNotifier::Read);
 271     d->contextWatches[fd] = notify;
 272
 273     notify->connect(notify, SIGNAL(activated(int)), theInstance, SLOT(contextWatchActivated(int)));
 274 }
 275
 276 void PolicyKitMechanism::removeWatch(int fd)
 277 {
 278     Q_D(PolicyKitMechanism);
 279
 280     Q_ASSERT(d->contextWatches.contains(fd));
 281     delete d->contextWatches[fd];
 282     d->contextWatches.remove(fd);
 283 }
 284
 285 #include "PolicyKitMechanism.moc"