Initial import from polkit-qt-1 debian snapshot archive.

https://snapshot.debian.org/package/polkit-qt-1/0.103.0-1/

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

13 files changed, 3064 insertions, 0 deletions

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
new file mode 100644
index 000000000..f2efca4de
--- /dev/null
+++ b/core/CMakeLists.txt
@@ -0,0 +1,31 @@
+include_directories(
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set(polkit_qt_core_SRCS
+    polkitqt1-authority.cpp
+    polkitqt1-identity.cpp
+    polkitqt1-subject.cpp
+    polkitqt1-temporaryauthorization.cpp
+    polkitqt1-details.cpp
+    polkitqt1-actiondescription.cpp
+)
+
+automoc4_add_library(polkit-qt-core-1 SHARED ${polkit_qt_core_SRCS})
+
+target_link_libraries(polkit-qt-core-1
+    ${QT_QTCORE_LIBRARY}
+    ${QT_QTDBUS_LIBRARY}
+    ${QT_QTXML_LIBRARY}
+    ${POLKIT_LIBRARIES}
+    ${GLIB2_LIBRARIES}
+    ${GOBJECT_LIBRARIES}
+    ${GIO_LIBRARIES}
+)
+
+set_target_properties(polkit-qt-core-1 PROPERTIES VERSION ${POLKITQT-1_LIBRARY_VERSION}
+                                SOVERSION ${POLKITQT-1_ABI_VERSION}
+                                DEFINE_SYMBOL MAKE_POLKITQT1_LIB)
+
+install(TARGETS polkit-qt-core-1 ${INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/core/polkitqt1-actiondescription.cpp b/core/polkitqt1-actiondescription.cpp
new file mode 100644
index 000000000..dbe1aa894
--- /dev/null
+++ b/core/polkitqt1-actiondescription.cpp
@@ -0,0 +1,148 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Jaroslav Reznik <jreznik@redhat.com>
+ * Copyright (C) 2010 Dario Freddi <drf@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "polkitqt1-actiondescription.h"
+
+#include <QtCore/QString>
+
+#include <polkit/polkit.h>
+
+namespace PolkitQt1
+{
+
+class ActionDescription::Data : public QSharedData
+{
+public:
+    Data() {}
+    Data(const Data& other)
+        : QSharedData(other)
+        , actionId(other.actionId)
+        , description(other.description)
+        , message(other.message)
+        , vendorName(other.vendorName)
+        , vendorUrl(other.vendorUrl)
+        , iconName(other.iconName)
+        , implicitAny(other.implicitAny)
+        , implicitInactive(other.implicitInactive)
+        , implicitActive(other.implicitActive)
+    {
+    }
+    virtual ~Data() {}
+
+    QString actionId;
+    QString description;
+    QString message;
+    QString vendorName;
+    QString vendorUrl;
+    QString iconName;
+
+    ActionDescription::ImplicitAuthorization implicitAny;
+    ActionDescription::ImplicitAuthorization implicitInactive;
+    ActionDescription::ImplicitAuthorization implicitActive;
+};
+
+ActionDescription::ActionDescription()
+        : d(new Data)
+{
+
+}
+
+ActionDescription::ActionDescription(PolkitActionDescription *polkitActionDescription)
+        : d(new Data)
+{
+    g_type_init();
+
+    d->actionId = QString::fromUtf8(polkit_action_description_get_action_id(polkitActionDescription));
+    d->description = QString::fromUtf8(polkit_action_description_get_description(polkitActionDescription));
+    d->message = QString::fromUtf8(polkit_action_description_get_message(polkitActionDescription));
+    d->vendorName = QString::fromUtf8(polkit_action_description_get_vendor_name(polkitActionDescription));
+    d->vendorUrl = QString::fromUtf8(polkit_action_description_get_vendor_url(polkitActionDescription));
+    d->iconName = QString::fromUtf8(polkit_action_description_get_icon_name(polkitActionDescription));
+
+    d->implicitAny = static_cast<ActionDescription::ImplicitAuthorization>(polkit_action_description_get_implicit_any(
+                         polkitActionDescription));
+    d->implicitInactive = static_cast<ActionDescription::ImplicitAuthorization>(polkit_action_description_get_implicit_inactive(
+                              polkitActionDescription));
+    d->implicitActive = static_cast<ActionDescription::ImplicitAuthorization>(polkit_action_description_get_implicit_active(
+                            polkitActionDescription));
+}
+
+ActionDescription::ActionDescription(const PolkitQt1::ActionDescription& other)
+        : d(other.d)
+{
+}
+
+ActionDescription& ActionDescription::operator=(const PolkitQt1::ActionDescription& other)
+{
+    d = other.d;
+    return *this;
+}
+
+ActionDescription::~ActionDescription()
+{
+}
+
+QString ActionDescription::actionId() const
+{
+    return d->actionId;
+}
+
+QString ActionDescription::description() const
+{
+    return d->description;
+}
+
+QString ActionDescription::message() const
+{
+    return d->message;
+}
+
+QString ActionDescription::vendorName() const
+{
+    return d->vendorName;
+}
+
+QString ActionDescription::vendorUrl() const
+{
+    return d->vendorUrl;
+}
+
+QString ActionDescription::iconName() const
+{
+    return d->iconName;
+}
+
+ActionDescription::ImplicitAuthorization ActionDescription::implicitAny() const
+{
+    return d->implicitAny;
+}
+
+ActionDescription::ImplicitAuthorization ActionDescription::implicitInactive() const
+{
+    return d->implicitInactive;
+}
+
+ActionDescription::ImplicitAuthorization ActionDescription::implicitActive() const
+{
+    return d->implicitActive;
+}
+
+}
diff --git a/core/polkitqt1-actiondescription.h b/core/polkitqt1-actiondescription.h
new file mode 100644
index 000000000..deed65d6e
--- /dev/null
+++ b/core/polkitqt1-actiondescription.h
@@ -0,0 +1,149 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Jaroslav Reznik <jreznik@redhat.com>
+ * Copyright (C) 2010 Dario Freddi <drf@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef POLKITQT1_ACTION_DESCRIPTION_H
+#define POLKITQT1_ACTION_DESCRIPTION_H
+
+#include "polkitqt1-export.h"
+
+#include <QtCore/QList>
+#include <QtCore/QMetaType>
+#include <QtCore/QSharedData>
+
+typedef struct _PolkitActionDescription PolkitActionDescription;
+
+namespace PolkitQt1
+{
+/**
+ * \class ActionDescription polkitqt1-actiondescription.h ActionDescription
+ * \author Jaroslav Reznik <jreznik@redhat.com>
+ * \author Dario Freddi <drf@kde.org>
+ *
+ * \brief Class used to encapsulate a registered action.
+ */
+class POLKITQT1_EXPORT ActionDescription
+{
+public:
+    enum ImplicitAuthorization {
+        /** Unknown whether the subject is authorized, never returned in any public API. **/
+        Unknown = -1,
+        /** Subject is not authorized. **/
+        NotAuthorized = 0,
+        /** Authentication is required. **/
+        AuthenticationRequired = 1,
+        /** Authentication as an administrator is required. **/
+        AdministratorAuthenticationRequired = 2,
+        /** Authentication is required. If the authorization is obtained, it is retained. **/
+        AuthenticationRequiredRetained = 3,
+        /** Authentication as an administrator is required. If the authorization is obtained, it is retained. **/
+        AdministratorAuthenticationRequiredRetained = 4,
+        /** The subject is authorized. **/
+        Authorized = 5
+    };
+
+    typedef QList< ActionDescription > List;
+
+    ActionDescription();
+    /**
+     * \brief Constructor of ActionDescription object from PolkitActionDescription
+     *
+     * \warning Use this only if you are completely aware of what are you doing!
+     *
+     * \param actionDesciption PolkitActionDescription
+     */
+    explicit ActionDescription(PolkitActionDescription *actionDescription);
+    ActionDescription(const ActionDescription &other);
+    ~ActionDescription();
+
+    ActionDescription &operator=(const ActionDescription &other);
+
+    /**
+     * \brief Gets the action id for ActionDescription
+     *
+     * \return id of the action
+     */
+    QString actionId() const;
+
+    /**
+     * \brief Gets the description used of ActionDescription
+     *
+     * \return description of the action
+     */
+    QString description() const;
+
+    /**
+     * \brief Gets the message user for ActionDescription
+     *
+     * \return action message
+     */
+    QString message() const;
+
+    /**
+     * \brief Gets the vendor name for ActionDescription, if any
+     *
+     * \return vendor name
+     */
+    QString vendorName() const;
+
+    /**
+     * \brief Gets the vendor URL for ActionDescription, if any
+     *
+     * \return vendor URL or empty QString if there is no vendor URL
+     */
+    QString vendorUrl() const;
+
+    /**
+     * \brief Gets the icon name for ActionDescription, if any
+     *
+     * \return icon name or empty QString if there is no icon
+     */
+    QString iconName() const;
+
+    /**
+     * \brief Gets the implicit authorization for ActionDescription used for any subject
+     *
+     * \return A value from ImplicitAuthorization enumeration
+     */
+    ActionDescription::ImplicitAuthorization implicitAny() const;
+
+    /**
+     * \brief Gets the implicit authorization for ActionDescription used for subjects in inactive session on a local console
+     *
+     * \return A value from ImplicitAuthorization enumeration
+     */
+    ActionDescription::ImplicitAuthorization implicitInactive() const;
+
+    /**
+     * \brief Gets the implicit authorization for ActionDescription used for subjects in active session on a local console
+     *
+     * \return A value from ImplicitAuthorization enumeration
+     */
+    ActionDescription::ImplicitAuthorization implicitActive() const;
+
+private:
+    class Data;
+    QSharedDataPointer< Data > d;
+};
+}
+
+Q_DECLARE_METATYPE(PolkitQt1::ActionDescription::List)
+
+#endif //POLKIT_QT_ACTION_DESCRIPTION_H
diff --git a/core/polkitqt1-authority.cpp b/core/polkitqt1-authority.cpp
new file mode 100644
index 000000000..0951d97b5
--- /dev/null
+++ b/core/polkitqt1-authority.cpp
@@ -0,0 +1,855 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Daniel Nicoletti <dantti85-pk@yahoo.com.br>
+ * Copyright (C) 2009 Dario Freddi <drf@kde.org>
+ * Copyright (C) 2009 Jaroslav Reznik <jreznik@redhat.com>
+ * Copyright (C) 2009 Radek Novacek <rnovacek@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "polkitqt1-authority.h"
+
+#include <QtDBus/QDBusInterface>
+#include <QtDBus/QDBusReply>
+
+#include <polkit/polkit.h>
+
+namespace PolkitQt1
+{
+
+class AuthorityHelper
+{
+public:
+    AuthorityHelper() : q(0) {}
+    ~AuthorityHelper() {
+        delete q;
+    }
+    Authority *q;
+};
+
+Q_GLOBAL_STATIC(AuthorityHelper, s_globalAuthority)
+
+Authority *Authority::instance(PolkitAuthority *authority)
+{
+    if (!s_globalAuthority()->q) {
+        new Authority(authority);
+    }
+
+    return s_globalAuthority()->q;
+}
+
+Authority::Result polkitResultToResult(PolkitAuthorizationResult *result)
+{
+    if (polkit_authorization_result_get_is_challenge(result)) {
+        return Authority::Challenge;
+    } else if (polkit_authorization_result_get_is_authorized(result)) {
+        return Authority::Yes;
+    } else {
+        return Authority::No;
+    }
+}
+
+ActionDescription::List actionsToListAndFree(GList *glist)
+{
+    ActionDescription::List result;
+    for (GList *glist2 = glist; glist2; glist2 = g_list_next(glist2)) {
+        gpointer i = glist2->data;
+        result.append(ActionDescription(static_cast<PolkitActionDescription *>(i)));
+        g_object_unref(i);
+    }
+
+    g_list_free(glist);
+    return result;
+}
+
+class Authority::Private
+{
+public:
+    // Polkit will return NULL on failures, hence we use it instead of 0
+    Private(Authority *qq) : q(qq)
+            , pkAuthority(NULL)
+            , m_hasError(false) {}
+
+    ~Private();
+
+    void init();
+
+    /** Use this method to set the error message to \p message. Set recover to \c true
+     * to try to reinitialize this object with init() method
+     */
+    void setError(Authority::ErrorCode code, const QString &details = QString(), bool recover = false);
+
+    void dbusFilter(const QDBusMessage &message);
+    void dbusSignalAdd(const QString &service, const QString &path, const QString &interface, const QString &name);
+    void seatSignalsConnect(const QString &seat);
+
+    Authority *q;
+    PolkitAuthority *pkAuthority;
+    bool m_hasError;
+    Authority::ErrorCode m_lastError;
+    QString m_errorDetails;
+    QDBusConnection *m_systemBus;
+    GCancellable *m_checkAuthorizationCancellable,
+    *m_enumerateActionsCancellable,
+    *m_registerAuthenticationAgentCancellable,
+    *m_unregisterAuthenticationAgentCancellable,
+    *m_authenticationAgentResponseCancellable,
+    *m_enumerateTemporaryAuthorizationsCancellable,
+    *m_revokeTemporaryAuthorizationsCancellable,
+    *m_revokeTemporaryAuthorizationCancellable;
+
+
+    static void pk_config_changed();
+    static void checkAuthorizationCallback(GObject *object, GAsyncResult *result, gpointer user_data);
+    static void enumerateActionsCallback(GObject *object, GAsyncResult *result, gpointer user_data);
+    static void registerAuthenticationAgentCallback(GObject *object, GAsyncResult *result, gpointer user_data);
+    static void unregisterAuthenticationAgentCallback(GObject *object, GAsyncResult *result, gpointer user_data);
+    static void authenticationAgentResponseCallback(GObject *object, GAsyncResult *result, gpointer user_data);
+    static void enumerateTemporaryAuthorizationsCallback(GObject *object, GAsyncResult *result, gpointer user_data);
+    static void revokeTemporaryAuthorizationsCallback(GObject *object, GAsyncResult *result, gpointer user_data);
+    static void revokeTemporaryAuthorizationCallback(GObject *object, GAsyncResult *result, gpointer user_data);
+};
+
+Authority::Private::~Private()
+{
+    g_object_unref(m_checkAuthorizationCancellable);
+    g_object_unref(m_enumerateActionsCancellable);
+    g_object_unref(m_registerAuthenticationAgentCancellable);
+    g_object_unref(m_unregisterAuthenticationAgentCancellable);
+    g_object_unref(m_authenticationAgentResponseCancellable);
+    g_object_unref(m_enumerateTemporaryAuthorizationsCancellable);
+    g_object_unref(m_revokeTemporaryAuthorizationsCancellable);
+    g_object_unref(m_revokeTemporaryAuthorizationCancellable);
+}
+
+Authority::Authority(PolkitAuthority *authority, QObject *parent)
+        : QObject(parent)
+        , d(new Private(this))
+{
+    qRegisterMetaType<PolkitQt1::Authority::Result> ();
+    qRegisterMetaType<PolkitQt1::ActionDescription::List>();
+
+    Q_ASSERT(!s_globalAuthority()->q);
+    s_globalAuthority()->q = this;
+
+    if (authority) {
+        d->pkAuthority = authority;
+    }
+
+    d->init();
+}
+
+Authority::~Authority()
+{
+    if (d->pkAuthority != NULL) {
+        g_object_unref(d->pkAuthority);
+    }
+
+    delete d;
+}
+
+void Authority::Private::init()
+{
+    QDBusError error;
+    QDBusError dbus_error;
+
+    g_type_init();
+
+    m_checkAuthorizationCancellable = g_cancellable_new();
+    m_enumerateActionsCancellable = g_cancellable_new();
+    m_registerAuthenticationAgentCancellable = g_cancellable_new();
+    m_unregisterAuthenticationAgentCancellable = g_cancellable_new();
+    m_authenticationAgentResponseCancellable = g_cancellable_new();
+    m_enumerateTemporaryAuthorizationsCancellable = g_cancellable_new();
+    m_revokeTemporaryAuthorizationsCancellable = g_cancellable_new();
+    m_revokeTemporaryAuthorizationCancellable = g_cancellable_new();
+
+#ifndef POLKIT_QT_1_COMPATIBILITY_MODE
+    GError *gerror = NULL;
+#endif
+    if (pkAuthority == NULL) {
+#ifndef POLKIT_QT_1_COMPATIBILITY_MODE
+        pkAuthority = polkit_authority_get_sync(NULL, &gerror);
+        if (gerror != NULL) {
+            setError(E_GetAuthority, gerror->message);
+            g_error_free(gerror);
+            return;
+        }
+#else
+        pkAuthority = polkit_authority_get();
+#endif
+    }
+
+    if (pkAuthority == NULL) {
+#ifdef POLKIT_QT_1_COMPATIBILITY_MODE
+        (E_GetAuthority);
+#endif
+        return;
+    }
+
+    // connect changed signal
+    g_signal_connect(G_OBJECT(pkAuthority), "changed", G_CALLBACK(pk_config_changed), NULL);
+
+    // need to listen to NameOwnerChanged
+    dbusSignalAdd("org.freedesktop.DBus", "/", "org.freedesktop.DBus", "NameOwnerChanged");
+
+    QString consoleKitService("org.freedesktop.ConsoleKit");
+    QString consoleKitManagerPath("/org/freedesktop/ConsoleKit/Manager");
+    QString consoleKitManagerInterface("org.freedesktop.ConsoleKit.Manager");
+    QString consoleKitSeatInterface("org.freedesktop.ConsoleKit.Seat");
+
+    // first, add signals SeadAdded and SeatRemoved from ConsoleKit Manager
+    dbusSignalAdd(consoleKitService, consoleKitManagerPath, consoleKitManagerInterface, "SeatAdded");
+    dbusSignalAdd(consoleKitService, consoleKitManagerPath, consoleKitManagerInterface, "SeatRemoved");
+
+    // then we need to extract all seats from ConsoleKit
+    QDBusMessage msg = QDBusMessage::createMethodCall(consoleKitService, consoleKitManagerPath, consoleKitManagerInterface, "GetSeats");
+    msg = QDBusConnection::systemBus().call(msg);
+    if (!msg.arguments().isEmpty()) {
+        // this method returns a list with present seats
+        QList<QString> seats;
+        qVariantValue<QDBusArgument> (msg.arguments()[0]) >> seats;
+        // it can be multiple seats present so connect all their signals
+        Q_FOREACH(const QString &seat, seats) {
+            seatSignalsConnect(seat);
+        }
+    }
+}
+
+void Authority::Private::setError(Authority::ErrorCode code, const QString &details, bool recover)
+{
+    if (recover) {
+        init();
+    }
+    m_lastError = code;
+    m_errorDetails = details;
+    m_hasError = true;
+}
+
+void Authority::Private::seatSignalsConnect(const QString &seat)
+{
+    QString consoleKitService("org.freedesktop.ConsoleKit");
+    QString consoleKitSeatInterface("org.freedesktop.ConsoleKit.Seat");
+    // we want to connect to all slots of the seat
+    dbusSignalAdd(consoleKitService, seat, consoleKitSeatInterface, "DeviceAdded");
+    dbusSignalAdd(consoleKitService, seat, consoleKitSeatInterface, "DeviceRemoved");
+    dbusSignalAdd(consoleKitService, seat, consoleKitSeatInterface, "SessionAdded");
+    dbusSignalAdd(consoleKitService, seat, consoleKitSeatInterface, "SessionRemoved");
+    dbusSignalAdd(consoleKitService, seat, consoleKitSeatInterface, "ActiveSessionChanged");
+}
+
+void Authority::Private::dbusSignalAdd(const QString &service, const QString &path, const QString &interface, const QString &name)
+{
+    // FIXME: This code seems to be nonfunctional - it needs to be fixed somewhere (is it Qt BUG?)
+    QDBusConnection::systemBus().connect(service, path, interface, name,
+                                         q, SLOT(dbusFilter(const QDBusMessage &)));
+}
+
+void Authority::Private::dbusFilter(const QDBusMessage &message)
+{
+    if (message.type() == QDBusMessage::SignalMessage) {
+        Q_EMIT q->consoleKitDBChanged();
+
+        // TODO: Test this with the multiseat support
+        if (message.member() == "SeatAdded") {
+            seatSignalsConnect(qVariantValue<QDBusObjectPath> (message.arguments()[0]).path());
+        }
+    }
+}
+
+bool Authority::hasError() const
+{
+    return d->m_hasError;
+}
+
+Authority::ErrorCode Authority::lastError() const
+{
+    return d->m_lastError;
+}
+
+const QString Authority::errorDetails() const
+{
+    if (d->m_lastError == E_None) {
+        return QString();
+    } else {
+        return d->m_errorDetails;
+    }
+}
+
+void Authority::clearError()
+{
+    d->m_hasError = false;
+    d->m_lastError = E_None;
+}
+
+void Authority::Private::pk_config_changed()
+{
+    Q_EMIT Authority::instance()->configChanged();
+}
+
+PolkitAuthority *Authority::polkitAuthority() const
+{
+    return d->pkAuthority;
+}
+
+Authority::Result Authority::checkAuthorizationSync(const QString &actionId, const Subject &subject, AuthorizationFlags flags)
+{
+    PolkitAuthorizationResult *pk_result;
+    GError *error = NULL;
+
+    if (Authority::instance()->hasError()) {
+        return Unknown;
+    }
+
+    if (!subject.isValid()) {
+        d->setError(E_WrongSubject);
+        return Unknown;
+    }
+
+    pk_result = polkit_authority_check_authorization_sync(d->pkAuthority,
+                subject.subject(),
+                actionId.toAscii().data(),
+                NULL,
+                (PolkitCheckAuthorizationFlags)(int)flags,
+                NULL,
+                &error);
+
+    if (error != NULL) {
+        d->setError(E_CheckFailed, error->message);
+        g_error_free(error);
+        return Unknown;
+    }
+
+    if (!pk_result) {
+        d->setError(E_UnknownResult);
+        return Unknown;
+    } else {
+        Authority::Result res = polkitResultToResult(pk_result);
+        g_object_unref(pk_result);
+        return res;
+    }
+}
+
+void Authority::checkAuthorization(const QString &actionId, const Subject &subject, AuthorizationFlags flags)
+{
+    if (Authority::instance()->hasError()) {
+        return;
+    }
+
+    if (!subject.isValid()) {
+        d->setError(E_WrongSubject);
+        return;
+    }
+
+    polkit_authority_check_authorization(d->pkAuthority,
+                                         subject.subject(),
+                                         actionId.toAscii().data(),
+                                         NULL,
+                                         (PolkitCheckAuthorizationFlags)(int)flags,
+                                         d->m_checkAuthorizationCancellable,
+                                         d->checkAuthorizationCallback, this);
+}
+
+void Authority::Private::checkAuthorizationCallback(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+    Authority *authority = (Authority *) user_data;
+
+    Q_ASSERT(authority != NULL);
+
+    GError *error = NULL;
+    PolkitAuthorizationResult *pkResult = polkit_authority_check_authorization_finish((PolkitAuthority *) object, result, &error);
+
+    if (error != NULL) {
+        // We don't want to set error if this is cancellation of some action
+        if (error->code != 1) {
+            authority->d->setError(E_CheckFailed, error->message);
+        }
+        g_error_free(error);
+        return;
+    }
+    if (pkResult != NULL) {
+        Q_EMIT authority->checkAuthorizationFinished(polkitResultToResult(pkResult));
+        g_object_unref(pkResult);
+    } else {
+        authority->d->setError(E_UnknownResult);
+    }
+}
+
+void Authority::checkAuthorizationCancel()
+{
+    if (!g_cancellable_is_cancelled(d->m_checkAuthorizationCancellable)) {
+        g_cancellable_cancel(d->m_checkAuthorizationCancellable);
+    }
+}
+
+ActionDescription::List Authority::enumerateActionsSync()
+{
+    if (Authority::instance()->hasError()) {
+        return ActionDescription::List();
+    }
+
+    GError *error = NULL;
+
+    GList *glist = polkit_authority_enumerate_actions_sync(d->pkAuthority,
+                   NULL,
+                   &error);
+
+    if (error != NULL) {
+        d->setError(E_EnumFailed, error->message);
+        g_error_free(error);
+        return ActionDescription::List();
+    }
+
+    return actionsToListAndFree(glist);
+}
+
+void Authority::enumerateActions()
+{
+    if (Authority::instance()->hasError()) {
+        return;
+    }
+
+    polkit_authority_enumerate_actions(d->pkAuthority,
+                                       d->m_enumerateActionsCancellable,
+                                       d->enumerateActionsCallback,
+                                       Authority::instance());
+}
+
+void Authority::Private::enumerateActionsCallback(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+    Authority *authority = (Authority *) user_data;
+    Q_ASSERT(authority != NULL);
+    GError *error = NULL;
+    GList *list = polkit_authority_enumerate_actions_finish((PolkitAuthority *) object, result, &error);
+    if (error != NULL) {
+        // We don't want to set error if this is cancellation of some action
+        if (error->code != 1) {
+            authority->d->setError(E_EnumFailed, error->message);
+        }
+        g_error_free(error);
+        return;
+    }
+
+    Q_EMIT authority->enumerateActionsFinished(actionsToListAndFree(list));
+}
+
+void Authority::enumerateActionsCancel()
+{
+    if (!g_cancellable_is_cancelled(d->m_enumerateActionsCancellable)) {
+        g_cancellable_cancel(d->m_enumerateActionsCancellable);
+    }
+}
+
+bool Authority::registerAuthenticationAgentSync(const Subject &subject, const QString &locale, const QString &objectPath)
+{
+    if (Authority::instance()->hasError()) {
+        return false;
+    }
+
+    gboolean result;
+    GError *error = NULL;
+
+    if (!subject.isValid()) {
+        d->setError(E_WrongSubject);
+        return false;
+    }
+
+    result = polkit_authority_register_authentication_agent_sync(d->pkAuthority,
+             subject.subject(), locale.toAscii().data(),
+             objectPath.toAscii().data(), NULL, &error);
+
+    if (error) {
+        d->setError(E_RegisterFailed, error->message);
+        g_error_free(error);
+        return false;
+    }
+
+    return result;
+}
+
+void Authority::registerAuthenticationAgent(const Subject &subject, const QString &locale, const QString &objectPath)
+{
+    if (Authority::instance()->hasError()) {
+        return;
+    }
+
+    if (!subject.isValid()) {
+        d->setError(E_WrongSubject);
+        return;
+    }
+
+    polkit_authority_register_authentication_agent(d->pkAuthority,
+            subject.subject(),
+            locale.toAscii().data(),
+            objectPath.toAscii().data(),
+            d->m_registerAuthenticationAgentCancellable,
+            d->registerAuthenticationAgentCallback,
+            this);
+}
+
+void Authority::Private::registerAuthenticationAgentCallback(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+    Authority *authority = (Authority *) user_data;
+    Q_ASSERT(authority != NULL);
+    GError *error = NULL;
+    bool res = polkit_authority_register_authentication_agent_finish((PolkitAuthority *) object, result, &error);
+    if (error != NULL) {
+        // We don't want to set error if this is cancellation of some action
+        if (error->code != 1) {
+            authority->d->setError(E_EnumFailed , error->message);
+        }
+        g_error_free(error);
+        return;
+    }
+
+    Q_EMIT authority->registerAuthenticationAgentFinished(res);
+}
+
+void Authority::registerAuthenticationAgentCancel()
+{
+    if (!g_cancellable_is_cancelled(d->m_registerAuthenticationAgentCancellable)) {
+        g_cancellable_cancel(d->m_registerAuthenticationAgentCancellable);
+    }
+}
+
+bool Authority::unregisterAuthenticationAgentSync(const Subject &subject, const QString &objectPath)
+{
+    if (d->pkAuthority) {
+        return false;
+    }
+
+    if (!subject.isValid()) {
+        d->setError(E_WrongSubject);
+        return false;
+    }
+
+    GError *error = NULL;
+
+    bool result = polkit_authority_unregister_authentication_agent_sync(d->pkAuthority,
+                  subject.subject(),
+                  objectPath.toUtf8().data(),
+                  NULL,
+                  &error);
+
+    if (error != NULL) {
+        d->setError(E_UnregisterFailed, error->message);
+        g_error_free(error);
+        return false;
+    }
+
+    return result;
+}
+
+void Authority::unregisterAuthenticationAgent(const Subject &subject, const QString &objectPath)
+{
+    if (Authority::instance()->hasError()) {
+        return;
+    }
+
+    if (!subject.isValid()) {
+        d->setError(E_WrongSubject);
+        return;
+    }
+
+    polkit_authority_unregister_authentication_agent(d->pkAuthority,
+            subject.subject(),
+            objectPath.toUtf8().data(),
+            d->m_unregisterAuthenticationAgentCancellable,
+            d->unregisterAuthenticationAgentCallback,
+            this);
+}
+
+void Authority::Private::unregisterAuthenticationAgentCallback(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+    Authority *authority = (Authority *) user_data;
+    Q_ASSERT(authority);
+    GError *error = NULL;
+    bool res = polkit_authority_unregister_authentication_agent_finish((PolkitAuthority *) object, result, &error);
+    if (error != NULL) {
+        // We don't want to set error if this is cancellation of some action
+        if (error->code != 1) {
+            authority->d->setError(E_UnregisterFailed, error->message);
+        }
+        g_error_free(error);
+        return;
+    }
+
+    Q_EMIT authority->unregisterAuthenticationAgentFinished(res);
+}
+
+void Authority::unregisterAuthenticationAgentCancel()
+{
+    if (!g_cancellable_is_cancelled(d->m_unregisterAuthenticationAgentCancellable)) {
+        g_cancellable_cancel(d->m_unregisterAuthenticationAgentCancellable);
+    }
+}
+
+bool Authority::authenticationAgentResponseSync(const QString &cookie, const Identity &identity)
+{
+    if (Authority::instance()->hasError()) {
+        return false;
+    }
+
+    if (cookie.isEmpty() || !identity.isValid()) {
+        d->setError(E_CookieOrIdentityEmpty);
+        return false;
+    }
+
+    GError *error = NULL;
+
+    bool result = polkit_authority_authentication_agent_response_sync(d->pkAuthority,
+                  cookie.toUtf8().data(),
+                  identity.identity(),
+                  NULL,
+                  &error);
+    if (error != NULL) {
+        d->setError(E_AgentResponseFailed, error->message);
+        g_error_free(error);
+        return false;
+    }
+
+    return result;
+}
+
+void Authority::authenticationAgentResponse(const QString &cookie, const Identity &identity)
+{
+    if (Authority::instance()->hasError()) {
+        return;
+    }
+
+    if (cookie.isEmpty() || !identity.isValid()) {
+        d->setError(E_CookieOrIdentityEmpty);
+        return;
+    }
+
+    polkit_authority_authentication_agent_response(d->pkAuthority,
+            cookie.toUtf8().data(),
+            identity.identity(),
+            d->m_authenticationAgentResponseCancellable,
+            d->authenticationAgentResponseCallback,
+            this);
+}
+
+void Authority::Private::authenticationAgentResponseCallback(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+    Authority *authority = (Authority *) user_data;
+    Q_ASSERT(authority);
+    GError *error = NULL;
+    bool res = polkit_authority_authentication_agent_response_finish((PolkitAuthority *) object, result, &error);
+    if (error != NULL) {
+        // We don't want to set error if this is cancellation of some action
+        if (error->code != 1) {
+            authority->d->setError(E_AgentResponseFailed, error->message);
+        }
+        g_error_free(error);
+        return;
+    }
+
+    Q_EMIT authority->authenticationAgentResponseFinished(res);
+}
+
+void Authority::authenticationAgentResponseCancel()
+{
+    if (!g_cancellable_is_cancelled(d->m_authenticationAgentResponseCancellable)) {
+        g_cancellable_cancel(d->m_authenticationAgentResponseCancellable);
+    }
+}
+
+TemporaryAuthorization::List Authority::enumerateTemporaryAuthorizationsSync(const Subject &subject)
+{
+    TemporaryAuthorization::List result;
+
+    GError *error = NULL;
+    GList *glist = polkit_authority_enumerate_temporary_authorizations_sync(d->pkAuthority,
+                   subject.subject(),
+                   NULL,
+                   &error);
+    if (error != NULL) {
+        d->setError(E_EnumFailed, error->message);
+        g_error_free(error);
+        return result;
+    }
+
+    GList *glist2;
+    for (glist2 = glist; glist2 != NULL; glist2 = g_list_next(glist2)) {
+        result.append(TemporaryAuthorization((PolkitTemporaryAuthorization *) glist2->data));
+        g_object_unref(glist2->data);
+    }
+
+    g_list_free(glist);
+
+    return result;
+}
+
+void Authority::Private::enumerateTemporaryAuthorizationsCallback(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+    Authority *authority = (Authority *) user_data;
+    Q_ASSERT(authority);
+    GError *error = NULL;
+
+    GList *glist = polkit_authority_enumerate_temporary_authorizations_finish((PolkitAuthority *) object, result, &error);
+
+    if (error != NULL) {
+        // We don't want to set error if this is cancellation of some action
+        if (error->code != 1) {
+            authority->d->setError(E_EnumFailed, error->message);
+        }
+        g_error_free(error);
+        return;
+    }
+    TemporaryAuthorization::List res;
+    GList *glist2;
+    for (glist2 = glist; glist2 != NULL; glist2 = g_list_next(glist2)) {
+        res.append(TemporaryAuthorization((PolkitTemporaryAuthorization *) glist2->data));
+        g_object_unref(glist2->data);
+    }
+
+    g_list_free(glist);
+
+    Q_EMIT authority->enumerateTemporaryAuthorizationsFinished(res);
+}
+
+void Authority::enumerateTemporaryAuthorizationsCancel()
+{
+    if (!g_cancellable_is_cancelled(d->m_enumerateTemporaryAuthorizationsCancellable)) {
+        g_cancellable_cancel(d->m_enumerateTemporaryAuthorizationsCancellable);
+    }
+}
+
+bool Authority::revokeTemporaryAuthorizationsSync(const Subject &subject)
+{
+    bool result;
+    if (Authority::instance()->hasError()) {
+        return false;
+    }
+
+    GError *error = NULL;
+    result = polkit_authority_revoke_temporary_authorizations_sync(d->pkAuthority,
+             subject.subject(),
+             NULL,
+             &error);
+    if (error != NULL) {
+        d->setError(E_RevokeFailed, error->message);
+        g_error_free(error);
+        return false;
+    }
+    return result;
+}
+
+void Authority::revokeTemporaryAuthorizations(const Subject &subject)
+{
+    if (Authority::instance()->hasError()) {
+        return;
+    }
+
+    polkit_authority_revoke_temporary_authorizations(d->pkAuthority,
+            subject.subject(),
+            d->m_revokeTemporaryAuthorizationsCancellable,
+            d->revokeTemporaryAuthorizationsCallback,
+            this);
+}
+
+void Authority::Private::revokeTemporaryAuthorizationsCallback(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+    Authority *authority = (Authority *) user_data;
+    Q_ASSERT(authority != NULL);
+    GError *error = NULL;
+
+    bool res = polkit_authority_revoke_temporary_authorizations_finish((PolkitAuthority *) object, result, &error);
+
+    if (error != NULL) {
+        // We don't want to set error if this is cancellation of some action
+        if (error->code != 1) {
+            authority->d->setError(E_RevokeFailed, error->message);
+        }
+        g_error_free(error);
+        return;
+    }
+
+    Q_EMIT authority->revokeTemporaryAuthorizationsFinished(res);
+}
+
+void Authority::revokeTemporaryAuthorizationsCancel()
+{
+    if (!g_cancellable_is_cancelled(d->m_revokeTemporaryAuthorizationsCancellable)) {
+        g_cancellable_cancel(d->m_revokeTemporaryAuthorizationsCancellable);
+    }
+}
+
+bool Authority::revokeTemporaryAuthorizationSync(const QString &id)
+{
+    bool result;
+    if (Authority::instance()->hasError()) {
+        return false;
+    }
+
+    GError *error = NULL;
+    result =  polkit_authority_revoke_temporary_authorization_by_id_sync(d->pkAuthority,
+              id.toUtf8().data(),
+              NULL,
+              &error);
+    if (error != NULL) {
+        d->setError(E_RevokeFailed, error->message);
+        g_error_free(error);
+        return false;
+    }
+    return result;
+}
+
+void Authority::revokeTemporaryAuthorization(const QString &id)
+{
+    if (Authority::instance()->hasError()) {
+        return;
+    }
+
+    polkit_authority_revoke_temporary_authorization_by_id(d->pkAuthority,
+            id.toUtf8().data(),
+            d->m_revokeTemporaryAuthorizationCancellable,
+            d->revokeTemporaryAuthorizationCallback,
+            this);
+}
+
+void Authority::Private::revokeTemporaryAuthorizationCallback(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+    Authority *authority = (Authority *) user_data;
+    Q_ASSERT(authority != NULL);
+    GError *error = NULL;
+
+    bool res = polkit_authority_revoke_temporary_authorization_by_id_finish((PolkitAuthority *) object, result, &error);
+
+    if (error != NULL) {
+        // We don't want to set error if this is cancellation of some action
+        if (error->code != 1) {
+            authority->d->setError(E_RevokeFailed, error->message);
+        }
+        g_error_free(error);
+        return;
+    }
+
+    Q_EMIT authority->revokeTemporaryAuthorizationFinished(res);
+}
+
+void Authority::revokeTemporaryAuthorizationCancel()
+{
+    if (!g_cancellable_is_cancelled(d->m_revokeTemporaryAuthorizationCancellable)) {
+        g_cancellable_cancel(d->m_revokeTemporaryAuthorizationCancellable);
+    }
+}
+
+}
+
+#include "polkitqt1-authority.moc"
diff --git a/core/polkitqt1-authority.h b/core/polkitqt1-authority.h
new file mode 100644
index 000000000..64ebb8f13
--- /dev/null
+++ b/core/polkitqt1-authority.h
@@ -0,0 +1,539 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Daniel Nicoletti <dantti85-pk@yahoo.com.br>
+ * Copyright (C) 2009 Dario Freddi <drf@kde.org>
+ * Copyright (C) 2009 Jaroslav Reznik <jreznik@redhat.com>
+ * Copyright (C) 2009 Radek Novacek <rnovacek@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef POLKITQT1_AUTHORITY_H
+#define POLKITQT1_AUTHORITY_H
+
+#include "polkitqt1-export.h"
+#include "polkitqt1-identity.h"
+#include "polkitqt1-subject.h"
+#include "polkitqt1-temporaryauthorization.h"
+#include "polkitqt1-actiondescription.h"
+
+#include <QtCore/QObject>
+#include <QtCore/QMetaType>
+
+typedef struct _PolkitAuthority PolkitAuthority;
+class QStringList;
+
+/**
+ * \namespace PolkitQt1 PolkitQt
+ *
+ * \brief Namespace wrapping Polkit-Qt classes
+ *
+ * This namespace wraps all Polkit-Qt classes.
+ */
+namespace PolkitQt1
+{
+
+/**
+ * \class Authority polkitqt1-authority.h Authority
+ * \author Daniel Nicoletti <dantti85-pk@yahoo.com.br>
+ * \author Dario Freddi <drf@kde.org>
+ * \author Jaroslav Reznik <jreznik@redhat.com>
+ *
+ * \brief Convenience class for Qt/KDE applications
+ *
+ * This class is a singleton that provides makes easy the usage
+ * of PolKitAuthority. It emits configChanged()
+ * whenever PolicyKit files change (e.g. the PolicyKit.conf
+ * or .policy files) or when ConsoleKit reports activities changes.
+ *
+ * \note This class is a singleton, its constructor is private.
+ * Call Authority::instance() to get an instance of the Authority object.
+ * Do not delete Authority::instance(), cleanup will be done automatically.
+ */
+class POLKITQT1_EXPORT Authority : public QObject
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(Authority)
+    Q_ENUMS(Result)
+    Q_ENUMS(ErrorCode)
+public:
+    enum Result {
+        /** Result unknown */
+        Unknown = 0x00,
+        /** The subject is authorized for the specified action  */
+        Yes = 0x01,
+        /** The subject is not authorized for the specified action  */
+        No = 0x02,
+        /** The subject is authorized if more information is provided */
+        Challenge = 0x03
+    };
+
+    enum AuthorizationFlag {
+        /** No flags set **/
+        None = 0x00,
+        /** If the subject can obtain the authorization through authentication,
+        * and an authentication agent is available, then attempt to do so.
+        *
+        * Note, this means that the method used for checking authorization is likely
+        * to block for a long time. **/
+        AllowUserInteraction = 0x01
+    };
+    Q_DECLARE_FLAGS(AuthorizationFlags, AuthorizationFlag)
+
+    /** Error codes for the authority class */
+    enum ErrorCode {
+        /** No error occurred **/
+        E_None = 0x00,
+        /** Authority cannot be obtained **/
+        E_GetAuthority = 0x01,
+        /** Authority check failed **/
+        E_CheckFailed = 0x02,
+        /** Wrong or empty subject was given **/
+        E_WrongSubject = 0x03,
+        /** Action returned unknown result **/
+        E_UnknownResult = 0x04,
+        /** Enumerating actions failed **/
+        E_EnumFailed = 0x05,
+        /** Registration of authentication agent failed **/
+        E_RegisterFailed = 0x06,
+        /** Unregistration of authentication agent failed **/
+        E_UnregisterFailed = 0x07,
+        /** Cookie or polkitqt1-identity.handled to the action is empty **/
+        E_CookieOrIdentityEmpty = 0x08,
+        /** Response of auth agent failed **/
+        E_AgentResponseFailed = 0x09,
+        /** Revoke temporary authorizations failed **/
+        E_RevokeFailed = 0x0A
+    };
+
+    /**
+     * \brief Returns the instance of Authority
+     *
+     * Returns the current instance of Authority. Call this function whenever
+     * you need to access the Authority class.
+     *
+     * \note Authority is a singleton. Memory is handled by polkit-qt, so you just
+     * need to call this function to get a working instance of Authority.
+     * Don't delete the object after having used it.
+     *
+     * \param authority use this if you want to set an explicit PolkitAuthority. If you
+     *                don't know what this implies, simply ignore the parameter. In case
+     *                you want to use it, be sure of streaming it the first time you call
+     *                this function, otherwise it will have no effect.
+     *
+     * \return The current authority instance
+     */
+    static Authority *instance(PolkitAuthority *authority = 0);
+
+    ~Authority();
+
+    /**
+     * You should always call this method after every action. No action will be allowed
+     * if the object is in error state. Use clearError() to clear the error message.
+     *
+     * \see lastError
+     * \see clearError
+     *
+     * \return \c true if an error occurred, \c false if the library is ready
+     */
+    bool hasError() const;
+
+    /**
+     * \return the code of last error
+     */
+    ErrorCode lastError() const;
+
+    /**
+     * Get detail information about error that occurred.
+     *
+     * \return detail message
+     */
+    const QString errorDetails() const;
+
+    /**
+     * Use this method to clear the error message.
+     */
+    void clearError();
+
+    /**
+     * Returns the current instance of PolkitAuthority. If you are handling
+     * it through Polkit-qt (which is quite likely, since you are calling
+     * this function), DO NOT use any PolicyKit API's specific method that
+     * modifies the instance on it, unless you're completely aware of what you're doing and
+     * of the possible consequencies. Use this instance only to gather information.
+     *
+     * \return the current PolkitAuthority instance
+     */
+    PolkitAuthority *polkitAuthority() const;
+
+    /**
+     * This function should be used by mechanisms (e.g.: helper applications).
+     * It returns the action should be carried out, so if the caller was
+     * actually authorized to perform it. The result is in form of a Result, so that
+     * you can have more control over the whole process, and detect an eventual error.
+     * Most of the times you simply want to check if the result is == to \c Result::Yes,
+     * if you don't have specific needs.
+     *
+     * It is CRITICAL that you call this function
+     * and check what it returns before doing anything in your helper, since otherwise
+     * you could be actually performing an action from an unknown or unauthorized caller.
+     *
+     * When operation is finished, signal checkAuthorizationFinish is emitted
+     * with result of authorization check in its parameter.
+     *
+     * \see checkAuthorizationSync Synchronous version of this method.
+     * \see checkAuthorizationFinished Signal that is emitted when this method finishes.
+     * \see checkAuthorizationCancel Use it to cancel execution of this method.
+     *
+     * \param actionId the Id of the action in question
+     * \param subject subject that the action is authorized for (e.g. unix process)
+     * \param flags flags that influences the authorization checking
+     *
+     * \return \c Result::Yes if the caller is authorized and the action should be performed
+     *         \c otherwise if the caller was not authorized and the action should not be performed,
+     *                      or an error has occurred
+     *
+     */
+    void checkAuthorization(const QString &actionId, const Subject &subject,
+                            AuthorizationFlags flags);
+
+    /**
+     * Synchronous version of the checkAuthorization method.
+     *
+     * \param actionId the Id of the action in question
+     * \param subject subject that the action is authorized for (e.g. unix process)
+     * \param flags flags that influences the authorization checking
+     *
+     * \see checkAuthorization Asynchronous version of this method.
+     */
+    Result checkAuthorizationSync(const QString &actionId, const Subject &subject,
+                                  AuthorizationFlags flags);
+
+    /**
+     * This method can be used to cancel last authorization check.
+     */
+    void checkAuthorizationCancel();
+
+    /**
+     * Asynchronously retrieves all registered actions.
+     *
+     * When operation is finished, signal checkAuthorizationFinish is emitted
+     * with result of authorization check in its parameter.
+     *
+     * \see enumerateActionsSync Synchronous version of this method.
+     * \see enumerateActionsFinished Signal that is emitted when this method finishes.
+     * \see enumerateActionsCancel Use it to cancel execution of this method.
+     */
+    void enumerateActions();
+
+    /**
+     * Synchronously retrieves all registered actions.
+     *
+     * \see enumerateActions Asynchronous version of this method.
+     *
+     * \return a list of Action IDs
+     */
+    ActionDescription::List enumerateActionsSync();
+
+    /**
+     * This method can be used to cancel enumeration of actions
+     */
+    void enumerateActionsCancel();
+
+    /**
+     * Registers an authentication agent.
+     *
+     * \see registerAuthenticationAgentSync Synchronous version of this method.
+     * \see registerAuthenticationAgentFinished Signal that is emitted when this method finishes.
+     * \see registerAuthenticationAgentCancel Use it to cancel execution of this method.
+     *
+     * \param subject caller subject
+     * \param locale the locale of the authentication agent
+     * \param objectPath the object path for the authentication agent
+     */
+    void registerAuthenticationAgent(const Subject &subject, const QString &locale,
+                                     const QString &objectPath);
+
+    /**
+     * Registers an authentication agent.
+     *
+     * \see registerAuthenticationAgent Asynchronous version of this method.
+     *
+     * \param subject caller subject
+     * \param locale the locale of the authentication agent
+     * \param objectPath the object path for the authentication agent
+     *
+     * \return \c true if the Authentication agent has been successfully registered
+     *         \c false if the Authentication agent registration failed
+    */
+    bool registerAuthenticationAgentSync(const Subject &subject, const QString &locale,
+                                         const QString &objectPath);
+
+    /**
+     * This method can be used to cancel the registration of the authentication agent.
+     */
+    void registerAuthenticationAgentCancel();
+
+    /**
+     * Unregisters an Authentication agent.
+     *
+     * \see unregisterAuthenticationAgentSync Synchronous version of this method.
+     * \see unregisterAuthenticationAgentFinished Signal that is emitted when this method finishes.
+     * \see unregisterAuthenticationAgentCancel Use it to cancel execution of this method.
+     *
+     * \param subject caller subject
+     * \param objectPath the object path for the Authentication agent
+     *
+     * \return \c true if the Authentication agent has been successfully unregistered
+     *         \c false if the Authentication agent unregistration failed
+     */
+    void unregisterAuthenticationAgent(const Subject &subject, const QString &objectPath);
+
+    /**
+     * Unregisters an Authentication agent.
+     *
+     * \see unregisterAuthenticationAgent Asynchronous version of this method.
+     *
+     * \param subject caller subject
+     * \param objectPath the object path for the Authentication agent
+     *
+     * \return \c true if the Authentication agent has been successfully unregistered
+     *         \c false if the Authentication agent unregistration failed
+    */
+    bool unregisterAuthenticationAgentSync(const Subject &subject, const QString &objectPath);
+
+    /**
+     * This method can be used to cancel the unregistration of the authentication agent.
+     */
+    void unregisterAuthenticationAgentCancel();
+
+    /**
+     * Provide response that \p identity successfully authenticated for the authentication request identified by \p cookie.
+     *
+     * \see authenticationAgentResponseSync Synchronous version of this method.
+     * \see authenticationAgentResponseFinished Signal that is emitted when this method finishes.
+     * \see authenticationAgentResponseCancel Use it to cancel execution of this method.
+     *
+     * \param cookie The cookie passed to the authentication agent from the authority.
+     * \param identity The identity that was authenticated.
+     */
+    void authenticationAgentResponse(const QString &cookie, const Identity &identity);
+
+    /**
+     * Provide response that \p identity successfully authenticated for the authentication request identified by \p cookie.
+     *
+     * \see authenticationAgentResponse Asynchronous version of this method.
+     *
+     * \param cookie The cookie passed to the authentication agent from the authority.
+     * \param identity The identity that was authenticated.
+     *
+     * \return \c true if authority acknowledged the call, \c false if error is set.
+     *
+    */
+    bool authenticationAgentResponseSync(const QString& cookie, const PolkitQt1::Identity& identity);
+
+    /**
+     * This method can be used to cancel the authenticationAgentResponseAsync method.
+     */
+    void authenticationAgentResponseCancel();
+
+    /**
+     * Retrieves all temporary action that applies to \p subject.
+     *
+     * \see enumerateTemporaryAuthorizationsSync Synchronous version of this method.
+     * \see enumerateTemporaryAuthorizationsFinished Signal that is emitted when this method finishes.
+     * \see enumerateTemporaryAuthorizationsCancel Use it to cancel execution of this method.
+     *
+     * \param subject the subject to get temporary authorizations for
+     *
+     */
+    void enumerateTemporaryAuthorizations(const Subject &subject);
+
+    /**
+     * Retrieves all temporary action that applies to \p subject
+     *
+     * \see enumerateTemporaryAuthorizations Asynchronous version of this method.
+     *
+     * \param subject the subject to get temporary authorizations for
+     *
+     * \note Free all TemporaryAuthorization objects using \p delete operator.
+     *
+     * \return List of all temporary authorizations
+    */
+    TemporaryAuthorization::List enumerateTemporaryAuthorizationsSync(const Subject &subject);
+
+    /**
+     * This method can be used to cancel the enumerateTemporaryAuthorizationsAsync method.
+     */
+    void enumerateTemporaryAuthorizationsCancel();
+
+    /**
+     * Revokes all temporary authorizations that applies to \p subject
+     *
+     * \see revokeTemporaryAuthorizationsSync Synchronous version of this method.
+     * \see revokeTemporaryAuthorizationsFinished Signal that is emitted when this method finishes.
+     * \see revokeTemporaryAuthorizationsCancel Use it to cancel execution of this method.
+
+     * \param subject the subject to revoke temporary authorizations from
+     */
+    void revokeTemporaryAuthorizations(const Subject &subject);
+
+    /**
+     * Revokes all temporary authorizations that applies to \p subject
+     *
+     * \see revokeTemporaryAuthorizations Asynchronous version of this method.
+     *
+     * \param subject the subject to revoke temporary authorizations from
+     *
+     * \return \c true if all temporary authorization were revoked
+     *         \c false if the revoking failed
+    */
+    bool revokeTemporaryAuthorizationsSync(const Subject &subject);
+
+    /**
+     * This method can be used to cancel the method revokeTemporaryAuthorizationsAsync.
+     */
+    void revokeTemporaryAuthorizationsCancel();
+
+    /**
+     * Revokes temporary authorization by \p id
+     *
+     * \see revokeTemporaryAuthorizationSync Synchronous version of this method.
+     * \see revokeTemporaryAuthorizationFinished Signal that is emitted when this method finishes.
+     * \see revokeTemporaryAuthorizationCancel Use it to cancel execution of this method.
+     *
+     * \param id the identifier of the temporary authorization
+     */
+    void revokeTemporaryAuthorization(const QString &id);
+
+    /**
+     * Revokes temporary authorization by \p id
+     *
+     * \see revokeTemporaryAuthorization Asynchronous version of this method.
+     *
+     * \param id the identifier of the temporary authorization
+     *
+     * \return \c true if the temporary authorization was revoked
+     *         \c false if the revoking failed
+    */
+    bool revokeTemporaryAuthorizationSync(const QString &id);
+
+    /**
+     * This method can be used to cancel the method revokeTemporaryAuthorizationAsync.
+     */
+    void revokeTemporaryAuthorizationCancel();
+
+Q_SIGNALS:
+    /**
+     * This signal will be emitted when a configuration
+     * file gets changed (e.g. /etc/PolicyKit/PolicyKit.conf or
+     * .policy files).
+     * Connect to this signal if you want to track down
+     * actions.
+     */
+    void configChanged();
+
+    /**
+     * This signal is emitted when ConsoleKit configuration
+     * changes. This might happen when a session becomes active
+     * or inactive.
+     *
+     * If you want to track your actions directly you should
+     * connect to this signal, as this might change the return value
+     * PolicyKit will give you.
+     *
+     * \note If you use Action you'll probably prefer to
+     * use the dataChanged() signal to track Action changes.
+     */
+    void consoleKitDBChanged();
+
+    /**
+     * This signal is emitted when asynchronous method checkAuthorization finishes.
+     *
+     * The argument is the result of authorization.
+     */
+    void checkAuthorizationFinished(PolkitQt1::Authority::Result);
+
+    /**
+     * This signal is emitted when asynchronous method enumerateActions finishes.
+     *
+     * The argument is the list of all Action IDs.
+     */
+    void enumerateActionsFinished(PolkitQt1::ActionDescription::List);
+
+    /**
+     * This signal is emitted when asynchronous method registerAuthenticationAgent finishes.
+     *
+     * The argument is \c true  if the Authentication agent has been successfully registered
+     *                 \c false if the Authentication agent registration failed
+     */
+    void registerAuthenticationAgentFinished(bool);
+
+    /**
+     * This signal is emitted when asynchronous method unregisterAuthenticationAgent finishes.
+     *
+     * The argument is \c true  if the Authentication agent has been successfully unregistered
+     *                 \c false if the Authentication agent unregistration failed
+     */
+    void unregisterAuthenticationAgentFinished(bool);
+
+    /**
+     * This signal is emitted when asynchronous method authenticationAgentResponse finishes.
+     *
+     * The argument is \c true if authority acknowledged the call, \c false if error is set.
+     */
+    void authenticationAgentResponseFinished(bool);
+
+    /**
+     * This signal is emmited when asynchronous method enumerateTemporaryAuthorizations finishes.
+     *
+     * The argument is list of all temporary authorizations.
+     *
+     * \note Free all TemporaryAuthorization objects using \p delete operator.
+     */
+    void enumerateTemporaryAuthorizationsFinished(PolkitQt1::TemporaryAuthorization::List);
+
+    /**
+     * This signal is emmited when asynchronous method revokeTemporaryAuthorizations finishes.
+     *
+     * The argument is \c true if all temporary authorizations were revoked
+     *                 \c false if the revoking failed
+     */
+    void revokeTemporaryAuthorizationsFinished(bool);
+
+    /**
+     * This signal is emmited when asynchronous method revokeTemporaryAuthorization finishes.
+     * \return \c true if the temporary authorization was revoked
+     *         \c false if the revoking failed
+     */
+    void revokeTemporaryAuthorizationFinished(bool);
+
+private:
+    explicit Authority(PolkitAuthority *context, QObject *parent = 0);
+
+    class Private;
+    friend class Private;
+    Private * const d;
+
+    Q_PRIVATE_SLOT(d, void dbusFilter(const QDBusMessage &message))
+};
+
+}
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(PolkitQt1::Authority::AuthorizationFlags)
+Q_DECLARE_METATYPE(PolkitQt1::Authority::Result)
+
+#endif
diff --git a/core/polkitqt1-details.cpp b/core/polkitqt1-details.cpp
new file mode 100644
index 000000000..e1d0f315d
--- /dev/null
+++ b/core/polkitqt1-details.cpp
@@ -0,0 +1,99 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Radek Novacek <rnovacek@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "polkitqt1-details.h"
+
+#include <QtCore/QStringList>
+
+#include <polkit/polkit.h>
+
+namespace PolkitQt1
+{
+
+class Details::Data : public QSharedData
+{
+public:
+    Data() {}
+    Data(const Data &other)
+        : QSharedData(other)
+        , polkitDetails(other.polkitDetails)
+    {
+        g_object_ref(polkitDetails);
+    }
+    ~Data()
+    {
+        g_object_unref(polkitDetails);
+    }
+
+    PolkitDetails *polkitDetails;
+};
+
+Details::Details()
+        : d(new Data)
+{
+    g_type_init();
+    d->polkitDetails = polkit_details_new();
+}
+
+Details::Details(PolkitDetails *pkDetails)
+        : d(new Data)
+{
+    g_type_init();
+    d->polkitDetails = pkDetails;
+}
+
+Details::~Details()
+{
+}
+
+Details& Details::operator=(const PolkitQt1::Details& other)
+{
+    d = other.d;
+    return *this;
+}
+
+QString Details::lookup(const QString &key) const
+{
+    const gchar *result = polkit_details_lookup(d->polkitDetails, key.toUtf8().data());
+    if (result != NULL) {
+        return QString::fromUtf8(result);
+    } else {
+        return QString();
+    }
+}
+
+void Details::insert(const QString &key, const QString &value)
+{
+    polkit_details_insert(d->polkitDetails, key.toUtf8().data(), value.toUtf8().data());
+}
+
+QStringList Details::keys() const
+{
+    gchar **result = polkit_details_get_keys(d->polkitDetails);
+    QStringList list;
+    int len = g_strv_length(result);
+    for (int i = 0; i < len; i++) {
+        list.append(QString::fromUtf8(result[i]));
+    }
+    g_strfreev(result);
+    return list;
+}
+
+}
diff --git a/core/polkitqt1-details.h b/core/polkitqt1-details.h
new file mode 100644
index 000000000..dc55f854c
--- /dev/null
+++ b/core/polkitqt1-details.h
@@ -0,0 +1,97 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Radek Novacek <rnovacek@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef POLKITQT1_DETAILS_H
+#define POLKITQT1_DETAILS_H
+
+#include "polkitqt1-export.h"
+
+#include <QtCore/QObject>
+#include <QtCore/QSharedData>
+
+typedef struct _PolkitDetails PolkitDetails;
+
+/**
+ * \namespace PolkitQt1 PolkitQt
+ *
+ * \brief Namespace wrapping Polkit-Qt classes
+ *
+ * This namespace wraps all Polkit-Qt classes.
+ */
+namespace PolkitQt1
+{
+
+/**
+ * \class Details polkitqt1-details.h Details
+ * \author Radek Novacek <rnovacek@redhat.com>
+ *
+ * \brief Class used for passing details around.
+ */
+class POLKITQT1_EXPORT Details
+{
+public:
+    /**
+     * Creates a new Details object
+     */
+    Details();
+
+    /**
+     * Creates Details object from PolkitDetails
+     *
+     * \warning Use this only if you are completely aware of what are you doing!
+     *
+     * \param pkDetails PolkitDetails object
+     */
+    explicit Details(PolkitDetails *pkDetails);
+
+    ~Details();
+
+    Details &operator=(const Details &other);
+
+    /**
+     * Get the value for \p key
+     *
+     * \param key A key
+     * \return Value of the key \p key, otherwise empty QString.
+     */
+    QString lookup(const QString &key) const;
+
+    /**
+     * Inserts key \p key with value \p value.
+     *
+     * \param key A key.
+     * \param value A value.
+     */
+    void insert(const QString &key, const QString &value);
+
+    /**
+     * Gets a list of all keys.
+     *
+     * \return List of all keys.
+     */
+    QStringList keys() const;
+private:
+    class Data;
+    QExplicitlySharedDataPointer< Data > d;
+};
+
+}
+
+#endif // DETAILS_H
diff --git a/core/polkitqt1-identity.cpp b/core/polkitqt1-identity.cpp
new file mode 100644
index 000000000..354107213
--- /dev/null
+++ b/core/polkitqt1-identity.cpp
@@ -0,0 +1,227 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Lukas Tinkl <ltinkl@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "polkitqt1-identity.h"
+
+#include <polkit/polkit.h>
+
+#include <QtCore/QDebug>
+
+namespace PolkitQt1
+{
+
+class Identity::Data : public QSharedData
+{
+public:
+    Data() : identity(0) {}
+    Data(const Data& other)
+        : QSharedData(other)
+        , identity(other.identity)
+    {
+        if (identity) {
+            g_object_ref(identity);
+        }
+    }
+    ~Data()
+    {
+        if (identity) {
+            g_object_unref(identity);
+        }
+    }
+
+    PolkitIdentity *identity;
+};
+
+Identity::Identity()
+        : d(new Data)
+{
+    g_type_init();
+}
+
+Identity::Identity(PolkitIdentity *polkitIdentity)
+        : d(new Data)
+{
+    g_type_init();
+    d->identity = polkitIdentity;
+
+    if (d->identity) {
+        g_object_ref(d->identity);
+    }
+}
+
+Identity::Identity(const PolkitQt1::Identity& other)
+        : d(other.d)
+{
+
+}
+
+Identity::~Identity()
+{
+}
+
+Identity& Identity::operator=(const PolkitQt1::Identity& other)
+{
+    d = other.d;
+    return *this;
+}
+
+bool Identity::isValid() const
+{
+    return d->identity != NULL;
+}
+
+PolkitIdentity *Identity::identity() const
+{
+    return d->identity;
+}
+
+void Identity::setIdentity(PolkitIdentity *identity)
+{
+    if (d->identity == identity) {
+        return;
+    }
+
+    if (d->identity) {
+        g_object_unref(d->identity);
+    }
+
+    d->identity = identity;
+
+    if (d->identity) {
+        g_object_ref(d->identity);
+    }
+}
+
+QString Identity::toString() const
+{
+    Q_ASSERT(d->identity);
+    return QString::fromUtf8(polkit_identity_to_string(d->identity));
+}
+
+Identity Identity::fromString(const QString &string)
+{
+    GError *error = NULL;
+    PolkitIdentity *pkIdentity = polkit_identity_from_string(string.toUtf8().data(), &error);
+    if (error != NULL) {
+        qWarning() << QString("Cannot create Identity from string: %1").arg(error->message);
+        return Identity();
+    }
+    return Identity(pkIdentity);
+}
+
+UnixGroupIdentity Identity::toUnixGroupIdentity()
+{
+    UnixGroupIdentity *ugid = static_cast< UnixGroupIdentity* >(this);
+    if (!ugid) {
+        return UnixGroupIdentity();
+    }
+
+    return *ugid;
+}
+
+UnixUserIdentity Identity::toUnixUserIdentity()
+{
+    UnixUserIdentity *uuid = static_cast< UnixUserIdentity* >(this);
+    if (!uuid) {
+        return UnixUserIdentity();
+    }
+
+    return *uuid;
+}
+
+UnixUserIdentity::UnixUserIdentity(const QString &name)
+        : Identity()
+{
+    GError *error = NULL;
+    setIdentity(polkit_unix_user_new_for_name(name.toUtf8().data(), &error));
+    if (error != NULL) {
+        qWarning() << QString("Cannot create UnixUserIdentity: %1").arg(error->message);
+        setIdentity(NULL);
+    }
+}
+
+UnixUserIdentity::UnixUserIdentity(uid_t uid)
+        : Identity()
+{
+    setIdentity(polkit_unix_user_new(uid));
+}
+
+UnixUserIdentity::UnixUserIdentity(PolkitUnixUser *pkUnixUser)
+        : Identity((PolkitIdentity *)pkUnixUser)
+{
+
+}
+
+UnixUserIdentity::UnixUserIdentity()
+        : Identity()
+{
+
+}
+
+uid_t UnixUserIdentity::uid() const
+{
+    return polkit_unix_user_get_uid((PolkitUnixUser *) identity());
+}
+
+void UnixUserIdentity::setUid(uid_t uid)
+{
+    polkit_unix_user_set_uid((PolkitUnixUser *) identity(), uid);
+}
+
+UnixGroupIdentity::UnixGroupIdentity(const QString &name)
+        : Identity()
+{
+    GError *error = NULL;
+    setIdentity(polkit_unix_group_new_for_name(name.toUtf8().data(), &error));
+    if (error != NULL) {
+        qWarning() << QString("Cannot create UnixGroupIdentity: %1").arg(error->message);
+        setIdentity(NULL);
+    }
+}
+
+UnixGroupIdentity::UnixGroupIdentity(gid_t gid)
+        : Identity()
+{
+    setIdentity(polkit_unix_group_new(gid));
+}
+
+UnixGroupIdentity::UnixGroupIdentity(PolkitUnixGroup *pkUnixGroup)
+        : Identity((PolkitIdentity *) pkUnixGroup)
+{
+
+}
+
+UnixGroupIdentity::UnixGroupIdentity()
+        : Identity()
+{
+
+}
+
+gid_t UnixGroupIdentity::gid() const
+{
+    return polkit_unix_group_get_gid((PolkitUnixGroup *) identity());
+}
+
+void UnixGroupIdentity::setGid(gid_t gid)
+{
+    polkit_unix_group_set_gid((PolkitUnixGroup *) identity(), gid);
+}
+
+}
diff --git a/core/polkitqt1-identity.h b/core/polkitqt1-identity.h
new file mode 100644
index 000000000..faed3a332
--- /dev/null
+++ b/core/polkitqt1-identity.h
@@ -0,0 +1,211 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Lukas Tinkl <ltinkl@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef POLKITQT1_IDENTITY_H
+#define POLKITQT1_IDENTITY_H
+
+#include "polkitqt1-export.h"
+
+#include <unistd.h>
+
+#include <QtCore/QObject>
+#include <QtCore/QSharedData>
+
+typedef struct _PolkitIdentity PolkitIdentity;
+typedef struct _PolkitUnixUser PolkitUnixUser;
+typedef struct _PolkitUnixGroup PolkitUnixGroup;
+
+/**
+ * \namespace PolkitQt1 PolkitQt
+ *
+ * \brief Namespace wrapping Polkit-Qt classes
+ *
+ * This namespace wraps all Polkit-Qt classes.
+ */
+namespace PolkitQt1
+{
+
+class UnixUserIdentity;
+class UnixGroupIdentity;
+
+/**
+ * \class Identity polkitqt1-identity.h Identity
+ * \author Lukas Tinkl <ltinkl@redhat.com>
+ *
+ * This class encapsulates the PolkitIdentity interface.
+ *
+ * \brief Abstract class representing identities
+ *
+ * \see UnixGroup
+ * \see UnixUser
+ */
+class POLKITQT1_EXPORT Identity
+{
+public:
+    typedef QList< Identity > List;
+
+    Identity();
+    explicit Identity(PolkitIdentity *polkitIdentity);
+    Identity(const Identity &other);
+
+    ~Identity();
+
+    Identity &operator=(const Identity &other);
+
+    bool isValid() const;
+
+    /**
+     * Serialization of object to the string
+     *
+     * \return Serialized Identity object
+     */
+    QString toString() const;
+
+    /**
+     * Creates the Identity object from string representation
+     *
+     * \param string string representation of the object
+     *
+     * \return Pointer to new Identity instance
+     */
+    static Identity fromString(const QString &string);
+
+    UnixUserIdentity toUnixUserIdentity();
+    UnixGroupIdentity toUnixGroupIdentity();
+
+    /**
+     * Gets PolkitIdentity object.
+     *
+     * \warning It shouldn't be used directly unless you are completely aware of what are you doing
+     *
+     * \return Pointer to PolkitIdentity instance
+     */
+    PolkitIdentity *identity() const;
+protected:
+    void setIdentity(PolkitIdentity *identity);
+
+private:
+    class Data;
+    QExplicitlySharedDataPointer< Data > d;
+};
+
+/**
+  * \class UnixUserIdentity polkitqt1-identity.h Identity
+  *
+  * An object representing a user identity on a UNIX system.
+  *
+  * \brief UNIX user identity
+  * \sa Identity
+  */
+class POLKITQT1_EXPORT UnixUserIdentity : public Identity
+{
+public:
+    UnixUserIdentity();
+    /**
+     * Creates UnixUser object by UID of the user
+     *
+     * \param uid user id
+     */
+    explicit UnixUserIdentity(uid_t uid);
+
+    /**
+     * Creates UnixUser object by unix name of the user
+     *
+     * \param name Unix name
+     */
+    explicit UnixUserIdentity(const QString &name);
+
+    /**
+     * Creates UnixUser object from PolkitUnixUser object
+     *
+     * \warning Use this only if you are completely aware of what are you doing!
+     *
+     * \param pkUnixUser The PolkitUnixUser object
+     */
+    explicit UnixUserIdentity(PolkitUnixUser *pkUnixUser);
+
+    /**
+     * Gets an user id
+     *
+     * \return user id
+     */
+    uid_t uid() const;
+
+    /**
+     * Sets the id of user
+     *
+     * \param uid user id
+     */
+    void setUid(uid_t uid);
+};
+
+/**
+  * \class UnixGroupIdentity polkitqt1-identity.h Identity
+  *
+  * An object representing a group identity on a UNIX system.
+  *
+  * \brief UNIX group identity
+  * \sa Identity
+  */
+class POLKITQT1_EXPORT UnixGroupIdentity : public Identity
+{
+public:
+    UnixGroupIdentity();
+    /**
+     * Creates UnixGroup object by GID of the group
+     *
+     * \param gid group id
+     */
+    explicit UnixGroupIdentity(gid_t gid);
+
+    /**
+     * Creates UnixGroup object by unix name of the group
+     *
+     * \param name group name
+     */
+    explicit UnixGroupIdentity(const QString &name);
+
+    /**
+     * Creates UnixGroup object from PolkitUnixGroup object
+     *
+     * \warning Use this only if you are completely aware of what are you doing!
+     *
+     * \param pkUnixGroup The PolkitUnixGroup object
+     */
+    explicit UnixGroupIdentity(PolkitUnixGroup *pkUnixGroup);
+
+    /**
+     * Gets a group id
+     *
+     * \return group id
+     */
+    gid_t gid() const;
+
+    /**
+     * Sets the id of group
+     *
+     * \param gid group id
+     */
+    void setGid(gid_t gid);
+};
+
+}
+
+#endif // POLKIT_QT_IDENTITY_H
diff --git a/core/polkitqt1-subject.cpp b/core/polkitqt1-subject.cpp
new file mode 100644
index 000000000..dfc969711
--- /dev/null
+++ b/core/polkitqt1-subject.cpp
@@ -0,0 +1,205 @@
+/*
+ * This file is part of the Polkit-qt project
+ * Copyright (C) 2009 Jaroslav Reznik <jreznik@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "polkitqt1-subject.h"
+
+#include <QtCore/QDebug>
+#include <polkit/polkit.h>
+
+namespace PolkitQt1
+{
+
+class Subject::Data : public QSharedData
+{
+public:
+    Data()
+        : QSharedData()
+        , subject(0)
+    {}
+    Data(const Data& other)
+        : QSharedData(other)
+        , subject(other.subject)
+    {
+        g_object_ref(subject);
+    }
+    ~Data()
+    {
+        g_object_unref(subject);
+    }
+
+    PolkitSubject *subject;
+};
+
+Subject::Subject()
+        : d(new Data)
+{
+    g_type_init();
+}
+
+Subject::Subject(PolkitSubject *subject)
+        : d(new Data)
+{
+    g_type_init();
+    d->subject = subject;
+}
+
+Subject::Subject(const PolkitQt1::Subject& other)
+        : d(other.d)
+{
+
+}
+
+Subject& Subject::operator=(const PolkitQt1::Subject& other)
+{
+    d = other.d;
+    return *this;
+}
+
+Subject::~Subject()
+{
+}
+
+bool Subject::isValid() const
+{
+    return d->subject != NULL;
+}
+
+PolkitSubject *Subject::subject() const
+{
+    return d->subject;
+}
+
+void Subject::setSubject(PolkitSubject *subject)
+{
+    d->subject = subject;
+}
+
+QString Subject::toString() const
+{
+    Q_ASSERT(d->subject);
+    return QString::fromUtf8(polkit_subject_to_string(d->subject));
+}
+
+Subject Subject::fromString(const QString &string)
+{
+    // should be in polkit library!!! but for strange reason it's necessary to have it here
+    g_type_init();
+
+    Subject subject;
+    GError *error = NULL;
+    subject.d->subject = polkit_subject_from_string(string.toUtf8().data(), &error);
+    if (error != NULL) {
+        qWarning() << QString("Cannot create Subject from string: %1").arg(error->message);
+        return NULL;
+    }
+    return subject;
+}
+
+UnixProcessSubject::UnixProcessSubject(qint64 pid)
+        : Subject()
+{
+    setSubject(polkit_unix_process_new(pid));
+}
+
+UnixProcessSubject::UnixProcessSubject(qint64 pid, quint64 startTime)
+        : Subject()
+{
+    setSubject(polkit_unix_process_new_full(pid, startTime));
+}
+
+UnixProcessSubject::UnixProcessSubject(PolkitUnixProcess *pkUnixProcess)
+        : Subject((PolkitSubject *) pkUnixProcess)
+{
+
+}
+
+qint64 UnixProcessSubject::pid() const
+{
+    return polkit_unix_process_get_pid((PolkitUnixProcess *) subject());
+}
+
+qint64 UnixProcessSubject::startTime() const
+{
+    return polkit_unix_process_get_start_time((PolkitUnixProcess *) subject());
+}
+
+void UnixProcessSubject::setPid(qint64 pid)
+{
+    polkit_unix_process_set_pid((PolkitUnixProcess *) subject(), pid);
+}
+
+// ----- SystemBusName
+SystemBusNameSubject::SystemBusNameSubject(const QString &name)
+        : Subject()
+{
+    setSubject(polkit_system_bus_name_new(name.toUtf8().data()));
+}
+
+SystemBusNameSubject::SystemBusNameSubject(PolkitSystemBusName *pkSystemBusName)
+        : Subject((PolkitSubject *) pkSystemBusName)
+{
+
+}
+
+QString SystemBusNameSubject::name() const
+{
+    return QString::fromUtf8(polkit_system_bus_name_get_name((PolkitSystemBusName *) subject()));
+}
+
+void SystemBusNameSubject::setName(const QString &name)
+{
+    polkit_system_bus_name_set_name((PolkitSystemBusName *) subject(), name.toUtf8().data());
+}
+
+// ----- SystemSession
+UnixSessionSubject::UnixSessionSubject(const QString &sessionId)
+        : Subject()
+{
+    setSubject(polkit_unix_session_new(sessionId.toUtf8().data()));
+}
+
+UnixSessionSubject::UnixSessionSubject(qint64 pid)
+        : Subject()
+{
+    GError *error = NULL;
+    setSubject(polkit_unix_session_new_for_process_sync(pid, NULL, &error));
+    if (error != NULL) {
+        qWarning() << QString("Cannot create unix session: %1").arg(error->message);
+        setSubject(NULL);
+    }
+}
+
+UnixSessionSubject::UnixSessionSubject(PolkitSystemBusName *pkUnixSession)
+        : Subject((PolkitSubject *) pkUnixSession)
+{
+
+}
+
+QString UnixSessionSubject::sessionId() const
+{
+    return QString::fromUtf8(polkit_unix_session_get_session_id((PolkitUnixSession *) subject()));
+}
+
+void UnixSessionSubject::setSessionId(const QString &sessionId)
+{
+    polkit_unix_session_set_session_id((PolkitUnixSession *) subject(), sessionId.toUtf8().data());
+}
+
+}
diff --git a/core/polkitqt1-subject.h b/core/polkitqt1-subject.h
new file mode 100644
index 000000000..800318dfe
--- /dev/null
+++ b/core/polkitqt1-subject.h
@@ -0,0 +1,262 @@
+/*
+ * This file is part of the PolKit1-qt project
+ * Copyright (C) 2009 Jaroslav Reznik <jreznik@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef POLKITQT1_SUBJECT_H
+#define POLKITQT1_SUBJECT_H
+
+#include "polkitqt1-export.h"
+
+#include <QtCore/QObject>
+#include <QtCore/QSharedData>
+
+typedef struct _PolkitSubject PolkitSubject;
+typedef struct _PolkitUnixProcess PolkitUnixProcess;
+typedef struct _PolkitSystemBusName PolkitSystemBusName;
+
+/**
+ * \namespace PolkitQt1 PolkitQt
+ *
+ * \brief Namespace wrapping PolicyKit-Qt classes
+ *
+ * This namespace wraps all PolicyKit-Qt classes.
+ */
+namespace PolkitQt1
+{
+
+/**
+ * \class Subject polkitqt1-subject.h Subject
+ * \author Jaroslav Reznik <jreznik@redhat.com>
+ *
+ * \brief This class represents PolicyKit subjects
+ *
+ * This class encapsulates the PolkitSubject interface.
+ *
+ * \see UnixProcess
+ * \see SystemBusName
+ * \see UnixSession
+ */
+class POLKITQT1_EXPORT Subject
+{
+public:
+    Subject();
+    Subject(const Subject &other);
+    ~Subject();
+
+    Subject &operator=(const Subject &other);
+
+    bool isValid() const;
+
+    /**
+     * Serialization of object to the string
+     *
+     * \return Serialized Subject object
+     */
+    QString toString() const;
+
+    /**
+     * Creates the Subject object from string reprezentation
+     *
+     * \param string string reprezentation of the object
+     *
+     * \return Pointer to new Subject instance
+     */
+    static Subject fromString(const QString &string);
+
+    /**
+     * Gets PolkitSubject object.
+     *
+     * \warning It shouldn't be used directly unless you are completely aware of what are you doing
+     *
+     * \return Pointer to PolkitSubject instance
+     */
+    PolkitSubject *subject() const;
+
+protected:
+    Subject(PolkitSubject *subject);
+
+    void setSubject(PolkitSubject *subject);
+
+private:
+    class Data;
+    QExplicitlySharedDataPointer< Data > d;
+};
+
+/**
+ * \class UnixProcessSubject polkitqt1-subject.h Subject
+ * \author Jaroslav Reznik <jreznik@redhat.com>
+ *
+ * \brief A class for representing a UNIX process.
+ *
+ * To uniquely identify processes, both the process
+ * id and the start time of the process (a monotonic
+ * increasing value representing the time since the
+ * kernel was started) is used.
+ *
+ * \sa Subject
+ */
+class POLKITQT1_EXPORT UnixProcessSubject : public Subject
+{
+public:
+    /**
+    * Subject constructor, takes one parameter - PID. The start time
+    * of process will be looked automatically.
+    *
+    * \param pid An Unix process PID.
+    */
+    explicit UnixProcessSubject(qint64 pid);
+
+    /**
+    * Subject constructor, takes two parameters - PID and start time.
+    *
+    * \param pid An Unix process PID.
+    * \param startTime An Unix process start time.
+    */
+    UnixProcessSubject(qint64 pid, quint64 startTime);
+
+    /**
+     * Subject constructor, it creates UnixProcess object from PolkitUnixProcess object
+     *
+     * \warning Use this only if you are completely aware of what are you doing!
+     *
+     * \param process PolkitUnixProcess object
+     */
+    explicit UnixProcessSubject(PolkitUnixProcess *process);
+
+    /**
+    * Returns Unix process PID.
+    *
+    * \return A PID of associated Unix process.
+    */
+    qint64 pid() const;
+
+    /**
+    * Returns Unix process start time.
+    *
+    * \return A start time of associated Unix process.
+    */
+    qint64 startTime() const;
+
+    /**
+    * Sets Unix process PID.
+    *
+    * \param pid An Unix process PID.
+    */
+    void setPid(qint64 pid);
+};
+
+/**
+ * \class SystemBusNameSubject polkitqt1-subject.h Subject
+ * \author Jaroslav Reznik <jreznik@redhat.com>
+ *
+ * \brief A class for representing a process owning a unique name on the system bus.
+ *
+ * \sa Subject
+ */
+class POLKITQT1_EXPORT SystemBusNameSubject : public Subject
+{
+public:
+    /**
+    * Subject constructor, takes one parameter - system bus name.
+    *
+    * \param name A unique system bus name.
+    */
+    explicit SystemBusNameSubject(const QString &name);
+
+    /**
+     * Subject constructor, it creates SystemBusName object from PolkitSystemBusName object
+     *
+     * \warning Use this only if you are completely aware of what are you doing!
+     *
+     * \param pkSystemBusName PolkitSystemBusName object
+     */
+    explicit SystemBusNameSubject(PolkitSystemBusName *pkSystemBusName);
+
+    /**
+    * Returns system bus name.
+    *
+    * \return A unique system bus name.
+    */
+    QString name() const;
+
+    /**
+    * Sets system bus name.
+    *
+    * \param name System bus name.
+    */
+    void setName(const QString &name);
+};
+
+/**
+ * \class UnixSessionSubject polkitqt1-subject.h Subject
+ * \author Jaroslav Reznik <jreznik@redhat.com>
+ *
+ * \brief A class for representing unix session.
+ *
+ * The session id is an opaque string obtained from
+ * ConsoleKit.
+ *
+ * \sa Subject
+ */
+class POLKITQT1_EXPORT UnixSessionSubject : public Subject
+{
+public:
+    /**
+    * Subject constructor, takes one parameter - session id.
+    *
+    * \param sessionId The session id.
+    */
+    explicit UnixSessionSubject(const QString &sessionId);
+
+    /**
+    * Subject constructor, takes one parameter - pid of process.
+    *
+    * Synchronous!
+    *
+    * \param pid The session's process pid.
+    */
+    explicit UnixSessionSubject(qint64 pid);
+
+    /**
+     * Subject constructor, it creates UnixSession object from PolkitUnixSession object
+     *
+     * \warning Use this only if you are completely aware of what are you doing!
+     *
+     * \param pkUnixSession PolkitUnixSession object
+     */
+    explicit UnixSessionSubject(PolkitSystemBusName *pkUnixSession);
+
+    /**
+    * Returns session id.
+    *
+    * \return A session id.
+    */
+    QString sessionId() const;
+
+    /**
+    * Sets session id.
+    *
+    * \param sessionId A session id.
+    */
+    void setSessionId(const QString &sessionId);
+};
+
+}
+
+#endif
diff --git a/core/polkitqt1-temporaryauthorization.cpp b/core/polkitqt1-temporaryauthorization.cpp
new file mode 100644
index 000000000..5242faf7a
--- /dev/null
+++ b/core/polkitqt1-temporaryauthorization.cpp
@@ -0,0 +1,117 @@
+/*
+ * This file is part of the PolKit1-qt project
+ * Copyright (C) 2009 Radek Novacek <rnovacek@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "polkitqt1-temporaryauthorization.h"
+#include "polkitqt1-authority.h"
+
+#include <polkit/polkit.h>
+
+namespace PolkitQt1
+{
+
+class TemporaryAuthorization::Data : public QSharedData
+{
+public:
+    Data() {}
+    Data(const Data& other)
+        : QSharedData(other)
+        , id(other.id)
+        , actionId(other.actionId)
+        , subject(other.subject)
+        , timeObtained(other.timeObtained)
+        , timeExpires(other.timeExpires)
+    {
+    }
+    ~Data() {}
+
+    QString id;
+    QString actionId;
+    Subject subject;
+    QDateTime timeObtained;
+    QDateTime timeExpires;
+};
+
+TemporaryAuthorization::TemporaryAuthorization(PolkitTemporaryAuthorization *pkTemporaryAuthorization)
+        : d(new Data)
+{
+    g_type_init();
+    d->id = QString::fromUtf8(polkit_temporary_authorization_get_id(pkTemporaryAuthorization));
+    d->actionId = QString::fromUtf8(polkit_temporary_authorization_get_action_id(pkTemporaryAuthorization));
+    d->subject = Subject::fromString(polkit_subject_to_string(polkit_temporary_authorization_get_subject(pkTemporaryAuthorization)));
+    d->timeObtained = QDateTime::fromTime_t(polkit_temporary_authorization_get_time_obtained(pkTemporaryAuthorization));
+    d->timeExpires = QDateTime::fromTime_t(polkit_temporary_authorization_get_time_expires(pkTemporaryAuthorization));
+    g_object_unref(pkTemporaryAuthorization);
+}
+
+TemporaryAuthorization::TemporaryAuthorization(const PolkitQt1::TemporaryAuthorization& other)
+        : d(other.d)
+{
+
+}
+
+TemporaryAuthorization::TemporaryAuthorization()
+        : d(new Data)
+{
+
+}
+
+TemporaryAuthorization& TemporaryAuthorization::operator=(const PolkitQt1::TemporaryAuthorization& other)
+{
+    d = other.d;
+    return *this;
+}
+
+TemporaryAuthorization::~TemporaryAuthorization()
+{
+}
+
+QString TemporaryAuthorization::id() const
+{
+    return d->id;
+}
+
+QString TemporaryAuthorization::actionId() const
+{
+    return d->actionId;
+}
+
+Subject TemporaryAuthorization::subject() const
+{
+    //qFatal(polkit_subject_to_string(polkit_temporary_authorization_get_subject(d->temporaryAuthorization)));
+    return d->subject;//Subject::fromString(polkit_subject_to_string(d->subject));
+}
+
+QDateTime TemporaryAuthorization::obtainedAt() const
+{
+    return d->timeObtained;
+}
+
+QDateTime TemporaryAuthorization::expirationTime() const
+{
+    return d->timeExpires;
+}
+
+bool TemporaryAuthorization::revoke()
+{
+    Authority::instance()->revokeTemporaryAuthorization(id());
+    return true;
+}
+
+}
diff --git a/core/polkitqt1-temporaryauthorization.h b/core/polkitqt1-temporaryauthorization.h
new file mode 100644
index 000000000..f8a13ea17
--- /dev/null
+++ b/core/polkitqt1-temporaryauthorization.h
@@ -0,0 +1,124 @@
+/*
+ * This file is part of the PolKit1-qt project
+ * Copyright (C) 2009 Radek Novacek <rnovacek@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef POLKITQT1_TEMPORARYAUTHORIZATION_H
+#define POLKITQT1_TEMPORARYAUTHORIZATION_H
+
+#include "polkitqt1-subject.h"
+
+#include <QtCore/QObject>
+#include <QtCore/QDateTime>
+#include <QtCore/QMetaType>
+#include <QtCore/QSharedData>
+
+typedef struct _PolkitTemporaryAuthorization PolkitTemporaryAuthorization;
+
+/**
+ * \namespace PolkitQt1 PolkitQt
+ *
+ * \brief Namespace wrapping PolicyKit-Qt classes
+ *
+ * This namespace wraps all PolicyKit-Qt classes.
+ */
+namespace PolkitQt1
+{
+
+/**
+ * \class TemporaryAuthorization polkitqt1-temporaryauthorization.h TemporaryAuthorization
+ * \author Radek Novacek <rnovacek@redhat.com>
+ *
+ * \brief This class represents PolicyKit temporary authorization
+ *
+ * This class encapsulates the PolkitTemporaryAuthorization interface.
+ */
+class POLKITQT1_EXPORT TemporaryAuthorization
+{
+public:
+    typedef QList< TemporaryAuthorization > List;
+    TemporaryAuthorization();
+    /**
+     * Creates TemporaryAuthorization object from PolkitTemporaryAuthorization
+     *
+     * \warning It shouldn't be used directly unless you are completely aware of what are you doing
+     *
+     * \param pkTemporaryAuthorization PolkitTemporaryAuthorization object
+     * \param parent
+     */
+    explicit TemporaryAuthorization(PolkitTemporaryAuthorization *pkTemporaryAuthorization);
+    TemporaryAuthorization(const TemporaryAuthorization &other);
+
+    ~TemporaryAuthorization();
+
+    TemporaryAuthorization &operator=(const TemporaryAuthorization &other);
+
+    /**
+     * \brief Gets the identifier for the authorization.
+     *
+     * This identifier can be user by the revokeTemporaryAuthorization function
+     *
+     * \return Unique identifier for the authorization
+     */
+    QString id() const;
+
+    /**
+     * \brief Gets the identifier of the action that authorization is for
+     *
+     * \return String that identifies the action
+     */
+    QString actionId() const;
+
+    /**
+     * \brief Gets the subject that authorization is for
+     *
+     * \return A Subject.
+     */
+    Subject subject() const;
+
+    /**
+     * \brief Gets the time when authorization was obtained
+     *
+     * \return Time of obtaining the authorization
+     */
+    QDateTime obtainedAt() const;
+
+    /**
+     * \brief Gets the time when authorizaton will expire
+     *
+     * \return Time of expiration
+     */
+    QDateTime expirationTime() const;
+
+    /**
+     * \brief Revoke temporary authorization
+     *
+     * \return \c true Authorization has been revoked
+     *         \c false Revoking authorization failed
+     */
+    bool revoke();
+
+private:
+    class Data;
+    QSharedDataPointer< Data > d;
+};
+}
+
+Q_DECLARE_METATYPE(PolkitQt1::TemporaryAuthorization::List)
+
+#endif // TEMPORARYAUTHORIZATION_H