Adding upstream version 1:3.38.4.upstream/1%3.38.4upstream

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

1 files changed, 3643 insertions, 0 deletions

diff --git a/panels/printers/pp-utils.c b/panels/printers/pp-utils.c
new file mode 100644
index 0000000..127660f
--- /dev/null
+++ b/panels/printers/pp-utils.c
@@ -0,0 +1,3643 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright 2009-2010  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 <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+#include "pp-utils.h"
+
+#define DBUS_TIMEOUT      120000
+#define DBUS_TIMEOUT_LONG 600000
+
+#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5)
+#define HAVE_CUPS_1_6 1
+#endif
+
+#ifndef HAVE_CUPS_1_6
+#define ippGetCount(attr)     attr->num_values
+#define ippGetGroupTag(attr)  attr->group_tag
+#define ippGetValueTag(attr)  attr->value_tag
+#define ippGetName(attr)      attr->name
+#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 ippGetBoolean(attr, element) attr->values[element].boolean
+
+static int
+ippGetRange (ipp_attribute_t *attr,
+             int element,
+             int *upper)
+{
+  *upper = attr->values[element].range.upper;
+  return (attr->values[element].range.lower);
+}
+
+static ipp_attribute_t *
+ippFirstAttribute (ipp_t *ipp)
+{
+  if (!ipp)
+    return (NULL);
+  return (ipp->current = ipp->attrs);
+}
+
+static ipp_attribute_t *
+ippNextAttribute (ipp_t *ipp)
+{
+  if (!ipp || !ipp->current)
+    return (NULL);
+  return (ipp->current = ipp->current->next);
+}
+#endif
+
+#if (CUPS_VERSION_MAJOR == 1) && (CUPS_VERSION_MINOR <= 6)
+#define HTTP_URI_STATUS_OK HTTP_URI_OK
+#endif
+
+gchar *
+get_tag_value (const gchar *tag_string, const gchar *tag_name)
+{
+  gchar **tag_string_splitted = NULL;
+  gchar  *tag_value = NULL;
+  gint    tag_name_length;
+  gint    i;
+
+  if (tag_string && tag_name)
+    {
+      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;
+}
+
+
+/*
+ * Normalize given string so that it is lowercase, doesn't
+ * have trailing or leading whitespaces and digits doesn't
+ * neighbour with alphabetic.
+ * (see cupshelpers/ppds.py from system-config-printer)
+ */
+static gchar *
+normalize (const gchar *input_string)
+{
+  gchar *result = NULL;
+  gint   i, j = 0, k = -1;
+
+  if (input_string)
+    {
+      g_autofree gchar *tmp = g_strstrip (g_ascii_strdown (input_string, -1));
+      if (tmp)
+        {
+          g_autofree gchar *res = g_new (gchar, 2 * strlen (tmp));
+
+          for (i = 0; i < strlen (tmp); i++)
+            {
+              if ((g_ascii_isalpha (tmp[i]) && k >= 0 && g_ascii_isdigit (res[k])) ||
+                  (g_ascii_isdigit (tmp[i]) && k >= 0 && g_ascii_isalpha (res[k])))
+                {
+                  res[j] = ' ';
+                  k = j++;
+                  res[j] = tmp[i];
+                  k = j++;
+                }
+              else
+                {
+                  if (g_ascii_isspace (tmp[i]) || !g_ascii_isalnum (tmp[i]))
+                    {
+                      if (!(k >= 0 && res[k] == ' '))
+                        {
+                          res[j] = ' ';
+                          k = j++;
+                        }
+                    }
+                  else
+                    {
+                      res[j] = tmp[i];
+                      k = j++;
+                    }
+                }
+            }
+
+          res[j] = '\0';
+
+          result = g_strdup (res);
+        }
+    }
+
+  return result;
+}
+
+
+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;
+}
+
+gchar *
+get_ppd_attribute (const gchar *ppd_file_name,
+                   const gchar *attribute_name)
+{
+  ppd_file_t *ppd_file = NULL;
+  ppd_attr_t *ppd_attr = NULL;
+  gchar *result = NULL;
+
+  if (ppd_file_name)
+    {
+      ppd_file = ppdOpenFile (ppd_file_name);
+
+      if (ppd_file)
+        {
+          ppd_attr = ppdFindAttr (ppd_file, attribute_name, NULL);
+          if (ppd_attr != NULL)
+            result = g_strdup (ppd_attr->value);
+          ppdClose (ppd_file);
+        }
+    }
+
+  return result;
+}
+
+/*  Set default destination in ~/.cups/lpoptions.
+ *  Unset default destination if "dest" is NULL.
+ */
+void
+set_local_default_printer (const gchar *printer_name)
+{
+  cups_dest_t *dests = NULL;
+  int          num_dests = 0;
+  int          i;
+
+  num_dests = cupsGetDests (&dests);
+
+  for (i = 0; i < num_dests; i ++)
+    {
+      if (printer_name && g_strcmp0 (dests[i].name, printer_name) == 0)
+        dests[i].is_default = 1;
+      else
+        dests[i].is_default = 0;
+    }
+
+  cupsSetDests (num_dests, dests);
+}
+
+/*
+ * This function does something which should be provided by CUPS...
+ * It returns FALSE if the renaming fails.
+ */
+gboolean
+printer_rename (const gchar *old_name,
+                const gchar *new_name)
+{
+  ipp_attribute_t  *attr = NULL;
+  cups_ptype_t      printer_type = 0;
+  cups_dest_t      *dests = NULL;
+  cups_dest_t      *dest = NULL;
+  cups_job_t       *jobs = NULL;
+  g_autoptr(GDBusConnection) bus = NULL;
+  const gchar      *printer_location = NULL;
+  const gchar      *printer_info = NULL;
+  const gchar      *printer_uri = NULL;
+  const gchar      *device_uri = NULL;
+  const gchar      *job_sheets = NULL;
+  gboolean          result = FALSE;
+  gboolean          accepting = TRUE;
+  gboolean          printer_paused = FALSE;
+  gboolean          default_printer = FALSE;
+  gboolean          printer_shared = FALSE;
+  g_autoptr(GError) error = NULL;
+  http_t           *http;
+  g_autofree gchar *ppd_link = NULL;
+  g_autofree gchar *ppd_filename = NULL;
+  gchar           **sheets = NULL;
+  gchar           **users_allowed = NULL;
+  gchar           **users_denied = NULL;
+  gchar           **member_names = NULL;
+  const gchar      *start_sheet = NULL;
+  const gchar      *end_sheet = NULL;
+  g_autofree gchar *error_policy = NULL;
+  g_autofree gchar *op_policy = NULL;
+  ipp_t            *request;
+  ipp_t            *response;
+  gint              i;
+  int               num_dests = 0;
+  int               num_jobs = 0;
+  static const char * const requested_attrs[] = {
+    "printer-error-policy",
+    "printer-op-policy",
+    "requesting-user-name-allowed",
+    "requesting-user-name-denied",
+    "member-names"};
+
+  if (old_name == NULL ||
+      old_name[0] == '\0' ||
+      new_name == NULL ||
+      new_name[0] == '\0' ||
+      g_strcmp0 (old_name, new_name) == 0)
+    return FALSE;
+
+  num_dests = cupsGetDests (&dests);
+
+  dest = cupsGetDest (new_name, NULL, num_dests, dests);
+  if (dest)
+    {
+      cupsFreeDests (num_dests, dests);
+      return FALSE;
+    }
+
+  num_jobs = cupsGetJobs (&jobs, old_name, 0, CUPS_WHICHJOBS_ACTIVE);
+  cupsFreeJobs (num_jobs, jobs);
+  if (num_jobs > 1)
+    {
+      g_warning ("There are queued jobs on printer %s!", old_name);
+      cupsFreeDests (num_dests, dests);
+      return FALSE;
+    }
+
+  /*
+   * Gather some informations about the original printer
+   */
+  dest = cupsGetDest (old_name, NULL, num_dests, dests);
+  if (dest)
+    {
+      for (i = 0; i < dest->num_options; i++)
+        {
+          if (g_strcmp0 (dest->options[i].name, "printer-is-accepting-jobs") == 0)
+            accepting = g_strcmp0 (dest->options[i].value, "true") == 0;
+          else if (g_strcmp0 (dest->options[i].name, "printer-is-shared") == 0)
+            printer_shared = g_strcmp0 (dest->options[i].value, "true") == 0;
+          else if (g_strcmp0 (dest->options[i].name, "device-uri") == 0)
+            device_uri = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-uri-supported") == 0)
+            printer_uri = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-info") == 0)
+            printer_info = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-location") == 0)
+            printer_location = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-state") == 0)
+            printer_paused = g_strcmp0 (dest->options[i].value, "5") == 0;
+          else if (g_strcmp0 (dest->options[i].name, "job-sheets") == 0)
+            job_sheets = dest->options[i].value;
+          else if (g_strcmp0 (dest->options[i].name, "printer-type") == 0)
+            printer_type = atoi (dest->options[i].value);
+        }
+      default_printer = dest->is_default;
+    }
+  cupsFreeDests (num_dests, dests);
+
+  if (accepting)
+    {
+      printer_set_accepting_jobs (old_name, FALSE, NULL);
+
+      num_jobs = cupsGetJobs (&jobs, old_name, 0, CUPS_WHICHJOBS_ACTIVE);
+      cupsFreeJobs (num_jobs, jobs);
+      if (num_jobs > 1)
+        {
+          printer_set_accepting_jobs (old_name, accepting, NULL);
+          g_warning ("There are queued jobs on printer %s!", old_name);
+          return FALSE;
+        }
+    }
+
+
+  /*
+   * Gather additional informations about the original printer
+   */
+#ifdef HAVE_CUPS_HTTPCONNECT2
+  http = httpConnect2 (cupsServer (), ippPort (), NULL, AF_UNSPEC,
+                       cupsEncryption (), 1, 30000, NULL);
+#else
+  http = httpConnectEncrypt (cupsServer (), ippPort (), cupsEncryption ());
+#endif
+  if (http != NULL)
+    {
+      request = ippNewRequest (IPP_GET_PRINTER_ATTRIBUTES);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                    "printer-uri", NULL, printer_uri);
+      ippAddStrings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                     "requested-attributes", G_N_ELEMENTS (requested_attrs), NULL, requested_attrs);
+      response = cupsDoRequest (http, request, "/");
+
+      if (response)
+        {
+          if (ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+            {
+              attr = ippFindAttribute (response, "printer-error-policy", IPP_TAG_NAME);
+              if (attr)
+                error_policy = g_strdup (ippGetString (attr, 0, NULL));
+
+              attr = ippFindAttribute (response, "printer-op-policy", IPP_TAG_NAME);
+              if (attr)
+                op_policy = g_strdup (ippGetString (attr, 0, NULL));
+
+              attr = ippFindAttribute (response, "requesting-user-name-allowed", IPP_TAG_NAME);
+              if (attr && ippGetCount (attr) > 0)
+                {
+                  users_allowed = g_new0 (gchar *, ippGetCount (attr) + 1);
+                  for (i = 0; i < ippGetCount (attr); i++)
+                    users_allowed[i] = g_strdup (ippGetString (attr, i, NULL));
+                }
+
+              attr = ippFindAttribute (response, "requesting-user-name-denied", IPP_TAG_NAME);
+              if (attr && ippGetCount (attr) > 0)
+                {
+                  users_denied = g_new0 (gchar *, ippGetCount (attr) + 1);
+                  for (i = 0; i < ippGetCount (attr); i++)
+                    users_denied[i] = g_strdup (ippGetString (attr, i, NULL));
+                }
+
+              attr = ippFindAttribute (response, "member-names", IPP_TAG_NAME);
+              if (attr && ippGetCount (attr) > 0)
+                {
+                  member_names = g_new0 (gchar *, ippGetCount (attr) + 1);
+                  for (i = 0; i < ippGetCount (attr); i++)
+                    member_names[i] = g_strdup (ippGetString (attr, i, NULL));
+                }
+            }
+          ippDelete (response);
+        }
+      httpClose (http);
+    }
+
+  if (job_sheets)
+    {
+      sheets = g_strsplit (job_sheets, ",", 0);
+      if (g_strv_length (sheets) > 1)
+        {
+          start_sheet = sheets[0];
+          end_sheet = sheets[1];
+        }
+    }
+
+  ppd_link = g_strdup (cupsGetPPD (old_name));
+  if (ppd_link)
+    {
+      ppd_filename = g_file_read_link (ppd_link, NULL);
+
+      if (!ppd_filename)
+        ppd_filename = g_strdup (ppd_link);
+    }
+
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+   }
+  else
+    {
+      if (printer_type & CUPS_PRINTER_CLASS)
+        {
+          if (member_names)
+            for (i = 0; i < g_strv_length (member_names); i++)
+              class_add_printer (new_name, member_names[i]);
+        }
+      else
+        {
+          g_autoptr(GVariant) output = NULL;
+          g_autoptr(GError) add_error = NULL;
+
+          output = g_dbus_connection_call_sync (bus,
+                                                MECHANISM_BUS,
+                                                "/",
+                                                MECHANISM_BUS,
+                                                "PrinterAddWithPpdFile",
+                                                g_variant_new ("(sssss)",
+                                                               new_name,
+                                                               device_uri ? device_uri : "",
+                                                               ppd_filename ? ppd_filename : "",
+                                                               printer_info ? printer_info : "",
+                                                               printer_location ? printer_location : ""),
+                                                G_VARIANT_TYPE ("(s)"),
+                                                G_DBUS_CALL_FLAGS_NONE,
+                                                -1,
+                                                NULL,
+                                                &add_error);
+
+          if (output)
+            {
+              const gchar *ret_error;
+
+              g_variant_get (output, "(&s)", &ret_error);
+              if (ret_error[0] != '\0')
+                g_warning ("cups-pk-helper: rename of printer %s to %s failed: %s", old_name, new_name, ret_error);
+            }
+          else
+            {
+              g_warning ("%s", add_error->message);
+            }
+        }
+    }
+
+  if (ppd_link)
+    {
+      g_unlink (ppd_link);
+    }
+
+  num_dests = cupsGetDests (&dests);
+  dest = cupsGetDest (new_name, NULL, num_dests, dests);
+  if (dest)
+    {
+      printer_set_accepting_jobs (new_name, accepting, NULL);
+      printer_set_enabled (new_name, !printer_paused);
+      printer_set_shared (new_name, printer_shared);
+      printer_set_job_sheets (new_name, start_sheet, end_sheet);
+      printer_set_policy (new_name, op_policy, FALSE);
+      printer_set_policy (new_name, error_policy, TRUE);
+      printer_set_users (new_name, users_allowed, TRUE);
+      printer_set_users (new_name, users_denied, FALSE);
+      if (default_printer)
+        printer_set_default (new_name);
+
+      printer_delete (old_name);
+
+      result = TRUE;
+    }
+  else
+    printer_set_accepting_jobs (old_name, accepting, NULL);
+
+  cupsFreeDests (num_dests, dests);
+  if (sheets)
+    g_strfreev (sheets);
+  if (users_allowed)
+    g_strfreev (users_allowed);
+  if (users_denied)
+    g_strfreev (users_denied);
+
+  return result;
+}
+
+gboolean
+printer_set_location (const gchar *printer_name,
+                      const gchar *location)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name || !location)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetLocation",
+                                        g_variant_new ("(ss)", printer_name, location),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of location for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_accepting_jobs (const gchar *printer_name,
+                            gboolean     accepting_jobs,
+                            const gchar *reason)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetAcceptJobs",
+                                        g_variant_new ("(sbs)",
+                                                       printer_name,
+                                                       accepting_jobs,
+                                                       reason ? reason : ""),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of acceptance of jobs for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_enabled (const gchar *printer_name,
+                     gboolean     enabled)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetEnabled",
+                                        g_variant_new ("(sb)", printer_name, enabled),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of enablement of printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_delete (const gchar *printer_name)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterDelete",
+                                        g_variant_new ("(s)", printer_name),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: removing of printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_default (const gchar *printer_name)
+{
+  const char *cups_server;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  cups_server = cupsServer ();
+  if (g_ascii_strncasecmp (cups_server, "localhost", 9) == 0 ||
+      g_ascii_strncasecmp (cups_server, "127.0.0.1", 9) == 0 ||
+      g_ascii_strncasecmp (cups_server, "::1", 3) == 0 ||
+      cups_server[0] == '/')
+    {
+      g_autoptr(GDBusConnection) bus = NULL;
+      g_autoptr(GVariant) output = NULL;
+      const gchar *ret_error;
+
+      /* Clean .cups/lpoptions before setting
+       * default printer on local CUPS server.
+       */
+      set_local_default_printer (NULL);
+
+      bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+      if (!bus)
+        {
+          g_warning ("Failed to get system bus: %s", error->message);
+          return FALSE;
+        }
+
+      output = g_dbus_connection_call_sync (bus,
+                                            MECHANISM_BUS,
+                                            "/",
+                                            MECHANISM_BUS,
+                                            "PrinterSetDefault",
+                                            g_variant_new ("(s)", printer_name),
+                                            G_VARIANT_TYPE ("(s)"),
+                                            G_DBUS_CALL_FLAGS_NONE,
+                                            -1,
+                                            NULL,
+                                            &error);
+
+      if (output == NULL)
+        {
+          g_warning ("%s", error->message);
+          return FALSE;
+        }
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        {
+          g_warning ("cups-pk-helper: setting default printer to %s failed: %s", printer_name, ret_error);
+          return FALSE;
+        }
+
+      return TRUE;
+    }
+  else
+    /* Store default printer to .cups/lpoptions
+     * if we are connected to a remote CUPS server.
+     */
+    {
+      set_local_default_printer (printer_name);
+      return TRUE;
+    }
+}
+
+gboolean
+printer_set_shared (const gchar *printer_name,
+                    gboolean     shared)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetShared",
+                                        g_variant_new ("(sb)", printer_name, shared),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of sharing of printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_job_sheets (const gchar *printer_name,
+                        const gchar *start_sheet,
+                        const gchar *end_sheet)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name || !start_sheet || !end_sheet)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "PrinterSetJobSheets",
+                                        g_variant_new ("(sss)", printer_name, start_sheet, end_sheet),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of job sheets for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_policy (const gchar *printer_name,
+                    const gchar *policy,
+                    gboolean     error_policy)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!printer_name || !policy)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  if (error_policy)
+    output = g_dbus_connection_call_sync (bus,
+                                          MECHANISM_BUS,
+                                          "/",
+                                          MECHANISM_BUS,
+                                          "PrinterSetErrorPolicy",
+                                          g_variant_new ("(ss)", printer_name, policy),
+                                          G_VARIANT_TYPE ("(s)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          NULL,
+                                          &error);
+  else
+    output = g_dbus_connection_call_sync (bus,
+                                          MECHANISM_BUS,
+                                          "/",
+                                          MECHANISM_BUS,
+                                          "PrinterSetOpPolicy",
+                                          g_variant_new ("(ss)", printer_name, policy),
+                                          G_VARIANT_TYPE ("(s)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          NULL,
+                                          &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of a policy for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_set_users (const gchar  *printer_name,
+                   gchar       **users,
+                   gboolean      allowed)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  GVariantBuilder     array_builder;
+  gint                i;
+  g_autoptr(GVariant) output = NULL;
+  const gchar        *ret_error;
+  g_autoptr(GError)   error = NULL;
+
+  if (!printer_name || !users)
+    return TRUE;
+  
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
+  for (i = 0; users[i]; i++)
+    g_variant_builder_add (&array_builder, "s", users[i]);
+
+  if (allowed)
+    output = g_dbus_connection_call_sync (bus,
+                                          MECHANISM_BUS,
+                                          "/",
+                                          MECHANISM_BUS,
+                                          "PrinterSetUsersAllowed",
+                                          g_variant_new ("(sas)", printer_name, &array_builder),
+                                          G_VARIANT_TYPE ("(s)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          NULL,
+                                          &error);
+  else
+    output = g_dbus_connection_call_sync (bus,
+                                          MECHANISM_BUS,
+                                          "/",
+                                          MECHANISM_BUS,
+                                          "PrinterSetUsersDenied",
+                                          g_variant_new ("(sas)", printer_name, &array_builder),
+                                          G_VARIANT_TYPE ("(s)"),
+                                          G_DBUS_CALL_FLAGS_NONE,
+                                          -1,
+                                          NULL,
+                                          &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: setting of access list for printer %s failed: %s", printer_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+class_add_printer (const gchar *class_name,
+                   const gchar *printer_name)
+{
+  g_autoptr(GDBusConnection) bus = NULL;
+  g_autoptr(GVariant) output = NULL;
+  const gchar *ret_error;
+  g_autoptr(GError) error = NULL;
+
+  if (!class_name || !printer_name)
+    return TRUE;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     return TRUE;
+   }
+
+  output = g_dbus_connection_call_sync (bus,
+                                        MECHANISM_BUS,
+                                        "/",
+                                        MECHANISM_BUS,
+                                        "ClassAddPrinter",
+                                        g_variant_new ("(ss)", class_name, printer_name),
+                                        G_VARIANT_TYPE ("(s)"),
+                                        G_DBUS_CALL_FLAGS_NONE,
+                                        -1,
+                                        NULL,
+                                        &error);
+
+  if (output == NULL)
+    {
+      g_warning ("%s", error->message);
+      return FALSE;
+    }
+
+  g_variant_get (output, "(&s)", &ret_error);
+  if (ret_error[0] != '\0')
+    {
+      g_warning ("cups-pk-helper: adding of printer %s to class %s failed: %s", printer_name, class_name, ret_error);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+printer_is_local (cups_ptype_t  printer_type,
+                  const gchar  *device_uri)
+{
+  gboolean result = TRUE;
+  char     scheme[HTTP_MAX_URI];
+  char     username[HTTP_MAX_URI];
+  char     hostname[HTTP_MAX_URI];
+  char     resource[HTTP_MAX_URI];
+  int      port;
+
+  if (printer_type &
+      (CUPS_PRINTER_DISCOVERED |
+       CUPS_PRINTER_REMOTE |
+       CUPS_PRINTER_IMPLICIT))
+    result = FALSE;
+
+  if (device_uri == NULL || !result)
+    return result;
+
+  httpSeparateURI (HTTP_URI_CODING_ALL, device_uri,
+		   scheme, sizeof (scheme), 
+		   username, sizeof (username),
+		   hostname, sizeof (hostname),
+		   &port,
+		   resource, sizeof (resource));
+
+  if (g_str_equal (scheme, "ipp") ||
+      g_str_equal (scheme, "smb") ||
+      g_str_equal (scheme, "socket") ||
+      g_str_equal (scheme, "lpd"))
+    result = FALSE;
+
+  return result;
+}
+
+gchar*
+printer_get_hostname (cups_ptype_t  printer_type,
+                      const gchar  *device_uri,
+                      const gchar  *printer_uri)
+{
+  gboolean  local = TRUE;
+  gchar    *result = NULL;
+  char      scheme[HTTP_MAX_URI];
+  char      username[HTTP_MAX_URI];
+  char      hostname[HTTP_MAX_URI];
+  char      resource[HTTP_MAX_URI];
+  int       port;
+
+  if (device_uri == NULL)
+    return result;
+
+  if (printer_type & (CUPS_PRINTER_DISCOVERED |
+                      CUPS_PRINTER_REMOTE |
+                      CUPS_PRINTER_IMPLICIT))
+    {
+      if (printer_uri)
+        {
+          httpSeparateURI (HTTP_URI_CODING_ALL, printer_uri,
+                           scheme, sizeof (scheme),
+                           username, sizeof (username),
+                           hostname, sizeof (hostname),
+                           &port,
+                           resource, sizeof (resource));
+
+          if (hostname[0] != '\0')
+            result = g_strdup (hostname);
+        }
+
+      local = FALSE;
+    }
+
+  if (result == NULL && device_uri)
+    {
+      httpSeparateURI (HTTP_URI_CODING_ALL, device_uri,
+                       scheme, sizeof (scheme),
+                       username, sizeof (username),
+                       hostname, sizeof (hostname),
+                       &port,
+                       resource, sizeof (resource));
+
+      if (g_str_equal (scheme, "ipp") ||
+          g_str_equal (scheme, "smb") ||
+          g_str_equal (scheme, "socket") ||
+          g_str_equal (scheme, "lpd"))
+        {
+          if (hostname[0] != '\0')
+            result = g_strdup (hostname);
+
+          local = FALSE;
+        }
+    }
+
+  if (local)
+    result = g_strdup ("localhost");
+
+  return result;
+}
+
+/* Returns default page size for current locale */
+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";
+}
+
+typedef struct
+{
+  gchar        *printer_name;
+  gchar       **attributes_names;
+  GHashTable   *result;
+  GIACallback   callback;
+  gpointer      user_data;
+  GMainContext *context;
+} GIAData;
+
+static gboolean
+get_ipp_attributes_idle_cb (gpointer user_data)
+{
+  GIAData *data = (GIAData *) user_data;
+
+  data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+get_ipp_attributes_data_free (gpointer user_data)
+{
+  GIAData *data = (GIAData *) user_data;
+
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data->printer_name);
+  if (data->attributes_names)
+    g_strfreev (data->attributes_names);
+  g_free (data);
+}
+
+static void
+get_ipp_attributes_cb (gpointer user_data)
+{
+  GIAData *data = (GIAData *) user_data;
+  GSource *idle_source;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         get_ipp_attributes_idle_cb,
+                         data,
+                         get_ipp_attributes_data_free);
+  g_source_attach (idle_source, data->context);
+  g_source_unref (idle_source);
+}
+
+static void
+ipp_attribute_free2 (gpointer attr)
+{
+  IPPAttribute *attribute = (IPPAttribute *) attr;
+  ipp_attribute_free (attribute);
+}
+
+static gpointer
+get_ipp_attributes_func (gpointer user_data)
+{
+  ipp_attribute_t  *attr = NULL;
+  GIAData          *data = (GIAData *) user_data;
+  ipp_t            *request;
+  ipp_t            *response = NULL;
+  g_autofree gchar *printer_uri = NULL;
+  char            **requested_attrs = NULL;
+  gint              i, j, length = 0;
+
+  printer_uri = g_strdup_printf ("ipp://localhost/printers/%s", data->printer_name);
+
+  if (data->attributes_names)
+    {
+      length = g_strv_length (data->attributes_names);
+
+      requested_attrs = g_new0 (char *, length);
+      for (i = 0; data->attributes_names[i]; i++)
+        requested_attrs[i] = g_strdup (data->attributes_names[i]);
+
+      request = ippNewRequest (IPP_GET_PRINTER_ATTRIBUTES);
+      ippAddString (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                    "printer-uri", NULL, printer_uri);
+      ippAddStrings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                     "requested-attributes", length, NULL, (const char **) requested_attrs);
+      response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+    }
+
+  if (response)
+    {
+      if (ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+        {
+          for (j = 0; j < length; j++)
+            {
+              attr = ippFindAttribute (response, requested_attrs[j], IPP_TAG_ZERO);
+              if (attr && ippGetCount (attr) > 0 && ippGetValueTag (attr) != IPP_TAG_NOVALUE)
+                {
+                  IPPAttribute *attribute;
+
+                  attribute = g_new0 (IPPAttribute, 1);
+                  attribute->attribute_name = g_strdup (requested_attrs[j]);
+                  attribute->attribute_values = g_new0 (IPPAttributeValue, ippGetCount (attr));
+                  attribute->num_of_values = ippGetCount (attr);
+
+                  if (ippGetValueTag (attr) == IPP_TAG_INTEGER ||
+                      ippGetValueTag (attr) == IPP_TAG_ENUM)
+                    {
+                      attribute->attribute_type = IPP_ATTRIBUTE_TYPE_INTEGER;
+
+                      for (i = 0; i < ippGetCount (attr); i++)
+                        attribute->attribute_values[i].integer_value = ippGetInteger (attr, i);
+                    }
+                  else if (ippGetValueTag (attr) == IPP_TAG_NAME ||
+                           ippGetValueTag (attr) == IPP_TAG_STRING ||
+                           ippGetValueTag (attr) == IPP_TAG_TEXT ||
+                           ippGetValueTag (attr) == IPP_TAG_URI ||
+                           ippGetValueTag (attr) == IPP_TAG_KEYWORD ||
+                           ippGetValueTag (attr) == IPP_TAG_URISCHEME)
+                    {
+                      attribute->attribute_type = IPP_ATTRIBUTE_TYPE_STRING;
+
+                      for (i = 0; i < ippGetCount (attr); i++)
+                        attribute->attribute_values[i].string_value = g_strdup (ippGetString (attr, i, NULL));
+                    }
+                  else if (ippGetValueTag (attr) == IPP_TAG_RANGE)
+                    {
+                      attribute->attribute_type = IPP_ATTRIBUTE_TYPE_RANGE;
+
+                      for (i = 0; i < ippGetCount (attr); i++)
+                        {
+                          attribute->attribute_values[i].lower_range =
+                            ippGetRange (attr, i, &(attribute->attribute_values[i].upper_range));
+                        }
+                    }
+                  else if (ippGetValueTag (attr) == IPP_TAG_BOOLEAN)
+                    {
+                      attribute->attribute_type = IPP_ATTRIBUTE_TYPE_BOOLEAN;
+
+                      for (i = 0; i < ippGetCount (attr); i++)
+                        attribute->attribute_values[i].boolean_value = ippGetBoolean (attr, i);
+                    }
+
+                  if (!data->result)
+                    data->result = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, ipp_attribute_free2);
+
+                  g_hash_table_insert (data->result, g_strdup (requested_attrs[j]), attribute);
+                }
+            }
+        }
+
+      ippDelete (response);
+    }
+
+
+  for (i = 0; i < length; i++)
+    g_free (requested_attrs[i]);
+  g_free (requested_attrs);
+
+  get_ipp_attributes_cb (data);
+
+  return NULL;
+}
+
+void
+get_ipp_attributes_async (const gchar  *printer_name,
+                          gchar       **attributes_names,
+                          GIACallback   callback,
+                          gpointer      user_data)
+{
+  GIAData          *data;
+  GThread          *thread;
+  g_autoptr(GError) error = NULL;
+
+  data = g_new0 (GIAData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->attributes_names = g_strdupv (attributes_names);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  thread = g_thread_try_new ("get-ipp-attributes",
+                             get_ipp_attributes_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      get_ipp_attributes_data_free (data);
+    }
+  else
+    {
+      g_thread_unref (thread);
+    }
+}
+
+IPPAttribute *
+ipp_attribute_copy (IPPAttribute *attr)
+{
+  IPPAttribute *result = NULL;
+  gint          i;
+
+  if (attr)
+    {
+      result = g_new0 (IPPAttribute, 1);
+
+      *result = *attr;
+      result->attribute_name = g_strdup (attr->attribute_name);
+      result->attribute_values = g_new0 (IPPAttributeValue, attr->num_of_values);
+      for (i = 0; i < attr->num_of_values; i++)
+        {
+          result->attribute_values[i] = attr->attribute_values[i];
+          if (attr->attribute_values[i].string_value)
+            result->attribute_values[i].string_value = g_strdup (attr->attribute_values[i].string_value);
+        }
+    }
+
+  return result;
+}
+
+void
+ipp_attribute_free (IPPAttribute *attr)
+{
+  gint i;
+
+  if (attr)
+    {
+      for (i = 0; i < attr->num_of_values; i++)
+        g_free (attr->attribute_values[i].string_value);
+
+      g_free (attr->attribute_values);
+      g_free (attr->attribute_name);
+      g_free (attr);
+    }
+}
+
+
+
+typedef struct
+{
+  gchar        *printer_name;
+  gchar        *ppd_copy;
+  GCancellable *cancellable;
+  PSPCallback   callback;
+  gpointer      user_data;
+} PSPData;
+
+static void
+printer_set_ppd_async_dbus_cb (GObject      *source_object,
+                               GAsyncResult *res,
+                               gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  gboolean            result = FALSE;
+  PSPData            *data = (PSPData *) user_data;
+  g_autoptr(GError)   error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+  g_object_unref (source_object);
+
+  if (output)
+    {
+      const gchar *ret_error;
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        g_warning ("cups-pk-helper: setting of driver for printer %s failed: %s", data->printer_name, ret_error);
+      else
+        result = TRUE;
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  /* Don't call callback if cancelled */
+  if (!data->cancellable ||
+      !g_cancellable_is_cancelled (data->cancellable))
+    data->callback (data->printer_name,
+                    result,
+                    data->user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+
+  if (data->ppd_copy)
+    {
+      g_unlink (data->ppd_copy);
+      g_free (data->ppd_copy);
+    }
+
+  g_free (data->printer_name);
+  g_free (data);
+}
+
+/*
+ * Set ppd for given printer.
+ * Don't use this for classes, just for printers.
+ */
+void
+printer_set_ppd_async (const gchar  *printer_name,
+                       const gchar  *ppd_name,
+                       GCancellable *cancellable,
+                       PSPCallback   callback,
+                       gpointer      user_data)
+{
+  GDBusConnection  *bus;
+  PSPData          *data;
+  g_autoptr(GError) error = NULL;
+
+  data = g_new0 (PSPData, 1);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->printer_name = g_strdup (printer_name);
+
+  if (printer_name == NULL ||
+      printer_name[0] == '\0')
+    {
+      goto out;
+    }
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      goto out;
+    }
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "PrinterAdd",
+                          g_variant_new ("(sssss)",
+                                         printer_name,
+                                         "",
+                                         ppd_name,
+                                         "",
+                                         ""),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          -1,
+                          data->cancellable,
+                          printer_set_ppd_async_dbus_cb,
+                          data);
+
+  return;
+
+out:
+  callback (printer_name, FALSE, user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data->printer_name);
+  g_free (data);
+}
+
+static void
+printer_set_ppd_file_async_scb (GObject      *source_object,
+                                GAsyncResult *res,
+                                gpointer      user_data)
+{
+  GDBusConnection  *bus;
+  gboolean          success;
+  PSPData          *data = (PSPData *) user_data;
+  g_autoptr(GError) error = NULL;
+
+  success = g_file_copy_finish (G_FILE (source_object),
+                                res,
+                                &error);
+  g_object_unref (source_object);
+
+  if (!success)
+    {
+      g_warning ("%s", error->message);
+      goto out;
+    }
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      goto out;
+    }
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "PrinterAddWithPpdFile",
+                          g_variant_new ("(sssss)",
+                                         data->printer_name,
+                                         "",
+                                         data->ppd_copy,
+                                         "",
+                                         ""),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          -1,
+                          data->cancellable,
+                          printer_set_ppd_async_dbus_cb,
+                          data);
+
+  return;
+
+out:
+  data->callback (data->printer_name, FALSE, data->user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data->printer_name);
+  g_free (data->ppd_copy);
+  g_free (data);
+}
+
+/*
+ * Set ppd for given printer.
+ * Don't use this for classes, just for printers.
+ */
+void
+printer_set_ppd_file_async (const gchar  *printer_name,
+                            const gchar  *ppd_filename,
+                            GCancellable *cancellable,
+                            PSPCallback   callback,
+                            gpointer      user_data)
+{
+  GFileIOStream *stream;
+  PSPData       *data;
+  GFile         *source_ppd_file;
+  GFile         *destination_ppd_file;
+
+  data = g_new0 (PSPData, 1);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->printer_name = g_strdup (printer_name);
+
+  if (printer_name == NULL ||
+      printer_name[0] == '\0')
+    {
+      goto out;
+    }
+
+  /*
+   * We need to copy the PPD to temp directory at first.
+   * This is needed because of SELinux.
+   */
+  source_ppd_file = g_file_new_for_path (ppd_filename);
+  destination_ppd_file = g_file_new_tmp ("g-c-c-XXXXXX.ppd", &stream, NULL);
+  g_object_unref (stream);
+  data->ppd_copy = g_strdup (g_file_get_path (destination_ppd_file));
+
+  g_file_copy_async (source_ppd_file,
+                     destination_ppd_file,
+                     G_FILE_COPY_OVERWRITE,
+                     G_PRIORITY_DEFAULT,
+                     cancellable,
+                     NULL,
+                     NULL,
+                     printer_set_ppd_file_async_scb,
+                     data);
+
+  g_object_unref (destination_ppd_file);
+
+  return;
+
+out:
+  callback (printer_name, FALSE, user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data->printer_name);
+  g_free (data);
+}
+
+
+
+typedef void (*GPACallback) (gchar    **attribute_values,
+                             gpointer   user_data);
+
+typedef struct
+{
+  gchar         *attribute_name;
+  gchar        **ppds_names;
+  gchar        **result;
+  GPACallback    callback;
+  gpointer       user_data;
+  GMainContext  *context;
+} GPAData;
+
+static gboolean
+get_ppds_attribute_idle_cb (gpointer user_data)
+{
+  GPAData *data = (GPAData *) user_data;
+
+  data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+get_ppds_attribute_data_free (gpointer user_data)
+{
+  GPAData *data = (GPAData *) user_data;
+
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data->attribute_name);
+  g_strfreev (data->ppds_names);
+  g_free (data);
+}
+
+static void
+get_ppds_attribute_cb (gpointer user_data)
+{
+  GPAData *data = (GPAData *) user_data;
+  GSource *idle_source;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         get_ppds_attribute_idle_cb,
+                         data,
+                         get_ppds_attribute_data_free);
+  g_source_attach (idle_source, data->context);
+  g_source_unref (idle_source);
+}
+
+static gpointer
+get_ppds_attribute_func (gpointer user_data)
+{
+  ppd_file_t  *ppd_file;
+  ppd_attr_t  *ppd_attr;
+  GPAData     *data = (GPAData *) user_data;
+  gint         i;
+
+  data->result = g_new0 (gchar *, g_strv_length (data->ppds_names) + 1);
+  for (i = 0; data->ppds_names[i]; i++)
+    {
+      g_autofree gchar *ppd_filename = g_strdup (cupsGetServerPPD (CUPS_HTTP_DEFAULT, data->ppds_names[i]));
+      if (ppd_filename)
+        {
+          ppd_file = ppdOpenFile (ppd_filename);
+          if (ppd_file)
+            {
+              ppd_attr = ppdFindAttr (ppd_file, data->attribute_name, NULL);
+              if (ppd_attr != NULL)
+                data->result[i] = g_strdup (ppd_attr->value);
+
+              ppdClose (ppd_file);
+            }
+
+          g_unlink (ppd_filename);
+        }
+    }
+
+  get_ppds_attribute_cb (data);
+
+  return NULL;
+}
+
+/*
+ * Get values of requested PPD attribute for given PPDs.
+ */
+static void
+get_ppds_attribute_async (gchar       **ppds_names,
+                          gchar        *attribute_name,
+                          GPACallback   callback,
+                          gpointer      user_data)
+{
+  GPAData          *data;
+  GThread          *thread;
+  g_autoptr(GError) error = NULL;
+
+  if (!ppds_names || !attribute_name)
+    {
+      callback (NULL, user_data);
+      return;
+    }
+
+  data = g_new0 (GPAData, 1);
+  data->ppds_names = g_strdupv (ppds_names);
+  data->attribute_name = g_strdup (attribute_name);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  thread = g_thread_try_new ("get-ppds-attribute",
+                             get_ppds_attribute_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      get_ppds_attribute_data_free (data);
+    }
+  else
+    {
+      g_thread_unref (thread);
+    }
+}
+
+
+
+typedef void (*GDACallback) (gchar    *device_id,
+                             gchar    *device_make_and_model,
+                             gchar    *device_uri,
+                             gpointer  user_data);
+
+typedef struct
+{
+  gchar        *printer_name;
+  gchar        *device_uri;
+  GCancellable *cancellable;
+  GList        *backend_list;
+  GDACallback   callback;
+  gpointer      user_data;
+} GDAData;
+
+typedef struct
+{
+  gchar         *printer_name;
+  gint           count;
+  PPDName      **result;
+  GCancellable  *cancellable;
+  GPNCallback    callback;
+  gpointer       user_data;
+} GPNData;
+
+static void
+get_ppd_names_async_cb (gchar    **attribute_values,
+                        gpointer   user_data)
+{
+  GPNData *data = (GPNData *) user_data;
+  gint     i;
+
+  if (g_cancellable_is_cancelled (data->cancellable))
+    {
+      g_strfreev (attribute_values);
+
+      for (i = 0; data->result[i]; i++)
+        {
+          g_free (data->result[i]->ppd_name);
+          g_free (data->result[i]);
+        }
+
+      g_free (data->result);
+      data->result = NULL;
+
+      goto out;
+    }
+
+  if (attribute_values)
+    {
+      for (i = 0; attribute_values[i]; i++)
+        data->result[i]->ppd_display_name = attribute_values[i];
+
+      g_free (attribute_values);
+    }
+
+out:
+  data->callback (data->result,
+                  data->printer_name,
+                  g_cancellable_is_cancelled (data->cancellable),
+                  data->user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data->printer_name);
+  g_free (data);
+}
+
+static void
+get_ppd_names_async_dbus_scb (GObject      *source_object,
+                              GAsyncResult *res,
+                              gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  PPDName            *ppd_item;
+  PPDName           **result = NULL;
+  GPNData            *data = (GPNData *) user_data;
+  g_autoptr(GError)   error = NULL;
+  GList              *driver_list = NULL;
+  GList              *iter;
+  gint                i, j, n = 0;
+  static const char * const match_levels[] = {
+             "exact-cmd",
+             "exact",
+             "close",
+             "generic",
+             "none"};
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+  g_object_unref (source_object);
+
+  if (output)
+    {
+      g_autoptr(GVariant) array = NULL;
+
+      g_variant_get (output, "(@a(ss))",
+                     &array);
+
+      for (j = 0; j < G_N_ELEMENTS (match_levels) && n < data->count; j++)
+        {
+          g_autoptr(GVariantIter) iter = NULL;
+          const gchar *driver, *match;
+
+          g_variant_get (array,
+                         "a(ss)",
+                         &iter);
+
+          while (g_variant_iter_next (iter, "(&s&s)", &driver, &match))
+            {
+              if (g_str_equal (match, match_levels[j]) && n < data->count)
+                {
+                  ppd_item = g_new0 (PPDName, 1);
+                  ppd_item->ppd_name = g_strdup (driver);
+
+                  if (g_strcmp0 (match, "exact-cmd") == 0)
+                    ppd_item->ppd_match_level = PPD_EXACT_CMD_MATCH;
+                  else if (g_strcmp0 (match, "exact") == 0)
+                    ppd_item->ppd_match_level = PPD_EXACT_MATCH;
+                  else if (g_strcmp0 (match, "close") == 0)
+                    ppd_item->ppd_match_level = PPD_CLOSE_MATCH;
+                  else if (g_strcmp0 (match, "generic") == 0)
+                    ppd_item->ppd_match_level = PPD_GENERIC_MATCH;
+                  else if (g_strcmp0 (match, "none") == 0)
+                    ppd_item->ppd_match_level = PPD_NO_MATCH;
+
+                  driver_list = g_list_append (driver_list, ppd_item);
+
+                  n++;
+                }
+            }
+        }
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (n > 0)
+    {
+      result = g_new0 (PPDName *, n + 1);
+      i = 0;
+      for (iter = driver_list; iter; iter = iter->next)
+        {
+          result[i] = iter->data;
+          i++;
+        }
+    }
+
+  if (result)
+    {
+      gchar **ppds_names;
+
+      data->result = result;
+
+      ppds_names = g_new0 (gchar *, n + 1);
+      for (i = 0; i < n; i++)
+        ppds_names[i] = g_strdup (result[i]->ppd_name);
+
+      get_ppds_attribute_async (ppds_names,
+                                "NickName",
+                                get_ppd_names_async_cb,
+                                data);
+
+      g_strfreev (ppds_names);
+    }
+  else
+    {
+      data->callback (NULL,
+                      data->printer_name,
+                      g_cancellable_is_cancelled (data->cancellable),
+                      data->user_data);
+
+      if (data->cancellable)
+        g_object_unref (data->cancellable);
+      g_free (data->printer_name);
+      g_free (data);
+    }
+}
+
+static void
+get_device_attributes_cb (gchar    *device_id,
+                          gchar    *device_make_and_model,
+                          gchar    *device_uri,
+                          gpointer  user_data)
+{
+  GDBusConnection  *bus;
+  g_autoptr(GError) error = NULL;
+  GPNData          *data = (GPNData *) user_data;
+
+  if (g_cancellable_is_cancelled (data->cancellable))
+    goto out;
+
+  if (!device_id || !device_make_and_model || !device_uri)
+    goto out;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      goto out;
+    }
+
+  g_dbus_connection_call (bus,
+                          SCP_BUS,
+                          SCP_PATH,
+                          SCP_IFACE,
+                          "GetBestDrivers",
+                          g_variant_new ("(sss)",
+                                         device_id,
+                                         device_make_and_model,
+                                         device_uri),
+                          G_VARIANT_TYPE ("(a(ss))"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT_LONG,
+                          data->cancellable,
+                          get_ppd_names_async_dbus_scb,
+                          data);
+
+  return;
+
+out:
+  data->callback (NULL,
+                  data->printer_name,
+                  g_cancellable_is_cancelled (data->cancellable),
+                  data->user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data->printer_name);
+  g_free (data);
+}
+
+/*
+ * Special item for the list of backends. It represents
+ * backends not present in the list itself.
+ */
+#define OTHER_BACKENDS "other-backends"
+
+/*
+ * List of CUPS backends sorted according to their speed,
+ * the fastest is the first one. The last item represents
+ * backends not present in the list.
+ */
+const gchar *cups_backends[] = {
+  "usb",
+  "socket",
+  "serial",
+  "parallel",
+  "lpd",
+  "ipp",
+  "hp",
+  "dnssd",
+  "snmp",
+  "bluetooth",
+  "beh",
+  "ncp",
+  "hpfax",
+  OTHER_BACKENDS
+};
+
+static GList *
+create_backends_list ()
+{
+  GList *list = NULL;
+  gint   i;
+
+  for (i = 0; i < G_N_ELEMENTS (cups_backends); i++)
+    list = g_list_prepend (list, g_strdup (cups_backends[i]));
+  list = g_list_reverse (list);
+
+  return list;
+}
+
+static GVariantBuilder *
+create_other_backends_array ()
+{
+  GVariantBuilder *builder;
+  gint             i;
+
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+  for (i = 0; i < G_N_ELEMENTS (cups_backends) - 1; i++)
+    g_variant_builder_add (builder, "s", cups_backends[i]);
+
+  return builder;
+}
+
+static void
+get_device_attributes_async_dbus_cb (GObject      *source_object,
+                                     GAsyncResult *res,
+                                     gpointer      user_data)
+
+{
+  g_autoptr(GVariant) output = NULL;
+  GDAData            *data = (GDAData *) user_data;
+  g_autoptr(GError)   error = NULL;
+  GList              *tmp;
+  gchar              *device_id = NULL;
+  gchar              *device_make_and_model = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+  g_object_unref (source_object);
+
+  if (output)
+    {
+      const gchar *ret_error;
+      g_autoptr(GVariant) devices_variant = NULL;
+      gint index = -1;
+
+      g_variant_get (output, "(&s@a{ss})",
+                     &ret_error,
+                     &devices_variant);
+
+      if (ret_error[0] != '\0')
+        {
+          g_warning ("cups-pk-helper: getting of attributes for printer %s failed: %s", data->printer_name, ret_error);
+        }
+
+      if (data->device_uri)
+        {
+          g_autoptr(GVariantIter) iter = NULL;
+          const gchar *key, *value;
+          g_autofree gchar *suffix = NULL;
+
+          g_variant_get (devices_variant,
+                         "a{ss}",
+                         &iter);
+
+          while (g_variant_iter_next (iter, "{&s&s}", &key, &value))
+            {
+              if (g_str_equal (value, data->device_uri))
+                {
+                  gchar *number = g_strrstr (key, ":");
+                  if (number != NULL)
+                    {
+                      gchar *endptr;
+
+                      number++;
+                      index = g_ascii_strtoll (number, &endptr, 10);
+                      if (index == 0 && endptr == (number))
+                        index = -1;
+                    }
+                }
+            }
+
+          suffix = g_strdup_printf (":%d", index);
+
+          g_variant_get (devices_variant,
+                         "a{ss}",
+                         &iter);
+
+          while (g_variant_iter_next (iter, "{&s&s}", &key, &value))
+            {
+              if (g_str_has_suffix (key, suffix))
+                {
+                  if (g_str_has_prefix (key, "device-id"))
+                    {
+                      device_id = g_strdup (value);
+                    }
+
+                  if (g_str_has_prefix (key, "device-make-and-model"))
+                    {
+                      device_make_and_model = g_strdup (value);
+                    }
+                }
+            }
+        }
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (!device_id || !device_make_and_model)
+    {
+      GVariantBuilder *include_scheme_builder = NULL;
+      GVariantBuilder *exclude_scheme_builder = NULL;
+
+      g_free (device_id);
+      g_free (device_make_and_model);
+
+      device_id = NULL;
+      device_make_and_model = NULL;
+
+      if (data->backend_list && !g_cancellable_is_cancelled (data->cancellable))
+        {
+          const gchar *backend_name;
+
+          backend_name = data->backend_list->data;
+
+          if (g_strcmp0 (backend_name, OTHER_BACKENDS) != 0)
+            {
+              include_scheme_builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+              g_variant_builder_add (include_scheme_builder, "s", backend_name);
+            }
+          else
+            {
+              exclude_scheme_builder = create_other_backends_array ();
+            }
+
+          tmp = data->backend_list;
+          data->backend_list = g_list_remove_link (data->backend_list, tmp);
+          g_list_free_full (tmp, g_free);
+
+          g_dbus_connection_call (G_DBUS_CONNECTION (g_object_ref (source_object)),
+                                  MECHANISM_BUS,
+                                  "/",
+                                  MECHANISM_BUS,
+                                  "DevicesGet",
+                                  g_variant_new ("(iiasas)",
+                                                 0,
+                                                 0,
+                                                 include_scheme_builder,
+                                                 exclude_scheme_builder),
+                                  G_VARIANT_TYPE ("(sa{ss})"),
+                                  G_DBUS_CALL_FLAGS_NONE,
+                                  DBUS_TIMEOUT,
+                                  data->cancellable,
+                                  get_device_attributes_async_dbus_cb,
+                                  user_data);
+
+          if (include_scheme_builder)
+            g_variant_builder_unref (include_scheme_builder);
+
+          if (exclude_scheme_builder)
+            g_variant_builder_unref (exclude_scheme_builder);
+
+          return;
+        }
+    }
+
+  g_object_unref (source_object);
+
+  if (data->backend_list)
+    {
+      g_list_free_full (data->backend_list, g_free);
+      data->backend_list = NULL;
+    }
+
+  data->callback (device_id,
+                  device_make_and_model,
+                  data->device_uri,
+                  data->user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data->device_uri);
+  g_free (data->printer_name);
+  g_free (data);
+}
+
+static void
+get_device_attributes_async_scb (GHashTable *result,
+                                 gpointer    user_data)
+{
+  GDBusConnection  *bus;
+  GVariantBuilder   include_scheme_builder;
+  IPPAttribute     *attr;
+  GDAData          *data = (GDAData *) user_data;
+  g_autoptr(GError) error = NULL;
+  GList            *tmp;
+
+  if (result)
+    {
+      attr = g_hash_table_lookup (result, "device-uri");
+      if (attr && attr->attribute_type == IPP_ATTRIBUTE_TYPE_STRING &&
+          attr->num_of_values > 0)
+      data->device_uri = g_strdup (attr->attribute_values[0].string_value);
+      g_hash_table_unref (result);
+    }
+
+  if (g_cancellable_is_cancelled (data->cancellable))
+    goto out;
+
+  if (!data->device_uri)
+    goto out;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+    {
+      g_warning ("Failed to get system bus: %s", error->message);
+      goto out;
+    }
+
+  data->backend_list = create_backends_list ();
+
+  g_variant_builder_init (&include_scheme_builder, G_VARIANT_TYPE ("as"));
+  g_variant_builder_add (&include_scheme_builder, "s", data->backend_list->data);
+
+  tmp = data->backend_list;
+  data->backend_list = g_list_remove_link (data->backend_list, tmp);
+  g_list_free_full (tmp, g_free);
+
+  g_dbus_connection_call (g_object_ref (bus),
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "DevicesGet",
+                          g_variant_new ("(iiasas)",
+                                         0,
+                                         0,
+                                         &include_scheme_builder,
+                                         NULL),
+                          G_VARIANT_TYPE ("(sa{ss})"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT,
+                          data->cancellable,
+                          get_device_attributes_async_dbus_cb,
+                          data);
+
+  return;
+
+out:
+  data->callback (NULL, NULL, NULL, data->user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data->device_uri);
+  g_free (data->printer_name);
+  g_free (data);
+}
+
+/*
+ * Get device-id, device-make-and-model and device-uri for given printer.
+ */
+static void
+get_device_attributes_async (const gchar  *printer_name,
+                             GCancellable *cancellable,
+                             GDACallback   callback,
+                             gpointer      user_data)
+{
+  GDAData  *data;
+  gchar   **attributes;
+
+  if (!printer_name)
+   {
+     callback (NULL, NULL, NULL, user_data);
+     return;
+   }
+
+  data = g_new0 (GDAData, 1);
+  data->printer_name = g_strdup (printer_name);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+
+  attributes = g_new0 (gchar *, 2);
+  attributes[0] = g_strdup ("device-uri");
+
+  get_ipp_attributes_async (printer_name,
+                            attributes,
+                            get_device_attributes_async_scb,
+                            data);
+
+  g_strfreev (attributes);
+}
+
+/*
+ * Return "count" best matching driver names for given printer.
+ */
+void
+get_ppd_names_async (gchar        *printer_name,
+                     gint          count,
+                     GCancellable *cancellable,
+                     GPNCallback   callback,
+                     gpointer      user_data)
+{
+  GPNData *data;
+
+  if (!printer_name)
+    {
+      callback (NULL, NULL, TRUE, user_data);
+      return;
+    }
+
+  data = g_new0 (GPNData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->count = count;
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+
+  /*
+   * We have to find out device-id for this printer at first.
+   */
+  get_device_attributes_async (printer_name,
+                               cancellable,
+                               get_device_attributes_cb,
+                               data);
+}
+
+typedef struct
+{
+  PPDList      *result;
+  GCancellable *cancellable;
+  GAPCallback   callback;
+  gpointer      user_data;
+  GMainContext *context;
+} GAPData;
+
+static gboolean
+get_all_ppds_idle_cb (gpointer user_data)
+{
+  GAPData *data = (GAPData *) user_data;
+
+  /* Don't call callback if cancelled */
+  if (data->cancellable &&
+      g_cancellable_is_cancelled (data->cancellable))
+    {
+      ppd_list_free (data->result);
+      data->result = NULL;
+    }
+  else
+    {
+      data->callback (data->result, data->user_data);
+    }
+
+  return FALSE;
+}
+
+static void
+get_all_ppds_data_free (gpointer user_data)
+{
+  GAPData *data = (GAPData *) user_data;
+
+  if (data->context)
+    g_main_context_unref (data->context);
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data);
+}
+
+static void
+get_all_ppds_cb (gpointer user_data)
+{
+  GAPData *data = (GAPData *) user_data;
+  GSource *idle_source;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         get_all_ppds_idle_cb,
+                         data,
+                         get_all_ppds_data_free);
+  g_source_attach (idle_source, data->context);
+  g_source_unref (idle_source);
+}
+
+static const struct {
+  const char *normalized_name;
+  const char *display_name;
+} manufacturers_names[] = {
+  { "alps", "Alps" },
+  { "anitech", "Anitech" },
+  { "apple", "Apple" },
+  { "apollo", "Apollo" },
+  { "brother", "Brother" },
+  { "canon", "Canon" },
+  { "citizen", "Citizen" },
+  { "citoh", "Citoh" },
+  { "compaq", "Compaq" },
+  { "dec", "DEC" },
+  { "dell", "Dell" },
+  { "dnp", "DNP" },
+  { "dymo", "Dymo" },
+  { "epson", "Epson" },
+  { "fujifilm", "Fujifilm" },
+  { "fujitsu", "Fujitsu" },
+  { "gelsprinter", "Ricoh" },
+  { "generic", "Generic" },
+  { "genicom", "Genicom" },
+  { "gestetner", "Gestetner" },
+  { "hewlett packard", "Hewlett-Packard" },
+  { "heidelberg", "Heidelberg" },
+  { "hitachi", "Hitachi" },
+  { "hp", "Hewlett-Packard" },
+  { "ibm", "IBM" },
+  { "imagen", "Imagen" },
+  { "imagistics", "Imagistics" },
+  { "infoprint", "InfoPrint" },
+  { "infotec", "Infotec" },
+  { "intellitech", "Intellitech" },
+  { "kodak", "Kodak" },
+  { "konica minolta", "Minolta" },
+  { "kyocera", "Kyocera" },
+  { "kyocera mita", "Kyocera" },
+  { "lanier", "Lanier" },
+  { "lexmark international", "Lexmark" },
+  { "lexmark", "Lexmark" },
+  { "minolta", "Minolta" },
+  { "minolta qms", "Minolta" },
+  { "mitsubishi", "Mitsubishi" },
+  { "nec", "NEC" },
+  { "nrg", "NRG" },
+  { "oce", "Oce" },
+  { "oki", "Oki" },
+  { "oki data corp", "Oki" },
+  { "olivetti", "Olivetti" },
+  { "olympus", "Olympus" },
+  { "panasonic", "Panasonic" },
+  { "pcpi", "PCPI" },
+  { "pentax", "Pentax" },
+  { "qms", "QMS" },
+  { "raven", "Raven" },
+  { "raw", "Raw" },
+  { "ricoh", "Ricoh" },
+  { "samsung", "Samsung" },
+  { "savin", "Savin" },
+  { "seiko", "Seiko" },
+  { "sharp", "Sharp" },
+  { "shinko", "Shinko" },
+  { "sipix", "SiPix" },
+  { "sony", "Sony" },
+  { "star", "Star" },
+  { "tally", "Tally" },
+  { "tektronix", "Tektronix" },
+  { "texas instruments", "Texas Instruments" },
+  { "toshiba", "Toshiba" },
+  { "toshiba tec corp.", "Toshiba" },
+  { "xante", "Xante" },
+  { "xerox", "Xerox" },
+  { "zebra", "Zebra" },
+};
+
+static gpointer
+get_all_ppds_func (gpointer user_data)
+{
+  ipp_attribute_t *attr;
+  GHashTable      *ppds_hash = NULL;
+  GHashTable      *manufacturers_hash = NULL;
+  GAPData         *data = (GAPData *) user_data;
+  PPDName         *item;
+  ipp_t           *request;
+  ipp_t           *response;
+  GList           *list;
+  gchar           *manufacturer_display_name;
+  gint             i, j;
+
+  request = ippNewRequest (CUPS_GET_PPDS);
+  response = cupsDoRequest (CUPS_HTTP_DEFAULT, request, "/");
+
+  if (response &&
+      ippGetStatusCode (response) <= IPP_OK_CONFLICT)
+    {
+      /*
+       * This hash contains names of manufacturers as keys and
+       * values are GLists of PPD names.
+       */
+      ppds_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+
+      /*
+       * This hash contains all possible names of manufacturers as keys
+       * and values are just first occurrences of their equivalents.
+       * This is for mapping of e.g. "Hewlett Packard" and "HP" to the same name
+       * (the one which comes first).
+       */
+      manufacturers_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+
+      for (i = 0; i < G_N_ELEMENTS (manufacturers_names); i++)
+        {
+          g_hash_table_insert (manufacturers_hash,
+                               g_strdup (manufacturers_names[i].normalized_name),
+                               g_strdup (manufacturers_names[i].display_name));
+        }
+
+      for (attr = ippFirstAttribute (response); attr != NULL; attr = ippNextAttribute (response))
+        {
+          const gchar      *ppd_device_id = NULL;
+          const gchar      *ppd_make_and_model = NULL;
+          const gchar      *ppd_name = NULL;
+          const gchar      *ppd_product = NULL;
+          const gchar      *ppd_make = NULL;
+          g_autofree gchar *mdl = NULL;
+          g_autofree gchar *mfg = NULL;
+          g_autofree gchar *mfg_normalized = NULL;
+
+          while (attr != NULL && ippGetGroupTag (attr) != IPP_TAG_PRINTER)
+            attr = ippNextAttribute (response);
+
+          if (attr == NULL)
+            break;
+
+          while (attr != NULL && ippGetGroupTag (attr) == IPP_TAG_PRINTER)
+            {
+              if (g_strcmp0 (ippGetName (attr), "ppd-device-id") == 0 &&
+                  ippGetValueTag (attr) == IPP_TAG_TEXT)
+                ppd_device_id = ippGetString (attr, 0, NULL);
+              else if (g_strcmp0 (ippGetName (attr), "ppd-make-and-model") == 0 &&
+                       ippGetValueTag (attr) == IPP_TAG_TEXT)
+                ppd_make_and_model = ippGetString (attr, 0, NULL);
+              else if (g_strcmp0 (ippGetName (attr), "ppd-name") == 0 &&
+                       ippGetValueTag (attr) == IPP_TAG_NAME)
+                ppd_name = ippGetString (attr, 0, NULL);
+              else if (g_strcmp0 (ippGetName (attr), "ppd-product") == 0 &&
+                       ippGetValueTag (attr) == IPP_TAG_TEXT)
+                ppd_product = ippGetString (attr, 0, NULL);
+              else if (g_strcmp0 (ippGetName (attr), "ppd-make") == 0 &&
+                       ippGetValueTag (attr) == IPP_TAG_TEXT)
+                ppd_make = ippGetString (attr, 0, NULL);
+
+              attr = ippNextAttribute (response);
+            }
+
+          /* Get manufacturer's name */
+          if (ppd_device_id && ppd_device_id[0] != '\0')
+            {
+              mfg = get_tag_value (ppd_device_id, "mfg");
+              if (!mfg)
+                mfg = get_tag_value (ppd_device_id, "manufacturer");
+              mfg_normalized = normalize (mfg);
+            }
+
+          if (!mfg &&
+              ppd_make &&
+              ppd_make[0] != '\0')
+            {
+              mfg = g_strdup (ppd_make);
+              mfg_normalized = normalize (ppd_make);
+            }
+
+          /* Get model */
+          if (ppd_make_and_model &&
+              ppd_make_and_model[0] != '\0')
+            {
+              mdl = g_strdup (ppd_make_and_model);
+            }
+
+          if (!mdl &&
+              ppd_product &&
+              ppd_product[0] != '\0')
+            {
+              mdl = g_strdup (ppd_product);
+            }
+
+          if (!mdl &&
+              ppd_device_id &&
+              ppd_device_id[0] != '\0')
+            {
+              mdl = get_tag_value (ppd_device_id, "mdl");
+              if (!mdl)
+                mdl = get_tag_value (ppd_device_id, "model");
+            }
+
+          if (ppd_name && ppd_name[0] != '\0' &&
+              mdl && mdl[0] != '\0' &&
+              mfg && mfg[0] != '\0')
+            {
+              manufacturer_display_name = g_hash_table_lookup (manufacturers_hash, mfg_normalized);
+              if (!manufacturer_display_name)
+                {
+                  g_hash_table_insert (manufacturers_hash, g_strdup (mfg_normalized), g_strdup (mfg));
+                }
+              else
+                {
+                  g_free (mfg_normalized);
+                  mfg_normalized = normalize (manufacturer_display_name);
+                }
+
+              item = g_new0 (PPDName, 1);
+              item->ppd_name = g_strdup (ppd_name);
+              item->ppd_display_name = g_strdup (mdl);
+              item->ppd_match_level = -1;
+
+              list = g_hash_table_lookup (ppds_hash, mfg_normalized);
+              if (list)
+                {
+                  list = g_list_append (list, item);
+                }
+              else
+                {
+                  list = g_list_append (list, item);
+                  g_hash_table_insert (ppds_hash, g_strdup (mfg_normalized), list);
+                }
+            }
+
+          if (attr == NULL)
+            break;
+        }
+    }
+
+  if (response)
+    ippDelete(response);
+
+  if (ppds_hash &&
+      manufacturers_hash)
+    {
+      GHashTableIter  iter;
+      gpointer        key;
+      gpointer        value;
+      GList          *ppd_item;
+      GList          *sort_list = NULL;
+      GList          *list_iter;
+      gchar          *name;
+
+      data->result = g_new0 (PPDList, 1);
+      data->result->num_of_manufacturers = g_hash_table_size (ppds_hash);
+      data->result->manufacturers = g_new0 (PPDManufacturerItem *, data->result->num_of_manufacturers);
+
+      g_hash_table_iter_init (&iter, ppds_hash);
+      while (g_hash_table_iter_next (&iter, &key, &value))
+        {
+          sort_list = g_list_append (sort_list, g_strdup (key));
+        }
+
+      /* Sort list of manufacturers */
+      sort_list = g_list_sort (sort_list, (GCompareFunc) g_strcmp0);
+
+      /*
+       * Fill resulting list of lists (list of manufacturers where
+       * each item contains list of PPD names)
+       */
+      i = 0;
+      for (list_iter = sort_list; list_iter; list_iter = list_iter->next)
+        {
+          name = (gchar *) list_iter->data;
+          value = g_hash_table_lookup (ppds_hash, name);
+
+          data->result->manufacturers[i] = g_new0 (PPDManufacturerItem, 1);
+          data->result->manufacturers[i]->manufacturer_name = g_strdup (name);
+          data->result->manufacturers[i]->manufacturer_display_name = g_strdup (g_hash_table_lookup (manufacturers_hash, name));
+          data->result->manufacturers[i]->num_of_ppds = g_list_length ((GList *) value);
+          data->result->manufacturers[i]->ppds = g_new0 (PPDName *, data->result->manufacturers[i]->num_of_ppds);
+
+          for (ppd_item = (GList *) value, j = 0; ppd_item; ppd_item = ppd_item->next, j++)
+            {
+              data->result->manufacturers[i]->ppds[j] = ppd_item->data;
+            }
+
+          g_list_free ((GList *) value);
+
+          i++;
+        }
+
+      g_list_free_full (sort_list, g_free);
+      g_hash_table_destroy (ppds_hash);
+      g_hash_table_destroy (manufacturers_hash);
+    }
+
+  get_all_ppds_cb (data);
+
+  return NULL;
+}
+
+/*
+ * Get names of all installed PPDs sorted by manufacturers names.
+ */
+void
+get_all_ppds_async (GCancellable *cancellable,
+                    GAPCallback   callback,
+                    gpointer      user_data)
+{
+  GAPData          *data;
+  GThread          *thread;
+  g_autoptr(GError) error = NULL;
+
+  data = g_new0 (GAPData, 1);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  thread = g_thread_try_new ("get-all-ppds",
+                             get_all_ppds_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      get_all_ppds_data_free (data);
+    }
+  else
+    {
+      g_thread_unref (thread);
+    }
+}
+
+PPDList *
+ppd_list_copy (PPDList *list)
+{
+  PPDList *result = NULL;
+  gint     i, j;
+
+  if (list)
+    {
+      result = g_new0 (PPDList, 1);
+      result->num_of_manufacturers = list->num_of_manufacturers;
+      result->manufacturers = g_new0 (PPDManufacturerItem *, list->num_of_manufacturers);
+
+      for (i = 0; i < result->num_of_manufacturers; i++)
+        {
+          result->manufacturers[i] = g_new0 (PPDManufacturerItem, 1);
+          result->manufacturers[i]->num_of_ppds = list->manufacturers[i]->num_of_ppds;
+          result->manufacturers[i]->ppds = g_new0 (PPDName *, result->manufacturers[i]->num_of_ppds);
+
+          result->manufacturers[i]->manufacturer_display_name =
+            g_strdup (list->manufacturers[i]->manufacturer_display_name);
+
+          result->manufacturers[i]->manufacturer_name =
+            g_strdup (list->manufacturers[i]->manufacturer_name);
+
+          for (j = 0; j < result->manufacturers[i]->num_of_ppds; j++)
+            {
+              result->manufacturers[i]->ppds[j] = g_new0 (PPDName, 1);
+
+              result->manufacturers[i]->ppds[j]->ppd_display_name =
+                g_strdup (list->manufacturers[i]->ppds[j]->ppd_display_name);
+
+              result->manufacturers[i]->ppds[j]->ppd_name =
+                g_strdup (list->manufacturers[i]->ppds[j]->ppd_name);
+
+              result->manufacturers[i]->ppds[j]->ppd_match_level =
+                list->manufacturers[i]->ppds[j]->ppd_match_level;
+            }
+        }
+    }
+
+  return result;
+}
+
+void
+ppd_list_free (PPDList *list)
+{
+  gint i, j;
+
+  if (list)
+    {
+      for (i = 0; i < list->num_of_manufacturers; i++)
+        {
+          for (j = 0; j < list->manufacturers[i]->num_of_ppds; j++)
+            {
+              g_free (list->manufacturers[i]->ppds[j]->ppd_name);
+              g_free (list->manufacturers[i]->ppds[j]->ppd_display_name);
+              g_free (list->manufacturers[i]->ppds[j]);
+            }
+
+          g_free (list->manufacturers[i]->manufacturer_name);
+          g_free (list->manufacturers[i]->manufacturer_display_name);
+          g_free (list->manufacturers[i]->ppds);
+          g_free (list->manufacturers[i]);
+        }
+
+      g_free (list->manufacturers);
+      g_free (list);
+    }
+}
+
+gchar *
+get_standard_manufacturers_name (const gchar *name)
+{
+  g_autofree gchar *normalized_name = NULL;
+  gint   i;
+
+  if (name == NULL)
+    return NULL;
+
+  normalized_name = normalize (name);
+
+  for (i = 0; i < G_N_ELEMENTS (manufacturers_names); i++)
+    {
+      if (g_strcmp0 (manufacturers_names[i].normalized_name, normalized_name) == 0)
+        {
+          return g_strdup (manufacturers_names[i].display_name);
+        }
+    }
+
+  return NULL;
+}
+
+typedef struct
+{
+  gchar        *printer_name;
+  gchar        *host_name;
+  gint          port;
+  gchar        *result;
+  PGPCallback   callback;
+  gpointer      user_data;
+  GMainContext *context;
+} PGPData;
+
+static gboolean
+printer_get_ppd_idle_cb (gpointer user_data)
+{
+  PGPData *data = (PGPData *) user_data;
+
+  data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+printer_get_ppd_data_free (gpointer user_data)
+{
+  PGPData *data = (PGPData *) user_data;
+
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data->result);
+  g_free (data->printer_name);
+  g_free (data->host_name);
+  g_free (data);
+}
+
+static void
+printer_get_ppd_cb (gpointer user_data)
+{
+  PGPData *data = (PGPData *) user_data;
+  GSource *idle_source;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         printer_get_ppd_idle_cb,
+                         data,
+                         printer_get_ppd_data_free);
+  g_source_attach (idle_source, data->context);
+  g_source_unref (idle_source);
+}
+
+static gpointer
+printer_get_ppd_func (gpointer user_data)
+{
+  PGPData *data = (PGPData *) user_data;
+
+  if (data->host_name)
+    {
+      http_t *http;
+
+#ifdef HAVE_CUPS_HTTPCONNECT2
+      http = httpConnect2 (data->host_name, data->port, NULL, AF_UNSPEC,
+                           HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL);
+#else
+      http = httpConnect (data->host_name, data->port);
+#endif
+      if (http)
+        {
+          data->result = g_strdup (cupsGetPPD2 (http, data->printer_name));
+          httpClose (http);
+        }
+    }
+  else
+    {
+      data->result = g_strdup (cupsGetPPD (data->printer_name));
+    }
+
+  printer_get_ppd_cb (data);
+
+  return NULL;
+}
+
+void
+printer_get_ppd_async (const gchar *printer_name,
+                       const gchar *host_name,
+                       gint         port,
+                       PGPCallback  callback,
+                       gpointer     user_data)
+{
+  PGPData          *data;
+  GThread          *thread;
+  g_autoptr(GError) error = NULL;
+
+  data = g_new0 (PGPData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->host_name = g_strdup (host_name);
+  data->port = port;
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  thread = g_thread_try_new ("printer-get-ppd",
+                             printer_get_ppd_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      printer_get_ppd_data_free (data);
+    }
+  else
+    {
+      g_thread_unref (thread);
+    }
+}
+
+typedef struct
+{
+  gchar        *printer_name;
+  cups_dest_t  *result;
+  GNDCallback   callback;
+  gpointer      user_data;
+  GMainContext *context;
+} GNDData;
+
+static gboolean
+get_named_dest_idle_cb (gpointer user_data)
+{
+  GNDData *data = (GNDData *) user_data;
+
+  data->callback (data->result, data->user_data);
+
+  return FALSE;
+}
+
+static void
+get_named_dest_data_free (gpointer user_data)
+{
+  GNDData *data = (GNDData *) user_data;
+
+  if (data->context)
+    g_main_context_unref (data->context);
+  g_free (data->printer_name);
+  g_free (data);
+}
+
+static void
+get_named_dest_cb (gpointer user_data)
+{
+  GNDData *data = (GNDData *) user_data;
+  GSource *idle_source;
+
+  idle_source = g_idle_source_new ();
+  g_source_set_callback (idle_source,
+                         get_named_dest_idle_cb,
+                         data,
+                         get_named_dest_data_free);
+  g_source_attach (idle_source, data->context);
+  g_source_unref (idle_source);
+}
+
+static gpointer
+get_named_dest_func (gpointer user_data)
+{
+  GNDData *data = (GNDData *) user_data;
+
+  data->result = cupsGetNamedDest (CUPS_HTTP_DEFAULT, data->printer_name, NULL);
+
+  get_named_dest_cb (data);
+
+  return NULL;
+}
+
+void
+get_named_dest_async (const gchar *printer_name,
+                      GNDCallback  callback,
+                      gpointer     user_data)
+{
+  GNDData          *data;
+  GThread          *thread;
+  g_autoptr(GError) error = NULL;
+
+  data = g_new0 (GNDData, 1);
+  data->printer_name = g_strdup (printer_name);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->context = g_main_context_ref_thread_default ();
+
+  thread = g_thread_try_new ("get-named-dest",
+                             get_named_dest_func,
+                             data,
+                             &error);
+
+  if (!thread)
+    {
+      g_warning ("%s", error->message);
+      callback (NULL, user_data);
+
+      get_named_dest_data_free (data);
+    }
+  else
+    {
+      g_thread_unref (thread);
+    }
+}
+
+typedef struct
+{
+  GCancellable *cancellable;
+  PAOCallback   callback;
+  gpointer      user_data;
+} PAOData;
+
+static void
+printer_add_option_async_dbus_cb (GObject      *source_object,
+                                  GAsyncResult *res,
+                                  gpointer      user_data)
+{
+  g_autoptr(GVariant) output = NULL;
+  gboolean            success = FALSE;
+  PAOData            *data = (PAOData *) user_data;
+  g_autoptr(GError)   error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+  g_object_unref (source_object);
+
+  if (output)
+    {
+      const gchar *ret_error;
+
+      g_variant_get (output, "(&s)", &ret_error);
+      if (ret_error[0] != '\0')
+        g_warning ("cups-pk-helper: setting of an option failed: %s", ret_error);
+      else
+        success = TRUE;
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+    }
+
+  if (!g_cancellable_is_cancelled (data->cancellable))
+    data->callback (success, data->user_data);
+
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data);
+}
+
+void
+printer_add_option_async (const gchar   *printer_name,
+                          const gchar   *option_name,
+                          gchar        **values,
+                          gboolean       set_default,
+                          GCancellable  *cancellable,
+                          PAOCallback    callback,
+                          gpointer       user_data)
+{
+  GVariantBuilder   array_builder;
+  GDBusConnection  *bus;
+  PAOData          *data;
+  g_autoptr(GError) error = NULL;
+  gint              i;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     callback (FALSE, user_data);
+     return;
+   }
+
+  g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
+  if (values)
+    {
+      for (i = 0; values[i]; i++)
+        g_variant_builder_add (&array_builder, "s", values[i]);
+    }
+
+  data = g_new0 (PAOData, 1);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          set_default ? "PrinterAddOptionDefault" :
+                                        "PrinterAddOption",
+                          g_variant_new ("(ssas)",
+                                         printer_name,
+                                         option_name,
+                                         &array_builder),
+                          G_VARIANT_TYPE ("(s)"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT,
+                          cancellable,
+                          printer_add_option_async_dbus_cb,
+                          data);
+}
+
+typedef struct
+{
+  GCancellable *cancellable;
+  GCDCallback   callback;
+  gpointer      user_data;
+  GList        *backend_list;
+} GCDData;
+
+static gint
+get_suffix_index (const gchar *string)
+{
+  gchar *number;
+  gchar *endptr;
+  gint   index = -1;
+
+  number = g_strrstr (string, ":");
+  if (number)
+    {
+      number++;
+      index = g_ascii_strtoll (number, &endptr, 10);
+      if (index == 0 && endptr == number)
+        index = -1;
+    }
+
+  return index;
+}
+
+static void
+get_cups_devices_async_dbus_cb (GObject      *source_object,
+                                GAsyncResult *res,
+                                gpointer      user_data)
+
+{
+  g_autoptr(GPtrArray) devices = NULL;
+  g_autoptr(GVariant) output = NULL;
+  GCDData            *data = (GCDData *) user_data;
+  g_autoptr(GError)   error = NULL;
+  gint                num_of_devices = 0;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
+                                          res,
+                                          &error);
+
+  if (output)
+    {
+      const gchar *ret_error;
+      g_autoptr(GVariant) devices_variant = NULL;
+      gboolean     is_network_device;
+      g_autoptr(GVariantIter) iter = NULL;
+      const gchar  *key, *value;
+      gint          index = -1, max_index = -1, i;
+
+      g_variant_get (output, "(&s@a{ss})",
+                     &ret_error,
+                     &devices_variant);
+
+      if (ret_error[0] != '\0')
+        {
+          g_warning ("cups-pk-helper: getting of CUPS devices failed: %s", ret_error);
+        }
+
+      g_variant_get (devices_variant, "a{ss}", &iter);
+      while (g_variant_iter_next (iter, "{&s&s}", &key, &value))
+        {
+          index = get_suffix_index (key);
+          if (index > max_index)
+            max_index = index;
+        }
+
+      if (max_index >= 0)
+        {
+          g_autoptr(GVariantIter) iter2 = NULL;
+
+          num_of_devices = max_index + 1;
+          devices = g_ptr_array_new_with_free_func (g_object_unref);
+          for (i = 0; i < num_of_devices; i++)
+             g_ptr_array_add (devices, pp_print_device_new ());
+
+          g_variant_get (devices_variant, "a{ss}", &iter2);
+          while (g_variant_iter_next (iter2, "{&s&s}", &key, &value))
+            {
+              PpPrintDevice *device;
+
+              index = get_suffix_index (key);
+              if (index >= 0)
+                {
+                  device = g_ptr_array_index (devices, index);
+                  if (g_str_has_prefix (key, "device-class"))
+                    {
+                      is_network_device = g_strcmp0 (value, "network") == 0;
+                      g_object_set (device, "is-network-device", is_network_device, NULL);
+                    }
+                  else if (g_str_has_prefix (key, "device-id"))
+                    g_object_set (device, "device-id", value, NULL);
+                  else if (g_str_has_prefix (key, "device-info"))
+                    g_object_set (device, "device-info", value, NULL);
+                  else if (g_str_has_prefix (key, "device-make-and-model"))
+                    {
+                      g_object_set (device,
+                                    "device-make-and-model", value,
+                                    "device-name", value,
+                                    NULL);
+                    }
+                  else if (g_str_has_prefix (key, "device-uri"))
+                    g_object_set (device, "device-uri", value, NULL);
+                  else if (g_str_has_prefix (key, "device-location"))
+                    g_object_set (device, "device-location", value, NULL);
+
+                  g_object_set (device, "acquisition-method", ACQUISITION_METHOD_DEFAULT_CUPS_SERVER, NULL);
+                }
+            }
+        }
+    }
+  else
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("%s", error->message);
+
+      data->callback (devices,
+                      TRUE,
+                      g_cancellable_is_cancelled (data->cancellable),
+                      data->user_data);
+
+      g_list_free_full (data->backend_list, g_free);
+      data->backend_list = NULL;
+      g_object_unref (source_object);
+      if (data->cancellable)
+        g_object_unref (data->cancellable);
+      g_free (data);
+
+      return;
+    }
+
+  if (data->backend_list)
+    {
+      if (!g_cancellable_is_cancelled (data->cancellable))
+        {
+          GVariantBuilder  *include_scheme_builder = NULL;
+          GVariantBuilder  *exclude_scheme_builder = NULL;
+          g_autofree gchar *backend_name = NULL;
+
+          backend_name = data->backend_list->data;
+
+          data->callback (devices,
+                          FALSE,
+                          FALSE,
+                          data->user_data);
+
+          if (g_strcmp0 (backend_name, OTHER_BACKENDS) != 0)
+            {
+              include_scheme_builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+              g_variant_builder_add (include_scheme_builder, "s", backend_name);
+            }
+          else
+            {
+              exclude_scheme_builder = create_other_backends_array ();
+            }
+
+          data->backend_list = g_list_remove_link (data->backend_list, data->backend_list);
+
+          g_dbus_connection_call (G_DBUS_CONNECTION (g_object_ref (source_object)),
+                                  MECHANISM_BUS,
+                                  "/",
+                                  MECHANISM_BUS,
+                                  "DevicesGet",
+                                  g_variant_new ("(iiasas)",
+                                                 0,
+                                                 0,
+                                                 include_scheme_builder,
+                                                 exclude_scheme_builder),
+                                  G_VARIANT_TYPE ("(sa{ss})"),
+                                  G_DBUS_CALL_FLAGS_NONE,
+                                  DBUS_TIMEOUT,
+                                  data->cancellable,
+                                  get_cups_devices_async_dbus_cb,
+                                  user_data);
+
+          if (include_scheme_builder)
+            g_variant_builder_unref (include_scheme_builder);
+
+          if (exclude_scheme_builder)
+            g_variant_builder_unref (exclude_scheme_builder);
+
+          return;
+        }
+      else
+        {
+          data->callback (devices,
+                          TRUE,
+                          TRUE,
+                          data->user_data);
+
+          g_list_free_full (data->backend_list, g_free);
+          data->backend_list = NULL;
+        }
+    }
+  else
+    {
+      data->callback (devices,
+                      TRUE,
+                      g_cancellable_is_cancelled (data->cancellable),
+                      data->user_data);
+    }
+
+  g_object_unref (source_object);
+  if (data->cancellable)
+    g_object_unref (data->cancellable);
+  g_free (data);
+}
+
+void
+get_cups_devices_async (GCancellable *cancellable,
+                        GCDCallback   callback,
+                        gpointer      user_data)
+{
+  GDBusConnection  *bus;
+  GVariantBuilder   include_scheme_builder;
+  GCDData          *data;
+  g_autoptr(GError) error = NULL;
+  g_autofree gchar *backend_name = NULL;
+
+  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!bus)
+   {
+     g_warning ("Failed to get system bus: %s", error->message);
+     callback (NULL, TRUE, FALSE, user_data);
+     return;
+   }
+
+  data = g_new0 (GCDData, 1);
+  if (cancellable)
+    data->cancellable = g_object_ref (cancellable);
+  data->callback = callback;
+  data->user_data = user_data;
+  data->backend_list = create_backends_list ();
+
+  backend_name = data->backend_list->data;
+
+  g_variant_builder_init (&include_scheme_builder, G_VARIANT_TYPE ("as"));
+  g_variant_builder_add (&include_scheme_builder, "s", backend_name);
+
+  data->backend_list = g_list_remove_link (data->backend_list, data->backend_list);
+
+  g_dbus_connection_call (bus,
+                          MECHANISM_BUS,
+                          "/",
+                          MECHANISM_BUS,
+                          "DevicesGet",
+                          g_variant_new ("(iiasas)",
+                                         0,
+                                         0,
+                                         &include_scheme_builder,
+                                         NULL),
+                          G_VARIANT_TYPE ("(sa{ss})"),
+                          G_DBUS_CALL_FLAGS_NONE,
+                          DBUS_TIMEOUT,
+                          cancellable,
+                          get_cups_devices_async_dbus_cb,
+                          data);
+}
+
+gchar *
+guess_device_hostname (PpPrintDevice *device)
+{
+  http_uri_status_t  status;
+  char               scheme[HTTP_MAX_URI];
+  char               username[HTTP_MAX_URI];
+  char               hostname[HTTP_MAX_URI];
+  char               resource[HTTP_MAX_URI];
+  int                port;
+  gchar             *result = NULL;
+  gchar             *hostname_begin;
+  gchar             *hostname_end = NULL;
+
+  if (device != NULL && pp_print_device_get_device_uri (device) != NULL)
+    {
+      if (g_str_has_prefix (pp_print_device_get_device_uri (device), "socket") ||
+          g_str_has_prefix (pp_print_device_get_device_uri (device), "lpd") ||
+          g_str_has_prefix (pp_print_device_get_device_uri (device), "ipp") ||
+          g_str_has_prefix (pp_print_device_get_device_uri (device), "smb"))
+        {
+          status = httpSeparateURI (HTTP_URI_CODING_ALL,
+                                    pp_print_device_get_device_uri (device),
+                                    scheme, HTTP_MAX_URI,
+                                    username, HTTP_MAX_URI,
+                                    hostname, HTTP_MAX_URI,
+                                    &port,
+                                    resource, HTTP_MAX_URI);
+
+          if (status >= HTTP_URI_STATUS_OK &&
+              hostname[0] != '\0')
+            result = g_strdup (hostname);
+        }
+      else if ((g_str_has_prefix (pp_print_device_get_device_uri (device), "dnssd") ||
+                g_str_has_prefix (pp_print_device_get_device_uri (device), "mdns")) &&
+               pp_print_device_get_device_info (device) != NULL)
+        {
+          /*
+           * CUPS browses its printers as
+           * "PrinterName @ ComputerName" or "PrinterInfo @ ComputerName"
+           * through DNS-SD.
+           */
+          hostname_begin = g_strrstr (pp_print_device_get_device_info (device), " @ ");
+          if (hostname_begin != NULL)
+            result = g_strdup (hostname_begin + 3);
+        }
+      else if (g_str_has_prefix (pp_print_device_get_device_uri (device), "hp:/net/") ||
+               g_str_has_prefix (pp_print_device_get_device_uri (device), "hpfax:/net/"))
+        {
+          /*
+           * HPLIP printers have URI of form hp:/net/%s?ip=%s&port=%d
+           * or hp:/net/%s?ip=%s.
+           */
+          hostname_begin = g_strrstr (pp_print_device_get_device_uri (device), "ip=");
+          if (hostname_begin != NULL)
+            {
+              hostname_begin += 3;
+              hostname_end = strstr (hostname_begin, "&");
+            }
+
+          if (hostname_end != NULL)
+            result = g_strndup (hostname_begin, hostname_end - hostname_begin);
+          else
+            result = g_strdup (hostname_begin);
+        }
+    }
+
+  return result;
+}
+
+gchar *
+canonicalize_device_name (GList         *device_names,
+                          GPtrArray     *local_cups_devices,
+                          cups_dest_t   *dests,
+                          gint           num_of_dests,
+                          PpPrintDevice *device)
+{
+  PpPrintDevice             *item;
+  gboolean                   already_present;
+  GList                     *iter;
+  gsize                      len;
+  g_autofree gchar          *name = NULL;
+  gchar                     *occurrence;
+  gint                       name_index, j;
+  static const char * const  residues[] = {
+    "-foomatic",
+    "-hpijs",
+    "-hpcups",
+    "-cups",
+    "-gutenprint",
+    "-series",
+    "-label-printer",
+    "-dot-matrix",
+    "-ps3",
+    "-ps2",
+    "-br-script",
+    "-kpdl",
+    "-pcl3",
+    "-pcl",
+    "-zxs",
+    "-pxl"};
+
+  if (pp_print_device_get_device_id (device) != NULL)
+    {
+      name = get_tag_value (pp_print_device_get_device_id (device), "mdl");
+      if (name == NULL)
+        name = get_tag_value (pp_print_device_get_device_id (device), "model");
+    }
+
+  if (name == NULL &&
+      pp_print_device_get_device_make_and_model (device) != NULL &&
+      pp_print_device_get_device_make_and_model (device)[0] != '\0')
+    {
+      name = g_strdup (pp_print_device_get_device_make_and_model (device));
+    }
+
+  if (name == NULL &&
+      pp_print_device_get_device_original_name (device) != NULL &&
+      pp_print_device_get_device_original_name (device)[0] != '\0')
+    {
+      name = g_strdup (pp_print_device_get_device_original_name (device));
+    }
+
+  if (name == NULL &&
+      pp_print_device_get_device_info (device) != NULL &&
+      pp_print_device_get_device_info (device)[0] != '\0')
+    {
+      name = g_strdup (pp_print_device_get_device_info (device));
+    }
+
+  if (name == NULL)
+    return NULL;
+
+  g_strstrip (name);
+  g_strcanon (name, ALLOWED_CHARACTERS, '-');
+
+  /* Remove common strings found in driver names */
+  for (j = 0; j < G_N_ELEMENTS (residues); j++)
+    {
+      g_autofree gchar *lower_name = g_ascii_strdown (name, -1);
+
+      occurrence = g_strrstr (lower_name, residues[j]);
+      if (occurrence != NULL)
+        {
+          occurrence[0] = '\0';
+          name[strlen (lower_name)] = '\0';
+        }
+    }
+
+  /* Remove trailing "-" */
+  len = strlen (name);
+  while (len-- && name[len] == '-')
+    name[len] = '\0';
+
+  /* Merge "--" to "-" */
+  occurrence = g_strrstr (name, "--");
+  while (occurrence != NULL)
+    {
+      shift_string_left (occurrence);
+      occurrence = g_strrstr (name, "--");
+    }
+
+  /* Remove leading "-" */
+  if (name[0] == '-')
+    shift_string_left (name);
+
+  name_index = 2;
+  already_present = FALSE;
+  while (TRUE)
+    {
+      g_autofree gchar *new_name = NULL;
+
+      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_of_dests; j++)
+        if (g_strcmp0 (dests[j].name, new_name) == 0)
+          already_present = TRUE;
+
+      for (iter = device_names; iter; iter = iter->next)
+        {
+          gchar *device_original_name = iter->data;
+          if (g_strcmp0 (device_original_name, new_name) == 0)
+            already_present = TRUE;
+        }
+
+      for (guint i = 0; i < local_cups_devices->len; i++)
+        {
+          item = g_ptr_array_index (local_cups_devices, i);
+          if (g_strcmp0 (pp_print_device_get_device_original_name (item), new_name) == 0)
+            already_present = TRUE;
+        }
+
+      if (!already_present)
+        return g_steal_pointer (&new_name);
+    }
+}
+
+void
+shift_string_left (gchar *str)
+{
+  gchar *next;
+
+  if (str != NULL && str[0] != '\0')
+    {
+      next = g_utf8_find_next_char (str, NULL);
+      memmove (str, next, strlen (next) + 1);
+    }
+}