Adding upstream version 43.0.upstream/43.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 3210 insertions, 0 deletions

diff --git a/plugins/print-notifications/gsd-print-notifications-manager.c b/plugins/print-notifications/gsd-print-notifications-manager.c
new file mode 100644
index 0000000..4e0b3ab
--- /dev/null
+++ b/plugins/print-notifications/gsd-print-notifications-manager.c
@@ -0,0 +1,1725 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2011 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include <locale.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+
+#include <cups/cups.h>
+#include <cups/ppd.h>
+#include <libnotify/notify.h>
+
+#include "gnome-settings-profile.h"
+#include "gsd-print-notifications-manager.h"
+
+#define CUPS_DBUS_NAME      "org.cups.cupsd.Notifier"
+#define CUPS_DBUS_PATH      "/org/cups/cupsd/Notifier"
+#define CUPS_DBUS_INTERFACE "org.cups.cupsd.Notifier"
+
+#define RENEW_INTERVAL                   3500
+#define SUBSCRIPTION_DURATION            3600
+#define CONNECTING_TIMEOUT               60
+#define REASON_TIMEOUT                   15000
+#define CUPS_CONNECTION_TEST_INTERVAL    300
+#define CHECK_INTERVAL                   60 /* secs */
+#define AUTHENTICATION_CHECK_TIMEOUT     3
+
+#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5)
+#define HAVE_CUPS_1_6 1
+#endif
+
+#ifndef HAVE_CUPS_1_6
+#define ippGetStatusCode(ipp) ipp->request.status.status_code
+#define ippGetInteger(attr, element) attr->values[element].integer
+#define ippGetString(attr, element, language) attr->values[element].string.text
+#define ippGetName(attr) attr->name
+#define ippGetCount(attr) attr->num_values
+#define ippGetBoolean(attr, index) attr->values[index].boolean
+
+static ipp_attribute_t *
+ippNextAttribute (ipp_t *ipp)
+{
+  if (!ipp || !ipp->current)
+    return (NULL);
+  return (ipp->current = ipp->current->next);
+}
+#endif
+
+struct _GsdPrintNotificationsManager
+{
+        GObject                       parent;
+
+        GDBusConnection              *cups_bus_connection;
+        gint                          subscription_id;
+        cups_dest_t                  *dests;
+        gint                          num_dests;
+        gboolean                      scp_handler_spawned;
+        GPid                          scp_handler_pid;
+        GList                        *timeouts;
+        GHashTable                   *printing_printers;
+        GList                        *active_notifications;
+        guint                         cups_connection_timeout_id;
+        guint                         check_source_id;
+        guint                         cups_dbus_subscription_id;
+        guint                         renew_source_id;
+        gint                          last_notify_sequence_number;
+        guint                         start_idle_id;
+        GList                        *held_jobs;
+};
+
+static void     gsd_print_notifications_manager_class_init  (GsdPrintNotificationsManagerClass *klass);
+static void     gsd_print_notifications_manager_init        (GsdPrintNotificationsManager      *print_notifications_manager);
+static void     gsd_print_notifications_manager_finalize    (GObject                           *object);
+static gboolean cups_connection_test                        (gpointer                           user_data);
+static gboolean process_new_notifications                   (gpointer                           user_data);
+
+G_DEFINE_TYPE (GsdPrintNotificationsManager, gsd_print_notifications_manager, G_TYPE_OBJECT)
+
+static gpointer manager_object = NULL;
+
+static const char *
+password_cb (const char *prompt,
+             http_t     *http,
+             const char *method,
+             const char *resource,
+             void       *user_data)
+{
+  return NULL;
+}
+
+static char *
+get_dest_attr (const char *dest_name,
+               const char *attr,
+               cups_dest_t *dests,
+               int          num_dests)
+{
+        cups_dest_t *dest;
+        const char  *value;
+        char        *ret;
+
+        if (dest_name == NULL)
+                return NULL;
+
+        ret = NULL;
+
+        dest = cupsGetDest (dest_name, NULL, num_dests, dests);
+        if (dest == NULL) {
+                g_debug ("Unable to find a printer named '%s'", dest_name);
+                goto out;
+        }
+
+        value = cupsGetOption (attr, dest->num_options, dest->options);
+        if (value == NULL) {
+                g_debug ("Unable to get %s for '%s'", attr, dest_name);
+                goto out;
+        }
+        ret = g_strdup (value);
+ out:
+        return ret;
+}
+
+static gboolean
+is_cupsbrowsed_dest (const char *name)
+{
+        const char  *val = NULL;
+        gboolean     is_cupsbrowsed = FALSE;
+        cups_dest_t *found_dest = NULL;
+
+        found_dest = cupsGetNamedDest (CUPS_HTTP_DEFAULT, name, NULL);
+        if (found_dest == NULL) {
+                goto out;
+        }
+
+        val = cupsGetOption ("cups-browsed", found_dest->num_options, found_dest->options);
+        if (val == NULL) {
+                goto out;
+        }
+
+        if (g_str_equal (val, "yes") || g_str_equal (val, "on") || g_str_equal (val, "true")) {
+                is_cupsbrowsed = TRUE;
+        }
+out:
+        if (found_dest != NULL) {
+                cupsFreeDests (1, found_dest);
+        }
+
+        return is_cupsbrowsed;
+}
+
+static gboolean
+is_local_dest (const char  *name,
+               cups_dest_t *dests,
+               int          num_dests)
+{
+        char        *type_str;
+        cups_ptype_t type;
+        gboolean     is_remote;
+
+        is_remote = TRUE;
+
+        type_str = get_dest_attr (name, "printer-type", dests, num_dests);
+        if (type_str == NULL) {
+                goto out;
+        }
+
+        type = atoi (type_str);
+        is_remote = type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_IMPLICIT);
+        g_free (type_str);
+ out:
+        return !is_remote;
+}
+
+static gboolean
+server_is_local (const gchar *server_name)
+{
+        if (server_name != NULL &&
+            (g_ascii_strncasecmp (server_name, "localhost", 9) == 0 ||
+             g_ascii_strncasecmp (server_name, "127.0.0.1", 9) == 0 ||
+             g_ascii_strncasecmp (server_name, "::1", 3) == 0 ||
+             server_name[0] == '/')) {
+                return TRUE;
+        } else {
+                return FALSE;
+        }
+}
+
+static int
+strcmp0(const void *a, const void *b)
+{
+        return g_strcmp0 (*((gchar **) a), *((gchar **) b));
+}
+
+struct
+{
+        gchar *printer_name;
+        gchar *primary_text;
+        gchar *secondary_text;
+        guint  timeout_id;
+        GsdPrintNotificationsManager *manager;
+} typedef TimeoutData;
+
+struct
+{
+        gchar *printer_name;
+        gchar *reason;
+        NotifyNotification *notification;
+        gulong notification_close_id;
+        GsdPrintNotificationsManager *manager;
+} typedef ReasonData;
+
+struct
+{
+        guint  job_id;
+        gchar *printer_name;
+        guint  timeout_id;
+} typedef HeldJob;
+
+static void
+free_timeout_data (gpointer user_data)
+{
+        TimeoutData *data = (TimeoutData *) user_data;
+
+        if (data) {
+                g_free (data->printer_name);
+                g_free (data->primary_text);
+                g_free (data->secondary_text);
+                g_free (data);
+        }
+}
+
+static void
+free_reason_data (gpointer user_data)
+{
+        ReasonData *data = (ReasonData *) user_data;
+
+        if (data) {
+                if (data->notification_close_id > 0 &&
+                    g_signal_handler_is_connected (data->notification,
+                                                   data->notification_close_id))
+                        g_signal_handler_disconnect (data->notification, data->notification_close_id);
+
+                g_object_unref (data->notification);
+
+                g_free (data->printer_name);
+                g_free (data->reason);
+
+                g_free (data);
+        }
+}
+
+static void
+free_held_job (gpointer user_data)
+{
+        HeldJob *job = (HeldJob *) user_data;
+
+        if (job != NULL) {
+                g_free (job->printer_name);
+                g_free (job);
+        }
+}
+
+static void
+notification_closed_cb (NotifyNotification *notification,
+                        gpointer            user_data)
+{
+        ReasonData *data = (ReasonData *) user_data;
+
+        if (data) {
+                data->manager->active_notifications =
+                        g_list_remove (data->manager->active_notifications, data);
+
+                free_reason_data (data);
+        }
+}
+
+static gboolean
+show_notification (gpointer user_data)
+{
+        NotifyNotification *notification;
+        TimeoutData        *data = (TimeoutData *) user_data;
+        ReasonData         *reason_data;
+        GList              *tmp;
+
+        if (!data)
+                return FALSE;
+
+        notification = notify_notification_new (data->primary_text,
+                                                data->secondary_text,
+                                                "printer-symbolic");
+
+        notify_notification_set_app_name (notification, _("Printers"));
+        notify_notification_set_hint (notification,
+                                      "resident",
+                                      g_variant_new_boolean (TRUE));
+        notify_notification_set_timeout (notification, REASON_TIMEOUT);
+        notify_notification_set_hint_string (notification, "desktop-entry", "gnome-printers-panel");
+
+        reason_data = g_new0 (ReasonData, 1);
+        reason_data->printer_name = g_strdup (data->printer_name);
+        reason_data->reason = g_strdup ("connecting-to-device");
+        reason_data->notification = notification;
+        reason_data->manager = data->manager;
+
+        reason_data->notification_close_id =
+                g_signal_connect (notification,
+                                  "closed",
+                                  G_CALLBACK (notification_closed_cb),
+                                  reason_data);
+
+        reason_data->manager->active_notifications =
+                g_list_append (reason_data->manager->active_notifications, reason_data);
+
+        notify_notification_show (notification, NULL);
+
+        tmp = g_list_find (data->manager->timeouts, data);
+        if (tmp) {
+                data->manager->timeouts = g_list_remove_link (data->manager->timeouts, tmp);
+                g_list_free_full (tmp, free_timeout_data);
+        }
+
+        return FALSE;
+}
+
+static gboolean
+reason_is_blacklisted (const gchar *reason)
+{
+        if (g_str_equal (reason, "none"))
+                return TRUE;
+
+        if (g_str_equal (reason, "other"))
+                return TRUE;
+
+        if (g_str_equal (reason, "com.apple.print.recoverable"))
+                return TRUE;
+
+        /* https://bugzilla.redhat.com/show_bug.cgi?id=883401 */
+        if (g_str_has_prefix (reason, "cups-remote-"))
+                return TRUE;
+
+        /* https://bugzilla.redhat.com/show_bug.cgi?id=1207154 */
+        if (g_str_equal (reason, "cups-waiting-for-job-completed"))
+                return TRUE;
+
+        return FALSE;
+}
+
+static void
+on_cups_notification (GDBusConnection *connection,
+                      const char      *sender_name,
+                      const char      *object_path,
+                      const char      *interface_name,
+                      const char      *signal_name,
+                      GVariant        *parameters,
+                      gpointer         user_data)
+{
+        /* Ignore any signal starting with Server*. This has caused a message
+         * storm through ServerAudit messages in the past, see
+         *  https://gitlab.gnome.org/GNOME/gnome-settings-daemon/issues/62
+         */
+        if (!signal_name || (strncmp (signal_name, "Server", 6) == 0))
+                return;
+
+        process_new_notifications (user_data);
+}
+
+static gchar *
+get_statuses_second (guint i,
+                     const gchar *printer_name)
+{
+        gchar *status;
+
+        switch (i) {
+                case 0:
+                        /* Translators: The printer is low on toner (same as in system-config-printer) */
+                        status = g_strdup_printf (_("Printer “%s” is low on toner."), printer_name);
+                        break;
+                case 1:
+                        /* Translators: The printer has no toner left (same as in system-config-printer) */
+                        status = g_strdup_printf (_("Printer “%s” has no toner left."), printer_name);
+                        break;
+                case 2:
+                        /* Translators: The printer is in the process of connecting to a shared network output device (same as in system-config-printer) */
+                        status = g_strdup_printf (_("Printer “%s” may not be connected."), printer_name);
+                        break;
+                case 3:
+                        /* Translators: One or more covers on the printer are open (same as in system-config-printer) */
+                        status = g_strdup_printf (_("The cover is open on printer “%s”."), printer_name);
+                        break;
+                case 4:
+                        /* Translators: A filter or backend is not installed (same as in system-config-printer) */
+                        status = g_strdup_printf (_("There is a missing print filter for "
+                                                    "printer “%s”."), printer_name);
+                        break;
+                case 5:
+                        /* Translators: One or more doors on the printer are open (same as in system-config-printer) */
+                        status = g_strdup_printf (_("The door is open on printer “%s”."), printer_name);
+                        break;
+                case 6:
+                        /* Translators: "marker" is one color bin of the printer */
+                        status = g_strdup_printf (_("Printer “%s” is low on a marker supply."), printer_name);
+                        break;
+                case 7:
+                        /* Translators: "marker" is one color bin of the printer */
+                        status = g_strdup_printf (_("Printer “%s” is out of a marker supply."), printer_name);
+                        break;
+                case 8:
+                        /* Translators: At least one input tray is low on media (same as in system-config-printer) */
+                        status = g_strdup_printf (_("Printer “%s” is low on paper."), printer_name);
+                        break;
+                case 9:
+                        /* Translators: At least one input tray is empty (same as in system-config-printer) */
+                        status = g_strdup_printf (_("Printer “%s” is out of paper."), printer_name);
+                        break;
+                case 10:
+                        /* Translators: The printer is offline (same as in system-config-printer) */
+                        status = g_strdup_printf (_("Printer “%s” is currently off-line."), printer_name);
+                        break;
+                case 11:
+                        /* Translators: The printer has detected an error (same as in system-config-printer) */
+                        status = g_strdup_printf (_("There is a problem on printer “%s”."), printer_name);
+                        break;
+                default:
+                        g_assert_not_reached ();
+        }
+
+        return status;
+}
+
+static void
+authenticate_cb (NotifyNotification *notification,
+                 gchar              *action,
+                 gpointer            user_data)
+{
+        GAppInfo *app_info;
+        gboolean  ret;
+        GError   *error = NULL;
+        gchar    *commandline;
+        gchar    *printer_name = user_data;
+
+        if (g_strcmp0 (action, "default") == 0) {
+                notify_notification_close (notification, NULL);
+
+                commandline = g_strdup_printf (BINDIR "/gnome-control-center printers show-jobs %s", printer_name);
+                app_info = g_app_info_create_from_commandline (commandline,
+                                                               "gnome-control-center",
+                                                               G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION,
+                                                               &error);
+                g_free (commandline);
+
+                if (app_info != NULL) {
+                        ret = g_app_info_launch (app_info,
+                                                 NULL,
+                                                 NULL,
+                                                 &error);
+
+                        if (!ret) {
+                                g_warning ("failed to launch gnome-control-center: %s", error->message);
+                                g_error_free (error);
+                        }
+
+                        g_object_unref (app_info);
+                } else {
+                        g_warning ("failed to create application info: %s", error->message);
+                        g_error_free (error);
+                }
+        }
+}
+
+static void
+unref_notification (NotifyNotification *notification,
+                    gpointer            data)
+{
+        g_object_unref (notification);
+}
+
+static gint
+check_job_for_authentication (gpointer userdata)
+{
+        GsdPrintNotificationsManager *manager = userdata;
+        ipp_attribute_t              *attr;
+        static gchar                 *requested_attributes[] = { "job-state-reasons", "job-hold-until", NULL };
+        gboolean                      needs_authentication = FALSE;
+        HeldJob                      *job;
+        gchar                        *primary_text;
+        gchar                        *secondary_text;
+        gchar                        *job_uri;
+        ipp_t                        *request, *response;
+        gint                          i;
+
+        if (manager->held_jobs != NULL) {
+                job = (HeldJob *) manager->held_jobs->data;
+
+                manager->held_jobs = g_list_delete_link (manager->held_jobs,
+                                                               manager->held_jobs);
+
+                request = ippNewRequest (IPP_GET_JOB_ATTRIBUTES);
+
+                job_uri = g_strdup_printf ("ipp://localhost/jobs/%u", job->job_id);
+                ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                              "job-uri", NULL, job_uri);
+                g_free (job_uri);
+                ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                              "requesting-user-name", NULL, cupsUser ());
+                ippAddStrings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                               "requested-attributes", 2, NULL, (const char **) requested_attributes);
+
+                response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+                if (response != NULL) {
+                        if (ippGetStatusCode (response) <= IPP_OK_CONFLICT) {
+                                if ((attr = ippFindAttribute (response, "job-state-reasons", IPP_TAG_ZERO)) != NULL) {
+                                        for (i = 0; i < ippGetCount (attr); i++) {
+                                                if (g_strcmp0 (ippGetString (attr, i, NULL), "cups-held-for-authentication") == 0) {
+                                                        needs_authentication = TRUE;
+                                                        break;
+                                                }
+                                        }
+                                }
+
+                                if (!needs_authentication && (attr = ippFindAttribute (response, "job-hold-until", IPP_TAG_ZERO)) != NULL) {
+                                        if (g_strcmp0 (ippGetString (attr, 0, NULL), "auth-info-required") == 0)
+                                                needs_authentication = TRUE;
+                                }
+                        }
+
+                        ippDelete (response);
+                }
+
+                if (needs_authentication) {
+                        NotifyNotification *notification;
+
+                        /* Translators: The printer has a job to print but the printer needs authentication to continue with the print */
+                        primary_text = g_strdup_printf (_("%s Requires Authentication"), job->printer_name);
+                        /* Translators: A printer needs credentials to continue printing a job */
+                        secondary_text = g_strdup_printf (_("Credentials required in order to print"));
+
+                        notification = notify_notification_new (primary_text,
+                                                                secondary_text,
+                                                                "printer-symbolic");
+                        notify_notification_set_app_name (notification, _("Printers"));
+                        notify_notification_set_hint_string (notification, "desktop-entry", "gnome-printers-panel");
+                        notify_notification_add_action (notification,
+                                                        "default",
+                                                        /* This is a default action so the label won't be shown */
+                                                        "Authenticate",
+                                                        authenticate_cb,
+                                                        g_strdup (job->printer_name), g_free);
+                        g_signal_connect (notification, "closed", G_CALLBACK (unref_notification), NULL);
+
+                        notify_notification_show (notification, NULL);
+
+                        g_free (primary_text);
+                        g_free (secondary_text);
+                }
+
+                free_held_job (job);
+        }
+
+        return G_SOURCE_REMOVE;
+}
+
+static void
+process_cups_notification (GsdPrintNotificationsManager *manager,
+                           const char                   *notify_subscribed_event,
+                           const char                   *notify_text,
+                           const char                   *notify_printer_uri,
+                           const char                   *printer_name,
+                           gint                          printer_state,
+                           const char                   *printer_state_reasons,
+                           gboolean                      printer_is_accepting_jobs,
+                           guint                         notify_job_id,
+                           gint                          job_state,
+                           const char                   *job_state_reasons,
+                           const char                   *job_name,
+                           gint                          job_impressions_completed)
+{
+        ipp_attribute_t *attr;
+        gboolean         my_job = FALSE;
+        gboolean         known_reason;
+        HeldJob         *held_job;
+        http_t          *http;
+        gchar           *primary_text = NULL;
+        gchar           *secondary_text = NULL;
+        gchar           *job_uri = NULL;
+        ipp_t           *request, *response;
+        static const char * const reasons[] = {
+                "toner-low",
+                "toner-empty",
+                "connecting-to-device",
+                "cover-open",
+                "cups-missing-filter",
+                "door-open",
+                "marker-supply-low",
+                "marker-supply-empty",
+                "media-low",
+                "media-empty",
+                "offline",
+                "other"};
+
+        static const char * statuses_first[] = {
+                /* Translators: The printer is low on toner (same as in system-config-printer) */
+                N_("Toner low"),
+                /* Translators: The printer has no toner left (same as in system-config-printer) */
+                N_("Toner empty"),
+                /* Translators: The printer is in the process of connecting to a shared network output device (same as in system-config-printer) */
+                N_("Not connected?"),
+                /* Translators: One or more covers on the printer are open (same as in system-config-printer) */
+                N_("Cover open"),
+                /* Translators: A filter or backend is not installed (same as in system-config-printer) */
+                N_("Printer configuration error"),
+                /* Translators: One or more doors on the printer are open (same as in system-config-printer) */
+                N_("Door open"),
+                /* Translators: "marker" is one color bin of the printer */
+                N_("Marker supply low"),
+                /* Translators: "marker" is one color bin of the printer */
+                N_("Out of a marker supply"),
+                /* Translators: At least one input tray is low on media (same as in system-config-printer) */
+                N_("Paper low"),
+                /* Translators: At least one input tray is empty (same as in system-config-printer) */
+                N_("Out of paper"),
+                /* Translators: The printer is offline (same as in system-config-printer) */
+                N_("Printer off-line"),
+                /* Translators: The printer has detected an error (same as in system-config-printer) */
+                N_("Printer error") };
+
+        if (g_strcmp0 (notify_subscribed_event, "printer-added") != 0 &&
+            g_strcmp0 (notify_subscribed_event, "printer-deleted") != 0 &&
+            g_strcmp0 (notify_subscribed_event, "printer-state-changed") != 0 &&
+            g_strcmp0 (notify_subscribed_event, "job-completed") != 0 &&
+            g_strcmp0 (notify_subscribed_event, "job-state-changed") != 0 &&
+            g_strcmp0 (notify_subscribed_event, "job-created") != 0)
+                return;
+
+        if (notify_job_id > 0) {
+                if ((http = httpConnectEncrypt (cupsServer (), ippPort (),
+                                                cupsEncryption ())) == NULL) {
+                        g_debug ("Connection to CUPS server \'%s\' failed.", cupsServer ());
+                } else {
+                        job_uri = g_strdup_printf ("ipp://localhost/jobs/%d", notify_job_id);
+
+                        request = ippNewRequest (IPP_GET_JOB_ATTRIBUTES);
+                        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                                      "job-uri", NULL, job_uri);
+                        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                                     "requesting-user-name", NULL, cupsUser ());
+                        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                                     "requested-attributes", NULL, "job-originating-user-name");
+                        response = cupsDoRequest (http, request, "/");
+
+                        if (response) {
+                                if (ippGetStatusCode (response) <= IPP_OK_CONFLICT &&
+                                    (attr = ippFindAttribute(response, "job-originating-user-name",
+                                                             IPP_TAG_NAME))) {
+                                        if (g_strcmp0 (ippGetString (attr, 0, NULL), cupsUser ()) == 0)
+                                                my_job = TRUE;
+                                }
+                                ippDelete(response);
+                        }
+                        g_free (job_uri);
+                        httpClose (http);
+                }
+        }
+
+        if (g_strcmp0 (notify_subscribed_event, "printer-added") == 0) {
+                cupsFreeDests (manager->num_dests, manager->dests);
+                manager->num_dests = cupsGetDests (&manager->dests);
+
+                if (is_local_dest (printer_name,
+                                   manager->dests,
+                                   manager->num_dests) &&
+                    !is_cupsbrowsed_dest (printer_name)) {
+                        /* Translators: New printer has been added */
+                        primary_text = g_strdup (_("Printer added"));
+                        secondary_text = g_strdup (printer_name);
+                }
+        } else if (g_strcmp0 (notify_subscribed_event, "printer-deleted") == 0) {
+                cupsFreeDests (manager->num_dests, manager->dests);
+                manager->num_dests = cupsGetDests (&manager->dests);
+        } else if (g_strcmp0 (notify_subscribed_event, "job-completed") == 0 && my_job) {
+                g_hash_table_remove (manager->printing_printers,
+                                     printer_name);
+
+                switch (job_state) {
+                        case IPP_JOB_PENDING:
+                        case IPP_JOB_HELD:
+                        case IPP_JOB_PROCESSING:
+                                break;
+                        case IPP_JOB_STOPPED:
+                                /* Translators: A print job has been stopped */
+                                primary_text = g_strdup (C_("print job state", "Printing stopped"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                        case IPP_JOB_CANCELED:
+                                /* Translators: A print job has been canceled */
+                                primary_text = g_strdup (C_("print job state", "Printing canceled"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                        case IPP_JOB_ABORTED:
+                                /* Translators: A print job has been aborted */
+                                primary_text = g_strdup (C_("print job state", "Printing aborted"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                        case IPP_JOB_COMPLETED:
+                                /* Translators: A print job has been completed */
+                                primary_text = g_strdup (C_("print job state", "Printing completed"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                }
+        } else if (g_strcmp0 (notify_subscribed_event, "job-state-changed") == 0 && my_job) {
+                switch (job_state) {
+                        case IPP_JOB_PROCESSING:
+                                g_hash_table_insert (manager->printing_printers,
+                                                     g_strdup (printer_name), NULL);
+
+                                /* Translators: A job is printing */
+                                primary_text = g_strdup (C_("print job state", "Printing"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                        case IPP_JOB_STOPPED:
+                                g_hash_table_remove (manager->printing_printers,
+                                                     printer_name);
+                                /* Translators: A print job has been stopped */
+                                primary_text = g_strdup (C_("print job state", "Printing stopped"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                        case IPP_JOB_CANCELED:
+                                g_hash_table_remove (manager->printing_printers,
+                                                     printer_name);
+                                /* Translators: A print job has been canceled */
+                                primary_text = g_strdup (C_("print job state", "Printing canceled"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                        case IPP_JOB_ABORTED:
+                                g_hash_table_remove (manager->printing_printers,
+                                                     printer_name);
+                                /* Translators: A print job has been aborted */
+                                primary_text = g_strdup (C_("print job state", "Printing aborted"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                        case IPP_JOB_COMPLETED:
+                                g_hash_table_remove (manager->printing_printers,
+                                                     printer_name);
+                                /* Translators: A print job has been completed */
+                                primary_text = g_strdup (C_("print job state", "Printing completed"));
+                                /* Translators: "print-job xy" on a printer */
+                                secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                                break;
+                        case IPP_JOB_HELD:
+                                held_job = g_new (HeldJob, 1);
+                                held_job->job_id = notify_job_id;
+                                held_job->printer_name = g_strdup (printer_name);
+                                /* CUPS takes sometime to change the "job-state-reasons" to "cups-held-for-authentication"
+                                   after the job changes job-state to "held" state but this change is not signalized
+                                   by any event so we just check the job-state-reason (or job-hold-until) after some timeout */
+                                held_job->timeout_id = g_timeout_add_seconds (AUTHENTICATION_CHECK_TIMEOUT, check_job_for_authentication, manager);
+
+                                manager->held_jobs = g_list_append (manager->held_jobs, held_job);
+                                break;
+                        default:
+                                break;
+                }
+        } else if (g_strcmp0 (notify_subscribed_event, "job-created") == 0 && my_job) {
+                if (job_state == IPP_JOB_PROCESSING) {
+                        g_hash_table_insert (manager->printing_printers,
+                                             g_strdup (printer_name), NULL);
+
+                        /* Translators: A job is printing */
+                        primary_text = g_strdup (C_("print job state", "Printing"));
+                        /* Translators: "print-job xy" on a printer */
+                        secondary_text = g_strdup_printf (C_("print job", "“%s” on %s"), job_name, printer_name);
+                }
+        } else if (g_strcmp0 (notify_subscribed_event, "printer-state-changed") == 0) {
+                cups_dest_t  *dest = NULL;
+                const gchar  *tmp_printer_state_reasons = NULL;
+                GSList       *added_reasons = NULL;
+                GSList       *tmp_list = NULL;
+                GList        *tmp;
+                gchar       **old_state_reasons = NULL;
+                gchar       **new_state_reasons = NULL;
+                gint          i, j;
+
+                /* Remove timeout which shows notification about possible disconnection of printer
+                 * if "connecting-to-device" has vanished.
+                 */
+                if (printer_state_reasons == NULL ||
+                    g_strrstr (printer_state_reasons, "connecting-to-device") == NULL) {
+                        TimeoutData *data;
+
+                        for (tmp = manager->timeouts; tmp; tmp = g_list_next (tmp)) {
+                                data = (TimeoutData *) tmp->data;
+                                if (g_strcmp0 (printer_name, data->printer_name) == 0) {
+                                        g_source_remove (data->timeout_id);
+                                        manager->timeouts = g_list_remove_link (manager->timeouts, tmp);
+                                        g_list_free_full (tmp, free_timeout_data);
+                                        break;
+                                }
+                        }
+                }
+
+                for (tmp = manager->active_notifications; tmp; tmp = g_list_next (tmp)) {
+                        ReasonData *reason_data = (ReasonData *) tmp->data;
+                        GList      *remove_list;
+
+                        if (printer_state_reasons == NULL ||
+                            (g_strcmp0 (printer_name, reason_data->printer_name) == 0 &&
+                             g_strrstr (printer_state_reasons, reason_data->reason) == NULL)) {
+
+                                if (reason_data->notification_close_id > 0 &&
+                                    g_signal_handler_is_connected (reason_data->notification,
+                                                                   reason_data->notification_close_id)) {
+                                        g_signal_handler_disconnect (reason_data->notification,
+                                                                     reason_data->notification_close_id);
+                                        reason_data->notification_close_id = 0;
+                                }
+
+                                notify_notification_close (reason_data->notification, NULL);
+
+                                remove_list = tmp;
+                                tmp = g_list_next (tmp);
+                                manager->active_notifications =
+                                        g_list_remove_link (manager->active_notifications, remove_list);
+
+                                g_list_free_full (remove_list, free_reason_data);
+                        }
+                }
+
+                /* Check whether we are printing on this printer right now. */
+                if (g_hash_table_lookup_extended (manager->printing_printers, printer_name, NULL, NULL)) {
+                        dest = cupsGetDest (printer_name,
+                                            NULL,
+                                            manager->num_dests,
+                                            manager->dests);
+                        if (dest)
+                                tmp_printer_state_reasons = cupsGetOption ("printer-state-reasons",
+                                                                           dest->num_options,
+                                                                           dest->options);
+
+                        if (tmp_printer_state_reasons)
+                                old_state_reasons = g_strsplit (tmp_printer_state_reasons, ",", -1);
+
+                        cupsFreeDests (manager->num_dests, manager->dests);
+                        manager->num_dests = cupsGetDests (&manager->dests);
+
+                        dest = cupsGetDest (printer_name,
+                                            NULL,
+                                            manager->num_dests,
+                                            manager->dests);
+                        if (dest)
+                                tmp_printer_state_reasons = cupsGetOption ("printer-state-reasons",
+                                                                           dest->num_options,
+                                                                           dest->options);
+
+                        if (tmp_printer_state_reasons)
+                                new_state_reasons = g_strsplit (tmp_printer_state_reasons, ",", -1);
+
+                        if (new_state_reasons)
+                                qsort (new_state_reasons,
+                                       g_strv_length (new_state_reasons),
+                                       sizeof (gchar *),
+                                       strcmp0);
+
+                        if (old_state_reasons) {
+                                qsort (old_state_reasons,
+                                       g_strv_length (old_state_reasons),
+                                       sizeof (gchar *),
+                                       strcmp0);
+
+                                j = 0;
+                                for (i = 0; new_state_reasons && i < g_strv_length (new_state_reasons); i++) {
+                                        while (old_state_reasons[j] &&
+                                               g_strcmp0 (old_state_reasons[j], new_state_reasons[i]) < 0)
+                                                j++;
+
+                                        if (old_state_reasons[j] == NULL ||
+                                            g_strcmp0 (old_state_reasons[j], new_state_reasons[i]) != 0)
+                                                added_reasons = g_slist_append (added_reasons,
+                                                                                new_state_reasons[i]);
+                                }
+                        } else {
+                                for (i = 0; new_state_reasons && i < g_strv_length (new_state_reasons); i++) {
+                                        added_reasons = g_slist_append (added_reasons,
+                                                                        new_state_reasons[i]);
+                                }
+                        }
+
+                        for (tmp_list = added_reasons; tmp_list; tmp_list = tmp_list->next) {
+                                gchar *data = (gchar *) tmp_list->data;
+                                known_reason = FALSE;
+                                for (j = 0; j < G_N_ELEMENTS (reasons); j++) {
+                                        if (strncmp (data,
+                                                     reasons[j],
+                                                     strlen (reasons[j])) == 0) {
+                                                NotifyNotification *notification;
+                                                known_reason = TRUE;
+
+                                                if (g_strcmp0 (reasons[j], "connecting-to-device") == 0) {
+                                                        TimeoutData *data;
+
+                                                        data = g_new0 (TimeoutData, 1);
+                                                        data->printer_name = g_strdup (printer_name);
+                                                        data->primary_text = g_strdup ( _(statuses_first[j]));
+                                                        data->secondary_text = get_statuses_second (j, printer_name);
+                                                        data->manager = manager;
+
+                                                        data->timeout_id = g_timeout_add_seconds (CONNECTING_TIMEOUT, show_notification, data);
+                                                        g_source_set_name_by_id (data->timeout_id, "[gnome-settings-daemon] show_notification");
+                                                        manager->timeouts = g_list_append (manager->timeouts, data);
+                                                } else {
+                                                        ReasonData *reason_data;
+                                                        gchar *second_row = get_statuses_second (j, printer_name);
+
+                                                        notification = notify_notification_new ( _(statuses_first[j]),
+                                                                                                second_row,
+                                                                                                "printer-symbolic");
+                                                        notify_notification_set_app_name (notification, _("Printers"));
+                                                        notify_notification_set_hint_string (notification, "desktop-entry", "gnome-printers-panel");
+                                                        notify_notification_set_hint (notification,
+                                                                                      "resident",
+                                                                                      g_variant_new_boolean (TRUE));
+                                                        notify_notification_set_timeout (notification, REASON_TIMEOUT);
+
+                                                        reason_data = g_new0 (ReasonData, 1);
+                                                        reason_data->printer_name = g_strdup (printer_name);
+                                                        reason_data->reason = g_strdup (reasons[j]);
+                                                        reason_data->notification = notification;
+                                                        reason_data->manager = manager;
+
+                                                        reason_data->notification_close_id =
+                                                                g_signal_connect (notification,
+                                                                                  "closed",
+                                                                                  G_CALLBACK (notification_closed_cb),
+                                                                                  reason_data);
+
+                                                        manager->active_notifications =
+                                                                g_list_append (manager->active_notifications, reason_data);
+
+                                                        notify_notification_show (notification, NULL);
+
+                                                        g_free (second_row);
+                                                }
+                                        }
+                                }
+
+                                if (!known_reason &&
+                                    !reason_is_blacklisted (data)) {
+                                        NotifyNotification *notification;
+                                        ReasonData         *reason_data;
+                                        gchar              *first_row;
+                                        gchar              *second_row;
+                                        gchar              *text = NULL;
+                                        gchar              *ppd_file_name;
+                                        ppd_file_t         *ppd_file;
+                                        char                buffer[8192];
+
+                                        ppd_file_name = g_strdup (cupsGetPPD (printer_name));
+                                        if (ppd_file_name) {
+                                                ppd_file = ppdOpenFile (ppd_file_name);
+                                                if (ppd_file) {
+                                                        gchar **tmpv;
+                                                        static const char * const schemes[] = {
+                                                                "text", "http", "help", "file"
+                                                        };
+
+                                                        tmpv = g_new0 (gchar *, G_N_ELEMENTS (schemes) + 1);
+                                                        i = 0;
+                                                        for (j = 0; j < G_N_ELEMENTS (schemes); j++) {
+                                                                if (ppdLocalizeIPPReason (ppd_file, data, schemes[j], buffer, sizeof (buffer))) {
+                                                                        tmpv[i++] = g_strdup (buffer);
+                                                                }
+                                                        }
+
+                                                        if (i > 0)
+                                                                text = g_strjoinv (", ", tmpv);
+                                                        g_strfreev (tmpv);
+
+                                                        ppdClose (ppd_file);
+                                                }
+
+                                                g_unlink (ppd_file_name);
+                                                g_free (ppd_file_name);
+                                        }
+
+
+                                        if (g_str_has_suffix (data, "-report"))
+                                                /* Translators: This is a title of a report notification for a printer */
+                                                first_row = g_strdup (_("Printer report"));
+                                        else if (g_str_has_suffix (data, "-warning"))
+                                                /* Translators: This is a title of a warning notification for a printer */
+                                                first_row = g_strdup (_("Printer warning"));
+                                        else
+                                                /* Translators: This is a title of an error notification for a printer */
+                                                first_row = g_strdup (_("Printer error"));
+
+
+                                        if (text == NULL)
+                                                text = g_strdup (data);
+
+                                        /* Translators: "Printer 'MyPrinterName': 'Description of the report/warning/error from a PPD file'." */
+                                        second_row = g_strdup_printf (_("Printer “%s”: “%s”."), printer_name, text);
+                                        g_free (text);
+
+
+                                        notification = notify_notification_new (first_row,
+                                                                                second_row,
+                                                                                "printer-symbolic");
+                                        notify_notification_set_app_name (notification, _("Printers"));
+                                        notify_notification_set_hint_string (notification, "desktop-entry", "gnome-printers-panel");
+                                        notify_notification_set_hint (notification,
+                                                                      "resident",
+                                                                      g_variant_new_boolean (TRUE));
+                                        notify_notification_set_timeout (notification, REASON_TIMEOUT);
+
+                                        reason_data = g_new0 (ReasonData, 1);
+                                        reason_data->printer_name = g_strdup (printer_name);
+                                        reason_data->reason = g_strdup (data);
+                                        reason_data->notification = notification;
+                                        reason_data->manager = manager;
+
+                                        reason_data->notification_close_id =
+                                                g_signal_connect (notification,
+                                                                  "closed",
+                                                                  G_CALLBACK (notification_closed_cb),
+                                                                  reason_data);
+
+                                        manager->active_notifications =
+                                                g_list_append (manager->active_notifications, reason_data);
+
+                                        notify_notification_show (notification, NULL);
+
+                                        g_free (first_row);
+                                        g_free (second_row);
+                                }
+                        }
+                        g_slist_free (added_reasons);
+                }
+
+                if (new_state_reasons)
+                        g_strfreev (new_state_reasons);
+
+                if (old_state_reasons)
+                        g_strfreev (old_state_reasons);
+        }
+
+
+        if (primary_text) {
+                NotifyNotification *notification;
+                notification = notify_notification_new (primary_text,
+                                                        secondary_text,
+                                                        "printer-symbolic");
+                notify_notification_set_app_name (notification, _("Printers"));
+                notify_notification_set_hint_string (notification, "desktop-entry", "gnome-printers-panel");
+                notify_notification_set_hint (notification, "transient", g_variant_new_boolean (TRUE));
+                notify_notification_show (notification, NULL);
+                g_object_unref (notification);
+                g_free (primary_text);
+                g_free (secondary_text);
+        }
+}
+
+static gboolean
+process_new_notifications (gpointer user_data)
+{
+        GsdPrintNotificationsManager  *manager = (GsdPrintNotificationsManager *) user_data;
+        ipp_attribute_t               *attr;
+        const gchar                   *notify_subscribed_event = NULL;
+        const gchar                   *printer_name = NULL;
+        const gchar                   *notify_text = NULL;
+        const gchar                   *notify_printer_uri = NULL;
+        gchar                         *job_state_reasons = NULL;
+        const gchar                   *job_name = NULL;
+        const char                    *attr_name;
+        gboolean                       printer_is_accepting_jobs = FALSE;
+        gchar                         *printer_state_reasons = NULL;
+        gchar                        **reasons;
+        guint                          notify_job_id = 0;
+        ipp_t                         *request;
+        ipp_t                         *response;
+        gint                           printer_state = -1;
+        gint                           job_state = -1;
+        gint                           job_impressions_completed = -1;
+        gint                           notify_sequence_number = -1;
+        gint                           i;
+
+        request = ippNewRequest (IPP_GET_NOTIFICATIONS);
+
+        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                      "requesting-user-name", NULL, cupsUser ());
+
+        ippAddInteger (request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                       "notify-subscription-ids", manager->subscription_id);
+
+        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
+                      "/printers/");
+
+        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL,
+                      "/jobs/");
+
+        ippAddInteger (request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                       "notify-sequence-numbers",
+                       manager->last_notify_sequence_number + 1);
+
+
+        response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+
+
+        for (attr = ippFindAttribute (response, "notify-sequence-number", IPP_TAG_INTEGER);
+             attr != NULL;
+             attr = ippNextAttribute (response)) {
+
+                attr_name = ippGetName (attr);
+                if (g_strcmp0 (attr_name, "notify-sequence-number") == 0) {
+                        notify_sequence_number = ippGetInteger (attr, 0);
+
+                        if (notify_sequence_number > manager->last_notify_sequence_number)
+                                manager->last_notify_sequence_number = notify_sequence_number;
+
+                        if (notify_subscribed_event != NULL) {
+                                process_cups_notification (manager,
+                                                           notify_subscribed_event,
+                                                           notify_text,
+                                                           notify_printer_uri,
+                                                           printer_name,
+                                                           printer_state,
+                                                           printer_state_reasons,
+                                                           printer_is_accepting_jobs,
+                                                           notify_job_id,
+                                                           job_state,
+                                                           job_state_reasons,
+                                                           job_name,
+                                                           job_impressions_completed);
+
+                                g_clear_pointer (&printer_state_reasons, g_free);
+                                g_clear_pointer (&job_state_reasons, g_free);
+                        }
+
+                        notify_subscribed_event = NULL;
+                        notify_text = NULL;
+                        notify_printer_uri = NULL;
+                        printer_name = NULL;
+                        printer_state = -1;
+                        printer_state_reasons = NULL;
+                        printer_is_accepting_jobs = FALSE;
+                        notify_job_id = 0;
+                        job_state = -1;
+                        job_state_reasons = NULL;
+                        job_name = NULL;
+                        job_impressions_completed = -1;
+                } else if (g_strcmp0 (attr_name, "notify-subscribed-event") == 0) {
+                        notify_subscribed_event = ippGetString (attr, 0, NULL);
+                } else if (g_strcmp0 (attr_name, "notify-text") == 0) {
+                        notify_text = ippGetString (attr, 0, NULL);
+                } else if (g_strcmp0 (attr_name, "notify-printer-uri") == 0) {
+                        notify_printer_uri = ippGetString (attr, 0, NULL);
+                } else if (g_strcmp0 (attr_name, "printer-name") == 0) {
+                        printer_name = ippGetString (attr, 0, NULL);
+                } else if (g_strcmp0 (attr_name, "printer-state") == 0) {
+                        printer_state = ippGetInteger (attr, 0);
+                } else if (g_strcmp0 (attr_name, "printer-state-reasons") == 0) {
+                        reasons = g_new0 (gchar *, ippGetCount (attr) + 1);
+                        for (i = 0; i < ippGetCount (attr); i++)
+                                reasons[i] = g_strdup (ippGetString (attr, i, NULL));
+                        printer_state_reasons = g_strjoinv (",", reasons);
+                        g_strfreev (reasons);
+                } else if (g_strcmp0 (attr_name, "printer-is-accepting-jobs") == 0) {
+                        printer_is_accepting_jobs = ippGetBoolean (attr, 0);
+                } else if (g_strcmp0 (attr_name, "notify-job-id") == 0) {
+                        notify_job_id = ippGetInteger (attr, 0);
+                } else if (g_strcmp0 (attr_name, "job-state") == 0) {
+                        job_state = ippGetInteger (attr, 0);
+                } else if (g_strcmp0 (attr_name, "job-state-reasons") == 0) {
+                        reasons = g_new0 (gchar *, ippGetCount (attr) + 1);
+                        for (i = 0; i < ippGetCount (attr); i++)
+                                reasons[i] = g_strdup (ippGetString (attr, i, NULL));
+                        job_state_reasons = g_strjoinv (",", reasons);
+                        g_strfreev (reasons);
+                } else if (g_strcmp0 (attr_name, "job-name") == 0) {
+                        job_name = ippGetString (attr, 0, NULL);
+                } else if (g_strcmp0 (attr_name, "job-impressions-completed") == 0) {
+                        job_impressions_completed = ippGetInteger (attr, 0);
+                }
+        }
+
+        if (notify_subscribed_event != NULL) {
+                process_cups_notification (manager,
+                                           notify_subscribed_event,
+                                           notify_text,
+                                           notify_printer_uri,
+                                           printer_name,
+                                           printer_state,
+                                           printer_state_reasons,
+                                           printer_is_accepting_jobs,
+                                           notify_job_id,
+                                           job_state,
+                                           job_state_reasons,
+                                           job_name,
+                                           job_impressions_completed);
+
+                g_clear_pointer (&printer_state_reasons, g_free);
+                g_clear_pointer (&job_state_reasons, g_free);
+        }
+
+        if (response != NULL)
+                ippDelete (response);
+
+        return TRUE;
+}
+
+static void
+scp_handler (GsdPrintNotificationsManager *manager,
+             gboolean                      start)
+{
+        if (start) {
+                GError *error = NULL;
+                char *args[2];
+
+                if (manager->scp_handler_spawned)
+                        return;
+
+                args[0] = LIBEXECDIR "/gsd-printer";
+                args[1] = NULL;
+
+                g_spawn_async (NULL, args, NULL,
+                               0, NULL, NULL,
+                               &manager->scp_handler_pid, &error);
+
+                manager->scp_handler_spawned = (error == NULL);
+
+                if (error) {
+                        g_warning ("Could not execute system-config-printer-udev handler: %s",
+                                   error->message);
+                        g_error_free (error);
+                }
+        } else if (manager->scp_handler_spawned) {
+                kill (manager->scp_handler_pid, SIGHUP);
+                g_spawn_close_pid (manager->scp_handler_pid);
+                manager->scp_handler_spawned = FALSE;
+        }
+}
+
+static void
+cancel_subscription (gint id)
+{
+        http_t *http;
+        ipp_t  *request;
+
+        if (id >= 0 &&
+            ((http = httpConnectEncrypt (cupsServer (), ippPort (),
+                                        cupsEncryption ())) != NULL)) {
+                request = ippNewRequest (IPP_CANCEL_SUBSCRIPTION);
+                ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                             "printer-uri", NULL, "/");
+                ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                             "requesting-user-name", NULL, cupsUser ());
+                ippAddInteger (request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                              "notify-subscription-id", id);
+                ippDelete (cupsDoRequest (http, request, "/"));
+                httpClose (http);
+        }
+}
+
+static gboolean
+renew_subscription (gpointer data)
+{
+        GsdPrintNotificationsManager *manager = (GsdPrintNotificationsManager *) data;
+        ipp_attribute_t              *attr = NULL;
+        http_t                       *http;
+        ipp_t                        *request;
+        ipp_t                        *response;
+        gint                          num_events = 7;
+        static const char * const events[] = {
+                "job-created",
+                "job-completed",
+                "job-state-changed",
+                "job-state",
+                "printer-added",
+                "printer-deleted",
+                "printer-state-changed"};
+
+        if ((http = httpConnectEncrypt (cupsServer (), ippPort (),
+                                        cupsEncryption ())) == NULL) {
+                g_debug ("Connection to CUPS server \'%s\' failed.", cupsServer ());
+        } else {
+                if (manager->subscription_id >= 0) {
+                        request = ippNewRequest (IPP_RENEW_SUBSCRIPTION);
+                        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                                     "printer-uri", NULL, "/");
+                        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                                     "requesting-user-name", NULL, cupsUser ());
+                        ippAddInteger (request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                                      "notify-subscription-id", manager->subscription_id);
+                        ippAddInteger (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
+                                      "notify-lease-duration", SUBSCRIPTION_DURATION);
+                        ippDelete (cupsDoRequest (http, request, "/"));
+                } else {
+                        request = ippNewRequest (IPP_CREATE_PRINTER_SUBSCRIPTION);
+                        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                                      "printer-uri", NULL,
+                                      "/");
+                        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                                      "requesting-user-name", NULL, cupsUser ());
+                        ippAddStrings (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
+                                       "notify-events", num_events, NULL, events);
+                        ippAddString (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
+                                      "notify-pull-method", NULL, "ippget");
+                        if (server_is_local (cupsServer ())) {
+                                ippAddString (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
+                                              "notify-recipient-uri", NULL, "dbus://");
+                        }
+                        ippAddInteger (request, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
+                                       "notify-lease-duration", SUBSCRIPTION_DURATION);
+                        response = cupsDoRequest (http, request, "/");
+
+                        if (response != NULL && ippGetStatusCode (response) <= IPP_OK_CONFLICT) {
+                                if ((attr = ippFindAttribute (response, "notify-subscription-id",
+                                                              IPP_TAG_INTEGER)) == NULL)
+                                        g_debug ("No notify-subscription-id in response!\n");
+                                else
+                                        manager->subscription_id = ippGetInteger (attr, 0);
+                        }
+
+                        if (response)
+                                ippDelete (response);
+                }
+                httpClose (http);
+        }
+        return TRUE;
+}
+
+static void
+renew_subscription_with_connection_test_cb (GObject      *source_object,
+                                            GAsyncResult *res,
+                                            gpointer      user_data)
+{
+        GSocketConnection *connection;
+        GError            *error = NULL;
+
+        connection = g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (source_object),
+                                                             res,
+                                                             &error);
+
+        if (connection) {
+                g_debug ("Test connection to CUPS server \'%s:%d\' succeeded.", cupsServer (), ippPort ());
+
+                g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
+                g_object_unref (connection);
+
+                renew_subscription (user_data);
+        } else {
+                g_debug ("Test connection to CUPS server \'%s:%d\' failed.", cupsServer (), ippPort ());
+        }
+}
+
+static gboolean
+renew_subscription_with_connection_test (gpointer user_data)
+{
+        GSocketClient *client;
+        gchar         *address;
+        int            port;
+
+        port = ippPort ();
+
+        address = g_strdup_printf ("%s:%d", cupsServer (), port);
+
+        if (address && address[0] != '/') {
+                client = g_socket_client_new ();
+
+                g_debug ("Initiating test connection to CUPS server \'%s:%d\'.", cupsServer (), port);
+
+                g_socket_client_connect_to_host_async (client,
+                                                       address,
+                                                       port,
+                                                       NULL,
+                                                       renew_subscription_with_connection_test_cb,
+                                                       user_data);
+
+                g_object_unref (client);
+        } else {
+                renew_subscription (user_data);
+        }
+
+        g_free (address);
+
+        return TRUE;
+}
+
+static void
+renew_subscription_timeout_enable (GsdPrintNotificationsManager *manager,
+                                   gboolean                      enable,
+                                   gboolean                      with_connection_test)
+{
+        if (manager->renew_source_id > 0)
+                g_source_remove (manager->renew_source_id);
+
+        if (enable) {
+                renew_subscription (manager);
+                if (with_connection_test) {
+                        manager->renew_source_id =
+                                g_timeout_add_seconds (RENEW_INTERVAL,
+                                                       renew_subscription_with_connection_test,
+                                                       manager);
+                        g_source_set_name_by_id (manager->renew_source_id, "[gnome-settings-daemon] renew_subscription_with_connection_test");
+                } else {
+                        manager->renew_source_id =
+                                g_timeout_add_seconds (RENEW_INTERVAL,
+                                                       renew_subscription,
+                                                       manager);
+                        g_source_set_name_by_id (manager->renew_source_id, "[gnome-settings-daemon] renew_subscription");
+                }
+        } else {
+                manager->renew_source_id = 0;
+        }
+}
+
+static void
+cups_connection_test_cb (GObject      *source_object,
+                         GAsyncResult *res,
+                         gpointer      user_data)
+{
+        GsdPrintNotificationsManager *manager = (GsdPrintNotificationsManager *) user_data;
+        GSocketConnection            *connection;
+        GError                       *error = NULL;
+
+        connection = g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (source_object),
+                                                             res,
+                                                             &error);
+
+        if (connection) {
+                g_debug ("Test connection to CUPS server \'%s:%d\' succeeded.", cupsServer (), ippPort ());
+
+                g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
+                g_object_unref (connection);
+
+                manager->num_dests = cupsGetDests (&manager->dests);
+                g_debug ("Got dests from remote CUPS server.");
+
+                renew_subscription_timeout_enable (manager, TRUE, TRUE);
+                manager->check_source_id = g_timeout_add_seconds (CHECK_INTERVAL, process_new_notifications, manager);
+                g_source_set_name_by_id (manager->check_source_id, "[gnome-settings-daemon] process_new_notifications");
+        } else {
+                g_debug ("Test connection to CUPS server \'%s:%d\' failed.", cupsServer (), ippPort ());
+                if (manager->cups_connection_timeout_id == 0) {
+                        manager->cups_connection_timeout_id =
+                                g_timeout_add_seconds (CUPS_CONNECTION_TEST_INTERVAL, cups_connection_test, manager);
+                        g_source_set_name_by_id (manager->cups_connection_timeout_id, "[gnome-settings-daemon] cups_connection_test");
+                }
+        }
+}
+
+static gboolean
+cups_connection_test (gpointer user_data)
+{
+        GsdPrintNotificationsManager *manager = (GsdPrintNotificationsManager *) user_data;
+        GSocketClient                *client;
+        gchar                        *address;
+        int                           port = ippPort ();
+
+        if (!manager->dests) {
+                address = g_strdup_printf ("%s:%d", cupsServer (), port);
+
+                client = g_socket_client_new ();
+
+                g_debug ("Initiating test connection to CUPS server \'%s:%d\'.", cupsServer (), port);
+
+                g_socket_client_connect_to_host_async (client,
+                                                       address,
+                                                       port,
+                                                       NULL,
+                                                       cups_connection_test_cb,
+                                                       manager);
+
+                g_object_unref (client);
+                g_free (address);
+        }
+
+        if (manager->dests) {
+                manager->cups_connection_timeout_id = 0;
+
+                return FALSE;
+        } else {
+                return TRUE;
+        }
+}
+
+static void
+gsd_print_notifications_manager_got_dbus_connection (GObject      *source_object,
+                                                     GAsyncResult *res,
+                                                     gpointer      user_data)
+{
+        GsdPrintNotificationsManager *manager = (GsdPrintNotificationsManager *) user_data;
+        GError                       *error = NULL;
+
+        manager->cups_bus_connection = g_bus_get_finish (res, &error);
+
+        if (manager->cups_bus_connection != NULL) {
+                manager->cups_dbus_subscription_id =
+                        g_dbus_connection_signal_subscribe (manager->cups_bus_connection,
+                                                            NULL,
+                                                            CUPS_DBUS_INTERFACE,
+                                                            NULL,
+                                                            CUPS_DBUS_PATH,
+                                                            NULL,
+                                                            0,
+                                                            on_cups_notification,
+                                                            manager,
+                                                            NULL);
+        } else {
+                g_warning ("Connection to message bus failed: %s", error->message);
+                g_error_free (error);
+        }
+}
+
+static gboolean
+gsd_print_notifications_manager_start_idle (gpointer data)
+{
+        GsdPrintNotificationsManager *manager = data;
+
+        gnome_settings_profile_start (NULL);
+
+        manager->printing_printers = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+
+        /*
+         * Set a password callback which cancels authentication
+         * before we prepare a correct solution (see bug #725440).
+         */
+        cupsSetPasswordCB2 (password_cb, NULL);
+
+        if (server_is_local (cupsServer ())) {
+                manager->num_dests = cupsGetDests (&manager->dests);
+                g_debug ("Got dests from local CUPS server.");
+
+                renew_subscription_timeout_enable (manager, TRUE, FALSE);
+
+                g_bus_get (G_BUS_TYPE_SYSTEM,
+                           NULL,
+                           gsd_print_notifications_manager_got_dbus_connection,
+                           data);
+        } else {
+                cups_connection_test (manager);
+        }
+
+        scp_handler (manager, TRUE);
+
+        gnome_settings_profile_end (NULL);
+
+        manager->start_idle_id = 0;
+        return G_SOURCE_REMOVE;
+}
+
+gboolean
+gsd_print_notifications_manager_start (GsdPrintNotificationsManager *manager,
+                                       GError                      **error)
+{
+        g_debug ("Starting print-notifications manager");
+
+        gnome_settings_profile_start (NULL);
+
+        manager->subscription_id = -1;
+        manager->dests = NULL;
+        manager->num_dests = 0;
+        manager->scp_handler_spawned = FALSE;
+        manager->timeouts = NULL;
+        manager->printing_printers = NULL;
+        manager->active_notifications = NULL;
+        manager->cups_bus_connection = NULL;
+        manager->cups_connection_timeout_id = 0;
+        manager->last_notify_sequence_number = -1;
+        manager->held_jobs = NULL;
+
+        manager->start_idle_id = g_idle_add (gsd_print_notifications_manager_start_idle, manager);
+        g_source_set_name_by_id (manager->start_idle_id, "[gnome-settings-daemon] gsd_print_notifications_manager_start_idle");
+
+        gnome_settings_profile_end (NULL);
+
+        return TRUE;
+}
+
+void
+gsd_print_notifications_manager_stop (GsdPrintNotificationsManager *manager)
+{
+        TimeoutData *data;
+        ReasonData  *reason_data;
+        HeldJob     *job;
+        GList       *tmp;
+
+        g_debug ("Stopping print-notifications manager");
+
+        cupsFreeDests (manager->num_dests, manager->dests);
+        manager->num_dests = 0;
+        manager->dests = NULL;
+
+        if (manager->cups_dbus_subscription_id > 0 &&
+            manager->cups_bus_connection != NULL) {
+                g_dbus_connection_signal_unsubscribe (manager->cups_bus_connection,
+                                                      manager->cups_dbus_subscription_id);
+                manager->cups_dbus_subscription_id = 0;
+        }
+
+        renew_subscription_timeout_enable (manager, FALSE, FALSE);
+
+        if (manager->check_source_id > 0) {
+                g_source_remove (manager->check_source_id);
+                manager->check_source_id = 0;
+        }
+
+        if (manager->subscription_id >= 0)
+                cancel_subscription (manager->subscription_id);
+
+        g_clear_pointer (&manager->printing_printers, g_hash_table_destroy);
+
+        g_clear_object (&manager->cups_bus_connection);
+
+        for (tmp = manager->timeouts; tmp; tmp = g_list_next (tmp)) {
+                data = (TimeoutData *) tmp->data;
+                if (data)
+                        g_source_remove (data->timeout_id);
+        }
+        g_list_free_full (manager->timeouts, free_timeout_data);
+
+        for (tmp = manager->active_notifications; tmp; tmp = g_list_next (tmp)) {
+                reason_data = (ReasonData *) tmp->data;
+                if (reason_data) {
+                        if (reason_data->notification_close_id > 0 &&
+                            g_signal_handler_is_connected (reason_data->notification,
+                                                           reason_data->notification_close_id)) {
+                                g_signal_handler_disconnect (reason_data->notification,
+                                                             reason_data->notification_close_id);
+                                reason_data->notification_close_id = 0;
+                        }
+
+                        notify_notification_close (reason_data->notification, NULL);
+                }
+        }
+        g_list_free_full (manager->active_notifications, free_reason_data);
+
+        for (tmp = manager->held_jobs; tmp; tmp = g_list_next (tmp)) {
+                job = (HeldJob *) tmp->data;
+                g_source_remove (job->timeout_id);
+        }
+        g_list_free_full (manager->held_jobs, free_held_job);
+
+        scp_handler (manager, FALSE);
+}
+
+static void
+gsd_print_notifications_manager_class_init (GsdPrintNotificationsManagerClass *klass)
+{
+        GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+
+        object_class->finalize = gsd_print_notifications_manager_finalize;
+
+        notify_init ("gnome-settings-daemon");
+}
+
+static void
+gsd_print_notifications_manager_init (GsdPrintNotificationsManager *manager)
+{
+}
+
+static void
+gsd_print_notifications_manager_finalize (GObject *object)
+{
+        GsdPrintNotificationsManager *manager;
+
+        g_return_if_fail (object != NULL);
+        g_return_if_fail (GSD_IS_PRINT_NOTIFICATIONS_MANAGER (object));
+
+        manager = GSD_PRINT_NOTIFICATIONS_MANAGER (object);
+
+        g_return_if_fail (manager != NULL);
+
+        gsd_print_notifications_manager_stop (manager);
+
+        if (manager->start_idle_id != 0)
+                g_source_remove (manager->start_idle_id);
+
+        G_OBJECT_CLASS (gsd_print_notifications_manager_parent_class)->finalize (object);
+}
+
+GsdPrintNotificationsManager *
+gsd_print_notifications_manager_new (void)
+{
+        if (manager_object != NULL) {
+                g_object_ref (manager_object);
+        } else {
+                manager_object = g_object_new (GSD_TYPE_PRINT_NOTIFICATIONS_MANAGER, NULL);
+                g_object_add_weak_pointer (manager_object,
+                                           (gpointer *) &manager_object);
+        }
+
+        return GSD_PRINT_NOTIFICATIONS_MANAGER (manager_object);
+}
diff --git a/plugins/print-notifications/gsd-print-notifications-manager.h b/plugins/print-notifications/gsd-print-notifications-manager.h
new file mode 100644
index 0000000..ec1dc72
--- /dev/null
+++ b/plugins/print-notifications/gsd-print-notifications-manager.h
@@ -0,0 +1,38 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2007 William Jon McCann <mccann@jhu.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __GSD_PRINT_NOTIFICATIONS_MANAGER_H
+#define __GSD_PRINT_NOTIFICATIONS_MANAGER_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define GSD_TYPE_PRINT_NOTIFICATIONS_MANAGER         (gsd_print_notifications_manager_get_type ())
+
+G_DECLARE_FINAL_TYPE (GsdPrintNotificationsManager, gsd_print_notifications_manager, GSD, PRINT_NOTIFICATIONS_MANAGER, GObject)
+
+GsdPrintNotificationsManager *gsd_print_notifications_manager_new      (void);
+gboolean                      gsd_print_notifications_manager_start    (GsdPrintNotificationsManager *manager,
+                                                                        GError                      **error);
+void                          gsd_print_notifications_manager_stop     (GsdPrintNotificationsManager *manager);
+
+G_END_DECLS
+
+#endif /* __GSD_PRINT_NOTIFICATIONS_MANAGER_H */
diff --git a/plugins/print-notifications/gsd-printer.c b/plugins/print-notifications/gsd-printer.c
new file mode 100644
index 0000000..573129b
--- /dev/null
+++ b/plugins/print-notifications/gsd-printer.c
@@ -0,0 +1,1403 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2011 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+#include <gio/gio.h>
+#include <stdlib.h>
+#include <libnotify/notify.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+static GDBusNodeInfo *npn_introspection_data = NULL;
+static GDBusNodeInfo *pdi_introspection_data = NULL;
+
+#define SCP_DBUS_NPN_NAME      "com.redhat.NewPrinterNotification"
+#define SCP_DBUS_NPN_PATH      "/com/redhat/NewPrinterNotification"
+#define SCP_DBUS_NPN_INTERFACE "com.redhat.NewPrinterNotification"
+
+#define SCP_DBUS_PDI_NAME      "com.redhat.PrinterDriversInstaller"
+#define SCP_DBUS_PDI_PATH      "/com/redhat/PrinterDriversInstaller"
+#define SCP_DBUS_PDI_INTERFACE "com.redhat.PrinterDriversInstaller"
+
+#define PACKAGE_KIT_BUS "org.freedesktop.PackageKit"
+#define PACKAGE_KIT_PATH "/org/freedesktop/PackageKit"
+#define PACKAGE_KIT_MODIFY_IFACE  "org.freedesktop.PackageKit.Modify"
+#define PACKAGE_KIT_QUERY_IFACE  "org.freedesktop.PackageKit.Query"
+
+#define SCP_BUS   "org.fedoraproject.Config.Printing"
+#define SCP_PATH  "/org/fedoraproject/Config/Printing"
+#define SCP_IFACE "org.fedoraproject.Config.Printing"
+
+#define MECHANISM_BUS "org.opensuse.CupsPkHelper.Mechanism"
+
+#define ALLOWED_CHARACTERS "abcdefghijklmnopqrtsuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
+
+#define DBUS_TIMEOUT           60000
+#define DBUS_INSTALL_TIMEOUT 3600000
+
+#define GNOME_SESSION_DBUS_NAME                 "org.gnome.SessionManager"
+#define GNOME_SESSION_DBUS_PATH                 "/org/gnome/SessionManager"
+#define GNOME_SESSION_DBUS_IFACE                "org.gnome.SessionManager"
+#define GNOME_SESSION_CLIENT_PRIVATE_DBUS_IFACE "org.gnome.SessionManager.ClientPrivate"
+
+#define GNOME_SESSION_PRESENCE_DBUS_PATH  "/org/gnome/SessionManager/Presence"
+#define GNOME_SESSION_PRESENCE_DBUS_IFACE "org.gnome.SessionManager.Presence"
+
+#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5)
+#define HAVE_CUPS_1_6 1
+#endif
+
+#ifndef HAVE_CUPS_1_6
+#define ippGetState(ipp) ipp->state
+#endif
+
+enum {
+  PRESENCE_STATUS_AVAILABLE = 0,
+  PRESENCE_STATUS_INVISIBLE,
+  PRESENCE_STATUS_BUSY,
+  PRESENCE_STATUS_IDLE,
+  PRESENCE_STATUS_UNKNOWN
+};
+
+static const gchar npn_introspection_xml[] =
+  "<node name='/com/redhat/NewPrinterNotification'>"
+  "  <interface name='com.redhat.NewPrinterNotification'>"
+  "    <method name='GetReady'>"
+  "    </method>"
+  "    <method name='NewPrinter'>"
+  "      <arg type='i' name='status' direction='in'/>"
+  "      <arg type='s' name='name' direction='in'/>"
+  "      <arg type='s' name='mfg' direction='in'/>"
+  "      <arg type='s' name='mdl' direction='in'/>"
+  "      <arg type='s' name='des' direction='in'/>"
+  "      <arg type='s' name='cmd' direction='in'/>"
+  "    </method>"
+  "  </interface>"
+  "</node>";
+
+static const gchar pdi_introspection_xml[] =
+  "<node name='/com/redhat/PrinterDriversInstaller'>"
+  "  <interface name='com.redhat.PrinterDriversInstaller'>"
+  "    <method name='InstallDrivers'>"
+  "      <arg type='s' name='mfg' direction='in'/>"
+  "      <arg type='s' name='mdl' direction='in'/>"
+  "      <arg type='s' name='cmd' direction='in'/>"
+  "    </method>"
+  "  </interface>"
+  "</node>";
+
+static GMainLoop *main_loop;
+static guint      npn_registration_id;
+static guint      pdi_registration_id;
+static guint      npn_owner_id;
+static guint      pdi_owner_id;
+
+static GHashTable *
+get_missing_executables (const gchar *ppd_file_name)
+{
+        GHashTable *executables = NULL;
+        GDBusProxy *proxy;
+        GVariant   *output;
+        GVariant   *array;
+        GError     *error = NULL;
+        gint        i;
+
+        if (!ppd_file_name)
+                return NULL;
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               SCP_BUS,
+                                               SCP_PATH,
+                                               SCP_IFACE,
+                                               NULL,
+                                               &error);
+
+        if (!proxy) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                return NULL;
+        }
+
+        output = g_dbus_proxy_call_sync (proxy,
+                                         "MissingExecutables",
+                                         g_variant_new ("(s)",
+                                                        ppd_file_name),
+                                         G_DBUS_CALL_FLAGS_NONE,
+                                         DBUS_TIMEOUT,
+                                         NULL,
+                                         &error);
+
+        if (output && g_variant_n_children (output) == 1) {
+                array = g_variant_get_child_value (output, 0);
+                if (array) {
+                        executables = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                                             g_free, NULL);
+                        for (i = 0; i < g_variant_n_children (array); i++) {
+                                g_hash_table_insert (executables,
+                                                     g_strdup (g_variant_get_string (
+                                                       g_variant_get_child_value (array, i),
+                                                       NULL)),
+                                                     NULL);
+                        }
+                }
+        }
+
+        if (output) {
+                g_variant_unref (output);
+        } else {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+        }
+
+        g_object_unref (proxy);
+
+        return executables;
+}
+
+static GHashTable *
+find_packages_for_executables (GHashTable *executables)
+{
+        GHashTableIter  exec_iter;
+        GHashTable     *packages = NULL;
+        GDBusProxy     *proxy;
+        GVariant       *output;
+        gpointer        key, value;
+        GError         *error = NULL;
+
+        if (!executables || g_hash_table_size (executables) <= 0)
+                return NULL;
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               PACKAGE_KIT_BUS,
+                                               PACKAGE_KIT_PATH,
+                                               PACKAGE_KIT_QUERY_IFACE,
+                                               NULL,
+                                               &error);
+
+        if (!proxy) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                return NULL;
+        }
+
+        packages = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                          g_free, NULL);
+
+        g_hash_table_iter_init (&exec_iter, executables);
+        while (g_hash_table_iter_next (&exec_iter, &key, &value)) {
+                output = g_dbus_proxy_call_sync (proxy,
+                                                 "SearchFile",
+                                                 g_variant_new ("(ss)",
+                                                                (gchar *) key,
+                                                                ""),
+                                                 G_DBUS_CALL_FLAGS_NONE,
+                                                 DBUS_TIMEOUT,
+                                                 NULL,
+                                                 &error);
+
+                if (output) {
+                        gboolean  installed;
+                        gchar    *package;
+
+                        g_variant_get (output,
+                                       "(bs)",
+                                       &installed,
+                                       &package);
+                        if (!installed)
+                                g_hash_table_insert (packages, g_strdup (package), NULL);
+
+                        g_variant_unref (output);
+                } else {
+                        g_warning ("%s", error->message);
+                        g_error_free (error);
+                }
+        }
+
+        g_object_unref (proxy);
+
+        return packages;
+}
+
+static void
+install_packages (GHashTable *packages)
+{
+        GVariantBuilder  array_builder;
+        GHashTableIter   pkg_iter;
+        GDBusProxy      *proxy;
+        GVariant        *output;
+        gpointer         key, value;
+        GError          *error = NULL;
+
+        if (!packages || g_hash_table_size (packages) <= 0)
+                return;
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               PACKAGE_KIT_BUS,
+                                               PACKAGE_KIT_PATH,
+                                               PACKAGE_KIT_MODIFY_IFACE,
+                                               NULL,
+                                               &error);
+
+        if (!proxy) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                return;
+        }
+
+        g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
+
+        g_hash_table_iter_init (&pkg_iter, packages);
+        while (g_hash_table_iter_next (&pkg_iter, &key, &value)) {
+                g_variant_builder_add (&array_builder,
+                                       "s",
+                                       (gchar *) key);
+        }
+
+        output = g_dbus_proxy_call_sync (proxy,
+                                         "InstallPackageNames",
+                                         g_variant_new ("(uass)",
+                                                        0,
+                                                        &array_builder,
+                                                        "hide-finished"),
+                                         G_DBUS_CALL_FLAGS_NONE,
+                                         DBUS_INSTALL_TIMEOUT,
+                                         NULL,
+                                         &error);
+
+        if (output) {
+                g_variant_unref (output);
+        } else {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+        }
+
+        g_object_unref (proxy);
+}
+
+static gchar *
+get_best_ppd (gchar *device_id,
+              gchar *device_make_and_model,
+              gchar *device_uri)
+{
+        GDBusProxy  *proxy;
+        GVariant    *output;
+        GVariant    *array;
+        GVariant    *tuple;
+        GError      *error = NULL;
+        gchar       *ppd_name = NULL;
+        gint         i, j;
+        static const char * const match_levels[] = {
+                   "exact-cmd",
+                   "exact",
+                   "close",
+                   "generic",
+                   "none"};
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               SCP_BUS,
+                                               SCP_PATH,
+                                               SCP_IFACE,
+                                               NULL,
+                                               &error);
+
+        if (!proxy) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                return NULL;
+        }
+
+        output = g_dbus_proxy_call_sync (proxy,
+                                         "GetBestDrivers",
+                                         g_variant_new ("(sss)",
+                                                 device_id ? device_id : "",
+                                                 device_make_and_model ? device_make_and_model : "",
+                                                 device_uri ? device_uri : ""),
+                                         G_DBUS_CALL_FLAGS_NONE,
+                                         DBUS_TIMEOUT,
+                                         NULL,
+                                         &error);
+
+        if (output && g_variant_n_children (output) >= 1) {
+                array = g_variant_get_child_value (output, 0);
+                if (array)
+                        for (j = 0; j < G_N_ELEMENTS (match_levels) && ppd_name == NULL; j++)
+                                for (i = 0; i < g_variant_n_children (array) && ppd_name == NULL; i++) {
+                                        tuple = g_variant_get_child_value (array, i);
+                                        if (tuple && g_variant_n_children (tuple) == 2) {
+                                                if (g_strcmp0 (g_variant_get_string (
+                                                                   g_variant_get_child_value (tuple, 1),
+                                                                   NULL), match_levels[j]) == 0)
+                                                        ppd_name = g_strdup (g_variant_get_string (
+                                                                                 g_variant_get_child_value (tuple, 0),
+                                                                                 NULL));
+                                        }
+                                }
+        }
+
+        if (output) {
+                g_variant_unref (output);
+        } else {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+        }
+
+        g_object_unref (proxy);
+
+        return ppd_name;
+}
+
+static gchar *
+get_tag_value (const gchar *tag_string,
+               const gchar *tag_name)
+{
+        gchar **tag_string_splitted;
+        gchar  *tag_value = NULL;
+        gint    tag_name_length;
+        gint    i;
+
+        if (!tag_string ||
+            !tag_name)
+                return NULL;
+
+        tag_name_length = strlen (tag_name);
+        tag_string_splitted = g_strsplit (tag_string, ";", 0);
+        if (tag_string_splitted) {
+                for (i = 0; i < g_strv_length (tag_string_splitted); i++)
+                        if (g_ascii_strncasecmp (tag_string_splitted[i], tag_name, tag_name_length) == 0)
+                                if (strlen (tag_string_splitted[i]) > tag_name_length + 1)
+                                        tag_value = g_strdup (tag_string_splitted[i] + tag_name_length + 1);
+
+                g_strfreev (tag_string_splitted);
+        }
+
+        return tag_value;
+}
+
+static gchar *
+create_name (gchar *device_id)
+{
+        cups_dest_t *dests;
+        gboolean     already_present = FALSE;
+        gchar       *name = NULL;
+        gchar       *new_name = NULL;
+        gint         num_dests;
+        gint         name_index = 2;
+        gint         j;
+
+        g_return_val_if_fail (device_id != NULL, NULL);
+
+        name = get_tag_value (device_id, "mdl");
+        if (!name)
+                name = get_tag_value (device_id, "model");
+
+        if (name)
+                name = g_strcanon (name, ALLOWED_CHARACTERS, '-');
+
+        num_dests = cupsGetDests (&dests);
+        do {
+                if (already_present) {
+                        new_name = g_strdup_printf ("%s-%d", name, name_index);
+                        name_index++;
+                } else {
+                        new_name = g_strdup (name);
+                }
+
+                already_present = FALSE;
+                for (j = 0; j < num_dests; j++)
+                        if (g_strcmp0 (dests[j].name, new_name) == 0)
+                                already_present = TRUE;
+
+                if (already_present) {
+                        g_free (new_name);
+                } else {
+                        g_free (name);
+                        name = new_name;
+                }
+        } while (already_present);
+        cupsFreeDests (num_dests, dests);
+
+        return name;
+}
+
+static gboolean
+add_printer (gchar *printer_name,
+             gchar *device_uri,
+             gchar *ppd_name,
+             gchar *info,
+             gchar *location)
+{
+        cups_dest_t *dests;
+        GDBusProxy  *proxy;
+        gboolean     success = FALSE;
+        GVariant    *output;
+        GError      *error = NULL;
+        gint         num_dests;
+        gint         i;
+
+        if (!printer_name || !device_uri || !ppd_name)
+                return FALSE;
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               MECHANISM_BUS,
+                                               "/",
+                                               MECHANISM_BUS,
+                                               NULL,
+                                               &error);
+
+        if (!proxy) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                return FALSE;
+        }
+
+        output = g_dbus_proxy_call_sync (proxy,
+                                         "PrinterAdd",
+                                         g_variant_new ("(sssss)",
+                                                        printer_name,
+                                                        device_uri,
+                                                        ppd_name,
+                                                        info ? info : "",
+                                                        location ? location : ""),
+                                         G_DBUS_CALL_FLAGS_NONE,
+                                         DBUS_TIMEOUT,
+                                         NULL,
+                                         &error);
+
+        if (output) {
+                g_variant_unref (output);
+        } else {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+        }
+
+        g_object_unref (proxy);
+
+        num_dests = cupsGetDests (&dests);
+        for (i = 0; i < num_dests; i++)
+                if (g_strcmp0 (dests[i].name, printer_name) == 0)
+                        success = TRUE;
+        cupsFreeDests (num_dests, dests);
+
+        return success;
+}
+
+static gboolean
+printer_set_enabled (const gchar *printer_name,
+                     gboolean     enabled)
+{
+        GDBusProxy *proxy;
+        gboolean    result = TRUE;
+        GVariant   *output;
+        GError     *error = NULL;
+
+        if (!printer_name)
+                return FALSE;
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               MECHANISM_BUS,
+                                               "/",
+                                               MECHANISM_BUS,
+                                               NULL,
+                                               &error);
+
+        if (!proxy) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                return FALSE;
+        }
+
+        output = g_dbus_proxy_call_sync (proxy,
+                                         "PrinterSetEnabled",
+                                         g_variant_new ("(sb)",
+                                                        printer_name,
+                                                        enabled),
+                                         G_DBUS_CALL_FLAGS_NONE,
+                                         DBUS_TIMEOUT,
+                                         NULL,
+                                         &error);
+
+        if (output) {
+                g_variant_unref (output);
+        } else {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                result = FALSE;
+        }
+
+        g_object_unref (proxy);
+
+        return result;
+}
+
+static gboolean
+printer_set_accepting_jobs (const gchar *printer_name,
+                            gboolean     accepting_jobs,
+                            const gchar *reason)
+{
+        GDBusProxy *proxy;
+        gboolean    result = TRUE;
+        GVariant   *output;
+        GError     *error = NULL;
+
+        if (!printer_name)
+                return FALSE;
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               MECHANISM_BUS,
+                                               "/",
+                                               MECHANISM_BUS,
+                                               NULL,
+                                               &error);
+
+        if (!proxy) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                return FALSE;
+        }
+
+        output = g_dbus_proxy_call_sync (proxy,
+                                         "PrinterSetAcceptJobs",
+                                         g_variant_new ("(sbs)",
+                                                        printer_name,
+                                                        accepting_jobs,
+                                                        reason ? reason : ""),
+                                         G_DBUS_CALL_FLAGS_NONE,
+                                         DBUS_TIMEOUT,
+                                         NULL,
+                                         &error);
+
+        if (output) {
+                g_variant_unref (output);
+        } else {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                result = FALSE;
+        }
+
+        g_object_unref (proxy);
+
+        return result;
+}
+
+static ipp_t *
+execute_maintenance_command (const char *printer_name,
+                             const char *command,
+                             const char *title)
+{
+        http_t *http;
+        GError *error = NULL;
+        ipp_t  *request = NULL;
+        ipp_t  *response = NULL;
+        gchar  *file_name = NULL;
+        char   *uri;
+        int     fd = -1;
+
+        http = httpConnectEncrypt (cupsServer (),
+                                   ippPort (),
+                                   cupsEncryption ());
+
+        if (!http)
+                return NULL;
+
+        request = ippNewRequest (IPP_PRINT_JOB);
+
+        uri = g_strdup_printf ("ipp://localhost/printers/%s",
+                               printer_name);
+
+        ippAddString (request,
+                      IPP_TAG_OPERATION,
+                      IPP_TAG_URI,
+                      "printer-uri",
+                      NULL,
+                      uri);
+
+        g_free (uri);
+
+        ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name",
+                      NULL, title);
+
+        ippAddString (request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format",
+                      NULL, "application/vnd.cups-command");
+
+        fd = g_file_open_tmp ("ccXXXXXX", &file_name, &error);
+
+        if (fd != -1) {
+                FILE *file;
+
+                file = fdopen (fd, "w");
+                fprintf (file, "#CUPS-COMMAND\n");
+                fprintf (file, "%s\n", command);
+                fclose (file);
+
+                response = cupsDoFileRequest (http, request, "/", file_name);
+                g_unlink (file_name);
+        } else {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+        }
+
+        g_free (file_name);
+        httpClose (http);
+
+        return response;
+}
+
+static char *
+get_dest_attr (const char *dest_name,
+               const char *attr)
+{
+        cups_dest_t *dests;
+        int          num_dests;
+        cups_dest_t *dest;
+        const char  *value;
+        char        *ret;
+
+        if (dest_name == NULL)
+                return NULL;
+
+        ret = NULL;
+
+        num_dests = cupsGetDests (&dests);
+        if (num_dests < 1) {
+                g_debug ("Unable to get printer destinations");
+                return NULL;
+        }
+
+        dest = cupsGetDest (dest_name, NULL, num_dests, dests);
+        if (dest == NULL) {
+                g_debug ("Unable to find a printer named '%s'", dest_name);
+                goto out;
+        }
+
+        value = cupsGetOption (attr, dest->num_options, dest->options);
+        if (value == NULL) {
+                g_debug ("Unable to get %s for '%s'", attr, dest_name);
+                goto out;
+        }
+        ret = g_strdup (value);
+out:
+        cupsFreeDests (num_dests, dests);
+
+        return ret;
+}
+
+static void
+printer_autoconfigure (gchar *printer_name)
+{
+        gchar *commands;
+        gchar *commands_lowercase;
+        ipp_t *response = NULL;
+
+        if (!printer_name)
+                return;
+
+        commands = get_dest_attr (printer_name, "printer-commands");
+        commands_lowercase = g_ascii_strdown (commands, -1);
+
+        if (g_strrstr (commands_lowercase, "autoconfigure")) {
+                response = execute_maintenance_command (printer_name,
+                                                        "AutoConfigure",
+                                                        ("Automatic configuration"));
+                if (response) {
+                        if (ippGetState (response) == IPP_ERROR)
+                                g_warning ("An error has occured during automatic configuration of new printer.");
+                        ippDelete (response);
+                }
+        }
+        g_free (commands);
+        g_free (commands_lowercase);
+}
+
+/* Returns default page size for current locale */
+static const gchar *
+get_page_size_from_locale (void)
+{
+  if (g_str_equal (gtk_paper_size_get_default (), GTK_PAPER_NAME_LETTER))
+    return "Letter";
+  else
+    return "A4";
+}
+
+static void
+set_default_paper_size (const gchar *printer_name,
+                        const gchar *ppd_file_name)
+{
+        GDBusProxy      *proxy;
+        GVariant        *output;
+        GError          *error = NULL;
+        GVariantBuilder *builder;
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               MECHANISM_BUS,
+                                               "/",
+                                               MECHANISM_BUS,
+                                               NULL,
+                                               &error);
+
+        if (!proxy) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                return;
+        }
+
+        /* Set default media size according to the locale
+         * FIXME: Handle more than A4 and Letter:
+         * https://bugzilla.gnome.org/show_bug.cgi?id=660769 */
+        builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+        g_variant_builder_add (builder, "s", get_page_size_from_locale ());
+
+        output = g_dbus_proxy_call_sync (proxy,
+                                         "PrinterAddOption",
+                                         g_variant_new ("(ssas)",
+                                                        printer_name ? printer_name : "",
+                                                        "PageSize",
+                                                        builder),
+                                         G_DBUS_CALL_FLAGS_NONE,
+                                         DBUS_TIMEOUT,
+                                         NULL,
+                                         &error);
+
+        if (output) {
+                g_variant_unref (output);
+        } else {
+                if (!(error->domain == G_DBUS_ERROR &&
+                      (error->code == G_DBUS_ERROR_SERVICE_UNKNOWN ||
+                       error->code == G_DBUS_ERROR_UNKNOWN_METHOD)))
+                        g_warning ("%s", error->message);
+                g_error_free (error);
+        }
+
+        g_object_unref (proxy);
+}
+
+/*
+ * Setup new printer and returns TRUE if successful.
+ */
+static gboolean
+setup_printer (gchar *device_id,
+               gchar *device_make_and_model,
+               gchar *device_uri)
+{
+        gboolean  success = FALSE;
+        gchar    *ppd_name;
+        gchar    *printer_name;
+
+        ppd_name = get_best_ppd (device_id, device_make_and_model, device_uri);
+        printer_name = create_name (device_id);
+
+        if (!ppd_name || !printer_name || !device_uri) {
+                g_free (ppd_name);
+                g_free (printer_name);
+                return FALSE;
+        }
+
+        success = add_printer (printer_name, device_uri,
+                               ppd_name, NULL, NULL);
+
+        /* Set some options of the new printer */
+        if (success) {
+                const char *ppd_file_name;
+
+                printer_set_accepting_jobs (printer_name, TRUE, NULL);
+                printer_set_enabled (printer_name, TRUE);
+                printer_autoconfigure (printer_name);
+
+                ppd_file_name = cupsGetPPD (printer_name);
+
+                if (ppd_file_name) {
+                        GHashTable *executables;
+                        GHashTable *packages;
+
+                        set_default_paper_size (printer_name, ppd_file_name);
+
+                        executables = get_missing_executables (ppd_file_name);
+                        packages = find_packages_for_executables (executables);
+                        install_packages (packages);
+
+                        if (executables)
+                                g_hash_table_destroy (executables);
+                        if (packages)
+                                g_hash_table_destroy (packages);
+                        g_unlink (ppd_file_name);
+                }
+        }
+
+        g_free (printer_name);
+        g_free (ppd_name);
+
+        return success;
+}
+
+static void
+handle_method_call (GDBusConnection       *connection,
+                    const gchar           *sender,
+                    const gchar           *object_path,
+                    const gchar           *interface_name,
+                    const gchar           *method_name,
+                    GVariant              *parameters,
+                    GDBusMethodInvocation *invocation,
+                    gpointer               user_data)
+{
+        gchar *primary_text = NULL;
+        gchar *secondary_text = NULL;
+        gchar *name = NULL;
+        gchar *mfg = NULL;
+        gchar *mdl = NULL;
+        gchar *des = NULL;
+        gchar *cmd = NULL;
+        gchar *device = NULL;
+        gchar *device_id;
+        gchar *make_and_model;
+        gint   status = 0;
+
+        if (g_strcmp0 (method_name, "GetReady") == 0) {
+                /* Translators: We are configuring new printer */
+                primary_text = g_strdup (_("Configuring new printer"));
+                /* Translators: Just wait */
+                secondary_text = g_strdup (_("Please wait…"));
+
+                g_dbus_method_invocation_return_value (invocation,
+                                                       NULL);
+        }
+        else if (g_strcmp0 (method_name, "NewPrinter") == 0) {
+                if (g_variant_n_children (parameters) == 6) {
+                        g_variant_get (parameters, "(i&s&s&s&s&s)",
+                               &status,
+                               &name,
+                               &mfg,
+                               &mdl,
+                               &des,
+                               &cmd);
+                }
+
+                if (g_strrstr (name, "/")) {
+                        /* name is a URI, no queue was generated, because no suitable
+                         * driver was found
+                         */
+
+                        device_id = g_strdup_printf ("MFG:%s;MDL:%s;DES:%s;CMD:%s;", mfg, mdl, des, cmd);
+                        make_and_model = g_strdup_printf ("%s %s", mfg, mdl);
+
+                        if (!setup_printer (device_id, make_and_model, name)) {
+
+                                /* Translators: We have no driver installed for this printer */
+                                primary_text = g_strdup (_("Missing printer driver"));
+
+                                if ((mfg && mdl) || des) {
+                                        if (mfg && mdl)
+                                                device = g_strdup_printf ("%s %s", mfg, mdl);
+                                        else
+                                                device = g_strdup (des);
+
+                                        /* Translators: We have no driver installed for the device */
+                                        secondary_text = g_strdup_printf (_("No printer driver for %s."), device);
+                                        g_free (device);
+                                }
+                                else
+                                        /* Translators: We have no driver installed for this printer */
+                                        secondary_text = g_strdup (_("No driver for this printer."));
+                        }
+
+                        g_free (make_and_model);
+                        g_free (device_id);
+                }
+                else {
+                        /* name is the name of the queue which hal_lpadmin has set up
+                         * automatically.
+                         */
+
+                        const char *ppd_file_name;
+
+                        ppd_file_name = cupsGetPPD (name);
+                        if (ppd_file_name) {
+                                GHashTable *executables;
+                                GHashTable *packages;
+
+                                executables = get_missing_executables (ppd_file_name);
+                                packages = find_packages_for_executables (executables);
+                                install_packages (packages);
+
+                                if (executables)
+                                        g_hash_table_destroy (executables);
+                                if (packages)
+                                        g_hash_table_destroy (packages);
+                                g_unlink (ppd_file_name);
+                        }
+                }
+
+                g_dbus_method_invocation_return_value (invocation,
+                                                       NULL);
+        }
+        else if (g_strcmp0 (method_name, "InstallDrivers") == 0) {
+                GDBusProxy *proxy;
+                GError     *error = NULL;
+
+                if (g_variant_n_children (parameters) == 3) {
+                        g_variant_get (parameters, "(&s&s&s)",
+                               &mfg,
+                               &mdl,
+                               &cmd);
+                }
+
+                if (mfg && mdl)
+                        device = g_strdup_printf ("MFG:%s;MDL:%s;", mfg, mdl);
+
+                proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                                       G_DBUS_PROXY_FLAGS_NONE,
+                                                       NULL,
+                                                       PACKAGE_KIT_BUS,
+                                                       PACKAGE_KIT_PATH,
+                                                       PACKAGE_KIT_MODIFY_IFACE,
+                                                       NULL,
+                                                       &error);
+
+                if (!proxy) {
+                        g_warning ("%s", error->message);
+                        g_error_free (error);
+                }
+
+                if (proxy && device) {
+                        GVariantBuilder *builder;
+                        GVariant        *output;
+
+                        builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+                        g_variant_builder_add (builder, "s", device);
+
+                        output = g_dbus_proxy_call_sync (proxy,
+                                                         "InstallPrinterDrivers",
+                                                         g_variant_new ("(uass)",
+                                                                        0,
+                                                                        builder,
+                                                                        "hide-finished"),
+                                                         G_DBUS_CALL_FLAGS_NONE,
+                                                         DBUS_INSTALL_TIMEOUT,
+                                                         NULL,
+                                                         &error);
+
+                        if (output) {
+                                g_variant_unref (output);
+                        } else {
+                                g_warning ("%s", error->message);
+                                g_error_free (error);
+                        }
+
+                        g_object_unref (proxy);
+                }
+
+                g_dbus_method_invocation_return_value (invocation,
+                                                       NULL);
+        }
+
+        if (primary_text) {
+                NotifyNotification *notification;
+                notification = notify_notification_new (primary_text,
+                                                        secondary_text,
+                                                        "printer-symbolic");
+                notify_notification_set_app_name (notification, _("Printers"));
+                notify_notification_set_hint_string (notification, "desktop-entry", "gnome-printers-panel");
+                notify_notification_set_hint (notification, "transient", g_variant_new_boolean (TRUE));
+
+                notify_notification_show (notification, NULL);
+                g_object_unref (notification);
+                g_free (primary_text);
+                g_free (secondary_text);
+        }
+}
+
+static const GDBusInterfaceVTable interface_vtable =
+{
+  handle_method_call,
+  NULL,
+  NULL
+};
+
+static void
+unregister_objects ()
+{
+        GDBusConnection *system_connection;
+        GError          *error = NULL;
+
+        system_connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+
+        if (npn_registration_id > 0) {
+                g_dbus_connection_unregister_object (system_connection, npn_registration_id);
+                npn_registration_id = 0;
+        }
+
+        if (pdi_registration_id > 0) {
+                g_dbus_connection_unregister_object (system_connection, pdi_registration_id);
+                pdi_registration_id = 0;
+        }
+}
+
+static void
+unown_names ()
+{
+        if (npn_owner_id > 0) {
+                g_bus_unown_name (npn_owner_id);
+                npn_owner_id = 0;
+        }
+
+        if (pdi_owner_id > 0) {
+                g_bus_unown_name (pdi_owner_id);
+                pdi_owner_id = 0;
+        }
+}
+
+static void
+on_npn_bus_acquired (GDBusConnection *connection,
+                     const gchar     *name,
+                     gpointer         user_data)
+{
+        GError *error = NULL;
+
+        npn_registration_id = g_dbus_connection_register_object (connection,
+                                                                 SCP_DBUS_NPN_PATH,
+                                                                 npn_introspection_data->interfaces[0],
+                                                                 &interface_vtable,
+                                                                 NULL,
+                                                                 NULL,
+                                                                 &error);
+
+        if (npn_registration_id == 0) {
+                g_warning ("Failed to register object: %s\n", error->message);
+                g_error_free (error);
+        }
+}
+
+static void
+on_pdi_bus_acquired (GDBusConnection *connection,
+                     const gchar     *name,
+                     gpointer         user_data)
+{
+        GError *error = NULL;
+
+        pdi_registration_id = g_dbus_connection_register_object (connection,
+                                                                 SCP_DBUS_PDI_PATH,
+                                                                 pdi_introspection_data->interfaces[0],
+                                                                 &interface_vtable,
+                                                                 NULL,
+                                                                 NULL,
+                                                                 &error);
+
+        if (pdi_registration_id == 0) {
+                g_warning ("Failed to register object: %s\n", error->message);
+                g_error_free (error);
+        }
+}
+
+static void
+on_name_acquired (GDBusConnection *connection,
+                  const gchar     *name,
+                  gpointer         user_data)
+{
+}
+
+static void
+on_name_lost (GDBusConnection *connection,
+              const gchar     *name,
+              gpointer         user_data)
+{
+        unregister_objects ();
+}
+
+static void
+session_signal_handler (GDBusConnection  *connection,
+                        const gchar      *sender_name,
+                        const gchar      *object_path,
+                        const gchar      *interface_name,
+                        const gchar      *signal_name,
+                        GVariant         *parameters,
+                        gpointer          user_data)
+{
+        guint            new_status;
+
+        g_variant_get (parameters, "(u)", &new_status);
+
+        if (new_status == PRESENCE_STATUS_IDLE ||
+            new_status == PRESENCE_STATUS_AVAILABLE) {
+                unregister_objects ();
+                unown_names ();
+
+                if (new_status == PRESENCE_STATUS_AVAILABLE) {
+                        npn_owner_id = g_bus_own_name (G_BUS_TYPE_SYSTEM,
+                                                       SCP_DBUS_NPN_NAME,
+                                                       G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
+                                                       G_BUS_NAME_OWNER_FLAGS_REPLACE,
+                                                       on_npn_bus_acquired,
+                                                       on_name_acquired,
+                                                       on_name_lost,
+                                                       NULL,
+                                                       NULL);
+
+                        pdi_owner_id = g_bus_own_name (G_BUS_TYPE_SYSTEM,
+                                                       SCP_DBUS_PDI_NAME,
+                                                       G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
+                                                       G_BUS_NAME_OWNER_FLAGS_REPLACE,
+                                                       on_pdi_bus_acquired,
+                                                       on_name_acquired,
+                                                       on_name_lost,
+                                                       NULL,
+                                                       NULL);
+                }
+        }
+}
+
+static void
+client_signal_handler (GDBusConnection  *connection,
+                       const gchar      *sender_name,
+                       const gchar      *object_path,
+                       const gchar      *interface_name,
+                       const gchar      *signal_name,
+                       GVariant         *parameters,
+                       gpointer          user_data)
+{
+        GDBusProxy *proxy;
+        GError     *error = NULL;
+        GVariant   *output;
+
+        if (g_strcmp0 (signal_name, "QueryEndSession") == 0 ||
+            g_strcmp0 (signal_name, "EndSession") == 0) {
+                proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                                       G_DBUS_PROXY_FLAGS_NONE,
+                                                       NULL,
+                                                       sender_name,
+                                                       object_path,
+                                                       interface_name,
+                                                       NULL,
+                                                       &error);
+
+                if (proxy) {
+                        output = g_dbus_proxy_call_sync (proxy,
+                                                         "EndSessionResponse",
+                                                         g_variant_new ("(bs)", TRUE, ""),
+                                                         G_DBUS_CALL_FLAGS_NONE,
+                                                         -1,
+                                                         NULL,
+                                                         &error);
+
+                        if (output) {
+                                g_variant_unref (output);
+                        }
+                        else {
+                                g_warning ("%s", error->message);
+                                g_error_free (error);
+                        }
+
+                        g_object_unref (proxy);
+                }
+                else {
+                        g_warning ("%s", error->message);
+                        g_error_free (error);
+                }
+
+                if (g_strcmp0 (signal_name, "EndSession") == 0) {
+                        g_main_loop_quit (main_loop);
+                        g_debug ("Exiting gsd-printer");
+                }
+        }
+}
+
+static gchar *
+register_gnome_session_client (const gchar *app_id,
+                               const gchar *client_startup_id)
+{
+        GDBusProxy  *proxy;
+        GVariant    *output = NULL;
+        GError      *error = NULL;
+        const gchar *client_id = NULL;
+        gchar       *result = NULL;
+
+        proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               NULL,
+                                               GNOME_SESSION_DBUS_NAME,
+                                               GNOME_SESSION_DBUS_PATH,
+                                               GNOME_SESSION_DBUS_IFACE,
+                                               NULL,
+                                               &error);
+
+        if (proxy) {
+                output = g_dbus_proxy_call_sync (proxy,
+                                                 "RegisterClient",
+                                                 g_variant_new ("(ss)", app_id, client_startup_id),
+                                                 G_DBUS_CALL_FLAGS_NONE,
+                                                 -1,
+                                                 NULL,
+                                                 &error);
+
+                if (output) {
+                        g_variant_get (output, "(o)", &client_id);
+                        if (client_id)
+                                result = g_strdup (client_id);
+                        g_variant_unref (output);
+                }
+                else {
+                        g_warning ("%s", error->message);
+                        g_error_free (error);
+                }
+
+                g_object_unref (proxy);
+        }
+        else {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+        }
+
+        return result;
+}
+
+int
+main (int argc, char *argv[])
+{
+  GDBusConnection *connection;
+  gboolean         client_signal_subscription_set = FALSE;
+  GError          *error = NULL;
+  guint            client_signal_subscription_id;
+  guint            session_signal_subscription_id;
+  gchar           *object_path;
+
+  bindtextdomain (GETTEXT_PACKAGE, GNOME_SETTINGS_LOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+  textdomain (GETTEXT_PACKAGE);
+  setlocale (LC_ALL, "");
+
+  npn_registration_id = 0;
+  pdi_registration_id = 0;
+  npn_owner_id = 0;
+  pdi_owner_id = 0;
+
+  notify_init ("gnome-settings-daemon-printer");
+
+  npn_introspection_data =
+          g_dbus_node_info_new_for_xml (npn_introspection_xml, &error);
+
+  if (npn_introspection_data == NULL) {
+          g_warning ("Error parsing introspection XML: %s\n", error->message);
+          g_error_free (error);
+          goto error;
+  }
+
+  pdi_introspection_data =
+          g_dbus_node_info_new_for_xml (pdi_introspection_xml, &error);
+
+  if (pdi_introspection_data == NULL) {
+          g_warning ("Error parsing introspection XML: %s\n", error->message);
+          g_error_free (error);
+          goto error;
+  }
+
+  connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+
+  session_signal_subscription_id =
+    g_dbus_connection_signal_subscribe (connection,
+                                        NULL,
+                                        GNOME_SESSION_PRESENCE_DBUS_IFACE,
+                                        "StatusChanged",
+                                        GNOME_SESSION_PRESENCE_DBUS_PATH,
+                                        NULL,
+                                        G_DBUS_SIGNAL_FLAGS_NONE,
+                                        session_signal_handler,
+                                        NULL,
+                                        NULL);
+
+  object_path = register_gnome_session_client ("gsd-printer", "");
+  if (object_path) {
+          client_signal_subscription_id =
+                  g_dbus_connection_signal_subscribe (connection,
+                                                      NULL,
+                                                      GNOME_SESSION_CLIENT_PRIVATE_DBUS_IFACE,
+                                                      NULL,
+                                                      object_path,
+                                                      NULL,
+                                                      G_DBUS_SIGNAL_FLAGS_NONE,
+                                                      client_signal_handler,
+                                                      NULL,
+                                                      NULL);
+          client_signal_subscription_set = TRUE;
+  }
+
+  if (npn_owner_id == 0)
+          npn_owner_id = g_bus_own_name (G_BUS_TYPE_SYSTEM,
+                                         SCP_DBUS_NPN_NAME,
+                                         G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
+                                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
+                                         on_npn_bus_acquired,
+                                         on_name_acquired,
+                                         on_name_lost,
+                                         NULL,
+                                         NULL);
+
+  if (pdi_owner_id == 0)
+          pdi_owner_id = g_bus_own_name (G_BUS_TYPE_SYSTEM,
+                                         SCP_DBUS_PDI_NAME,
+                                         G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
+                                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
+                                         on_pdi_bus_acquired,
+                                         on_name_acquired,
+                                         on_name_lost,
+                                         NULL,
+                                         NULL);
+
+  main_loop = g_main_loop_new (NULL, FALSE);
+  g_main_loop_run (main_loop);
+
+  unregister_objects ();
+  unown_names ();
+
+  if (client_signal_subscription_set)
+          g_dbus_connection_signal_unsubscribe (connection, client_signal_subscription_id);
+  g_dbus_connection_signal_unsubscribe (connection, session_signal_subscription_id);
+
+  g_free (object_path);
+
+  g_dbus_node_info_unref (npn_introspection_data);
+  g_dbus_node_info_unref (pdi_introspection_data);
+
+  return 0;
+
+error:
+
+  if (npn_introspection_data)
+          g_dbus_node_info_unref (npn_introspection_data);
+
+  if (pdi_introspection_data)
+          g_dbus_node_info_unref (pdi_introspection_data);
+
+  return 1;
+}
diff --git a/plugins/print-notifications/main.c b/plugins/print-notifications/main.c
new file mode 100644
index 0000000..a0dd406
--- /dev/null
+++ b/plugins/print-notifications/main.c
@@ -0,0 +1,7 @@
+#define NEW gsd_print_notifications_manager_new
+#define START gsd_print_notifications_manager_start
+#define STOP gsd_print_notifications_manager_stop
+#define MANAGER GsdPrintNotificationsManager
+#include "gsd-print-notifications-manager.h"
+
+#include "daemon-skeleton.h"
diff --git a/plugins/print-notifications/meson.build b/plugins/print-notifications/meson.build
new file mode 100644
index 0000000..1e1c614
--- /dev/null
+++ b/plugins/print-notifications/meson.build
@@ -0,0 +1,37 @@
+sources = files(
+  'gsd-print-notifications-manager.c',
+  'main.c'
+)
+
+deps = plugins_deps + [
+  cups_dep,
+  gtk_dep,
+  libnotify_dep
+]
+
+cflags += ['-DLIBEXECDIR="@0@"'.format(gsd_libexecdir)]
+cflags += ['-DBINDIR="@0@"'.format(gsd_bindir)]
+
+executable(
+  'gsd-' + plugin_name,
+  sources,
+  include_directories: [top_inc, common_inc],
+  dependencies: deps,
+  c_args: cflags,
+  install: true,
+  install_rpath: gsd_pkglibdir,
+  install_dir: gsd_libexecdir
+)
+
+program = 'gsd-printer'
+
+executable(
+  program,
+  program + '.c',
+  include_directories: top_inc,
+  dependencies: deps,
+  c_args: '-DGNOME_SETTINGS_LOCALEDIR="@0@"'.format(gsd_localedir),
+  install: true,
+  install_rpath: gsd_pkglibdir,
+  install_dir: gsd_libexecdir
+)