+/* Attributes we're interested in for printers */
+static const char * const printer_attrs[] =
+ {
+ "printer-name",
+ "printer-uri-supported",
+ "member-uris",
+ "printer-location",
+ "printer-info",
+ "printer-state-message",
+ "printer-state-reasons",
+ "printer-state",
+ "queued-job-count",
+ "printer-is-accepting-jobs",
+ "job-sheets-supported",
+ "job-sheets-default",
+ "printer-type",
+ "auth-info-required",
+ "number-up-default",
+ "ipp-versions-supported",
+ "multiple-document-handling-supported",
+ "copies-supported",
+ "number-up-supported"
+ };
+
+typedef enum
+ {
+ GTK_PRINTER_STATE_LEVEL_NONE = 0,
+ GTK_PRINTER_STATE_LEVEL_INFO = 1,
+ GTK_PRINTER_STATE_LEVEL_WARNING = 2,
+ GTK_PRINTER_STATE_LEVEL_ERROR = 3
+ } PrinterStateLevel;
+
+typedef struct
+{
+ const gchar *printer_name;
+ const gchar *printer_uri;
+ const gchar *member_uris;
+ const gchar *location;
+ const gchar *description;
+ gchar *state_msg;
+ const gchar *reason_msg;
+ PrinterStateLevel reason_level;
+ gint state;
+ gint job_count;
+ gboolean is_paused;
+ gboolean is_accepting_jobs;
+ const gchar *default_cover_before;
+ const gchar *default_cover_after;
+ gboolean default_printer;
+ gboolean got_printer_type;
+ gboolean remote_printer;
+#ifdef HAVE_AVAHI_BROWSING
+ gboolean avahi_printer;
+#endif
+ gchar **auth_info_required;
+ gint default_number_up;
+ guchar ipp_version_major;
+ guchar ipp_version_minor;
+ gboolean supports_copies;
+ gboolean supports_collate;
+ gboolean supports_number_up;
+} PrinterSetupInfo;
+
+static void
+get_ipp_version (const char *ipp_version_string,
+ guchar *ipp_version_major,
+ guchar *ipp_version_minor)
+{
+ gchar **ipp_version_strv;
+ gchar *endptr;
+
+ *ipp_version_major = 1;
+ *ipp_version_minor = 1;
+
+ if (ipp_version_string)
+ {
+ ipp_version_strv = g_strsplit (ipp_version_string, ".", 0);
+
+ if (ipp_version_strv)
+ {
+ if (g_strv_length (ipp_version_strv) == 2)
+ {
+ *ipp_version_major = (guchar) g_ascii_strtoull (ipp_version_strv[0], &endptr, 10);
+ if (endptr == ipp_version_strv[0])
+ *ipp_version_major = 1;
+
+ *ipp_version_minor = (guchar) g_ascii_strtoull (ipp_version_strv[1], &endptr, 10);
+ if (endptr == ipp_version_strv[1])
+ *ipp_version_minor = 1;
+ }
+
+ g_strfreev (ipp_version_strv);
+ }
+ }
+}
+
+static void
+get_server_ipp_version (guchar *ipp_version_major,
+ guchar *ipp_version_minor)
+{
+ *ipp_version_major = 1;
+ *ipp_version_minor = 1;
+
+ if (IPP_VERSION && strlen (IPP_VERSION) == 2)
+ {
+ *ipp_version_major = (unsigned char) IPP_VERSION[0];
+ *ipp_version_minor = (unsigned char) IPP_VERSION[1];
+ }
+}
+
+static gint
+ipp_version_cmp (guchar ipp_version_major1,
+ guchar ipp_version_minor1,
+ guchar ipp_version_major2,
+ guchar ipp_version_minor2)
+{
+ if (ipp_version_major1 == ipp_version_major2 &&
+ ipp_version_minor1 == ipp_version_minor2)
+ {
+ return 0;
+ }
+ else if (ipp_version_major1 < ipp_version_major2 ||
+ (ipp_version_major1 == ipp_version_major2 &&
+ ipp_version_minor1 < ipp_version_minor2))
+ {
+ return -1;
+ }
+ else
+ {
+ return 1;
+ }
+}
+
+static void
+cups_printer_handle_attribute (GtkPrintBackendCups *cups_backend,
+ ipp_attribute_t *attr,
+ PrinterSetupInfo *info)
+{
+ gint i, j;
+ if (strcmp (ippGetName (attr), "printer-name") == 0 &&
+ ippGetValueTag (attr) == IPP_TAG_NAME)
+ info->printer_name = ippGetString (attr, 0, NULL);
+ else if (strcmp (ippGetName (attr), "printer-uri-supported") == 0 &&
+ ippGetValueTag (attr) == IPP_TAG_URI)
+ info->printer_uri = ippGetString (attr, 0, NULL);
+ else if (strcmp (ippGetName (attr), "member-uris") == 0 &&
+ ippGetValueTag (attr) == IPP_TAG_URI)
+ info->member_uris = ippGetString (attr, 0, NULL);
+ else if (strcmp (ippGetName (attr), "printer-location") == 0)
+ info->location = ippGetString (attr, 0, NULL);
+ else if (strcmp (ippGetName (attr), "printer-info") == 0)
+ info->description = ippGetString (attr, 0, NULL);
+ else if (strcmp (ippGetName (attr), "printer-state-message") == 0)
+ info->state_msg = g_strdup (ippGetString (attr, 0, NULL));
+ else if (strcmp (ippGetName (attr), "printer-state-reasons") == 0)
+ /* Store most important reason to reason_msg and set
+ its importance at printer_state_reason_level */
+ {
+ for (i = 0; i < ippGetCount (attr); i++)
+ {
+ if (strcmp (ippGetString (attr, i, NULL), "none") != 0)
+ {
+ gboolean interested_in = FALSE;
+ /* Sets is_paused flag for paused printer. */
+ if (strcmp (ippGetString (attr, i, NULL), "paused") == 0)
+ {
+ info->is_paused = TRUE;
+ }
+
+ for (j = 0; j < G_N_ELEMENTS (printer_messages); j++)
+ if (strncmp (ippGetString (attr, i, NULL), printer_messages[j],
+ strlen (printer_messages[j])) == 0)
+ {
+ interested_in = TRUE;
+ break;
+ }
+
+ if (interested_in)
+ {
+ if (g_str_has_suffix (ippGetString (attr, i, NULL), "-report"))
+ {
+ if (info->reason_level <= GTK_PRINTER_STATE_LEVEL_INFO)
+ {
+ info->reason_msg = ippGetString (attr, i, NULL);
+ info->reason_level = GTK_PRINTER_STATE_LEVEL_INFO;
+ }
+ }
+ else if (g_str_has_suffix (ippGetString (attr, i, NULL), "-warning"))
+ {
+ if (info->reason_level <= GTK_PRINTER_STATE_LEVEL_WARNING)
+ {
+ info->reason_msg = ippGetString (attr, i, NULL);
+ info->reason_level = GTK_PRINTER_STATE_LEVEL_WARNING;
+ }
+ }
+ else /* It is error in the case of no suffix. */
+ {
+ info->reason_msg = ippGetString (attr, i, NULL);
+ info->reason_level = GTK_PRINTER_STATE_LEVEL_ERROR;
+ }
+ }
+ }
+ }
+ }
+ else if (strcmp (ippGetName (attr), "printer-state") == 0)
+ info->state = ippGetInteger (attr, 0);
+ else if (strcmp (ippGetName (attr), "queued-job-count") == 0)
+ info->job_count = ippGetInteger (attr, 0);
+ else if (strcmp (ippGetName (attr), "printer-is-accepting-jobs") == 0)
+ {
+ if (ippGetBoolean (attr, 0) == 1)
+ info->is_accepting_jobs = TRUE;
+ else
+ info->is_accepting_jobs = FALSE;
+ }
+ else if (strcmp (ippGetName (attr), "job-sheets-supported") == 0)
+ {
+ if (cups_backend->covers == NULL)
+ {
+ cups_backend->number_of_covers = ippGetCount (attr);
+ cups_backend->covers = g_new (char *, cups_backend->number_of_covers + 1);
+ for (i = 0; i < cups_backend->number_of_covers; i++)
+ cups_backend->covers[i] = g_strdup (ippGetString (attr, i, NULL));
+ cups_backend->covers[cups_backend->number_of_covers] = NULL;
+ }
+ }
+ else if (strcmp (ippGetName (attr), "job-sheets-default") == 0)
+ {
+ if (ippGetCount (attr) == 2)
+ {
+ info->default_cover_before = ippGetString (attr, 0, NULL);
+ info->default_cover_after = ippGetString (attr, 1, NULL);
+ }
+ }
+ else if (strcmp (ippGetName (attr), "printer-type") == 0)
+ {
+ info->got_printer_type = TRUE;
+ if (ippGetInteger (attr, 0) & 0x00020000)
+ info->default_printer = TRUE;
+ else
+ info->default_printer = FALSE;
+
+ if (ippGetInteger (attr, 0) & 0x00000002)
+ info->remote_printer = TRUE;
+ else
+ info->remote_printer = FALSE;
+ }
+ else if (strcmp (ippGetName (attr), "auth-info-required") == 0)
+ {
+ if (strcmp (ippGetString (attr, 0, NULL), "none") != 0)
+ {
+ info->auth_info_required = g_new0 (gchar *, ippGetCount (attr) + 1);
+ for (i = 0; i < ippGetCount (attr); i++)
+ info->auth_info_required[i] = g_strdup (ippGetString (attr, i, NULL));
+ }
+ }
+ else if (strcmp (ippGetName (attr), "number-up-default") == 0)
+ {
+ info->default_number_up = ippGetInteger (attr, 0);
+ }
+ else if (g_strcmp0 (ippGetName (attr), "ipp-versions-supported") == 0)
+ {
+ guchar server_ipp_version_major;
+ guchar server_ipp_version_minor;
+ guchar ipp_version_major;
+ guchar ipp_version_minor;
+
+ get_server_ipp_version (&server_ipp_version_major,
+ &server_ipp_version_minor);
+
+ for (i = 0; i < ippGetCount (attr); i++)
+ {
+ get_ipp_version (ippGetString (attr, i, NULL),
+ &ipp_version_major,
+ &ipp_version_minor);
+
+ if (ipp_version_cmp (ipp_version_major,
+ ipp_version_minor,
+ info->ipp_version_major,
+ info->ipp_version_minor) > 0 &&
+ ipp_version_cmp (ipp_version_major,
+ ipp_version_minor,
+ server_ipp_version_major,
+ server_ipp_version_minor) <= 0)
+ {
+ info->ipp_version_major = ipp_version_major;
+ info->ipp_version_minor = ipp_version_minor;
+ }
+ }
+ }
+ else if (g_strcmp0 (ippGetName (attr), "number-up-supported") == 0)
+ {
+ if (ippGetCount (attr) == 6)
+ {
+ info->supports_number_up = TRUE;
+ }
+ }
+ else if (g_strcmp0 (ippGetName (attr), "copies-supported") == 0)
+ {
+ int upper = 1;
+
+ ippGetRange (attr, 0, &upper);
+ if (upper > 1)
+ {
+ info->supports_copies = TRUE;
+ }
+ }
+ else if (g_strcmp0 (ippGetName (attr), "multiple-document-handling-supported") == 0)
+ {
+ for (i = 0; i < ippGetCount (attr); i++)
+ {
+ if (g_strcmp0 (ippGetString (attr, i, NULL), "separate-documents-collated-copies") == 0)
+ {
+ info->supports_collate = TRUE;
+ }
+ }
+ }
+ else
+ {
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Attribute %s ignored", ippGetName (attr)));
+ }
+}
+
+static GtkPrinter*
+cups_create_printer (GtkPrintBackendCups *cups_backend,
+ PrinterSetupInfo *info)
+{
+ GtkPrinterCups *cups_printer;
+ GtkPrinter *printer;
+ GtkPrintBackend *backend = GTK_PRINT_BACKEND (cups_backend);
+ char uri[HTTP_MAX_URI]; /* Printer URI */
+ char method[HTTP_MAX_URI]; /* Method/scheme name */
+ char username[HTTP_MAX_URI]; /* Username:password */
+ char hostname[HTTP_MAX_URI]; /* Hostname */
+ char resource[HTTP_MAX_URI]; /* Resource name */
+ int port; /* Port number */
+ char *cups_server; /* CUPS server */
+
+#ifdef HAVE_COLORD
+#ifdef HAVE_AVAHI_BROWSING
+ if (info->avahi_printer)
+ cups_printer = gtk_printer_cups_new (info->printer_name,
+ backend,
+ NULL);
+ else
+#endif
+ cups_printer = gtk_printer_cups_new (info->printer_name,
+ backend,
+ cups_backend->colord_client);
+#else
+ cups_printer = gtk_printer_cups_new (info->printer_name, backend, NULL);
+#endif
+
+ cups_printer->device_uri = g_strdup_printf ("/printers/%s",
+ info->printer_name);
+
+ /* Check to see if we are looking at a class */
+ if (info->member_uris)
+ {
+ cups_printer->printer_uri = g_strdup (info->member_uris);
+ /* TODO if member_uris is a class we need to recursivly find a printer */
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Found class with printer %s\n",
+ info->member_uris));
+ }
+ else
+ {
+ cups_printer->printer_uri = g_strdup (info->printer_uri);
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Found printer %s\n",
+ info->printer_uri));
+ }
+
+ httpSeparateURI (HTTP_URI_CODING_ALL, cups_printer->printer_uri,
+ method, sizeof (method),
+ username, sizeof (username),
+ hostname, sizeof (hostname),
+ &port,
+ resource, sizeof (resource));
+
+ if (strncmp (resource, "/printers/", 10) == 0)
+ {
+ cups_printer->ppd_name = g_strdup (resource + 10);
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Setting ppd name '%s' for printer/class '%s'\n", cups_printer->ppd_name, info->printer_name));
+ }
+
+ gethostname (uri, sizeof (uri));
+ cups_server = g_strdup (cupsServer());
+
+ if (strcasecmp (uri, hostname) == 0)
+ strcpy (hostname, "localhost");
+
+ /* if the cups server is local and listening at a unix domain socket
+ * then use the socket connection
+ */
+ if ((strstr (hostname, "localhost") != NULL) &&
+ (cups_server[0] == '/'))
+ strcpy (hostname, cups_server);
+
+ g_free (cups_server);
+
+ cups_printer->default_cover_before = g_strdup (info->default_cover_before);
+ cups_printer->default_cover_after = g_strdup (info->default_cover_after);
+
+ if (info->default_number_up > 0)
+ cups_printer->default_number_up = info->default_number_up;
+
+ cups_printer->hostname = g_strdup (hostname);
+ cups_printer->port = port;
+
+ cups_printer->auth_info_required = g_strdupv (info->auth_info_required);
+ g_strfreev (info->auth_info_required);
+
+ printer = GTK_PRINTER (cups_printer);
+
+ if (cups_backend->default_printer != NULL &&
+ strcmp (cups_backend->default_printer, gtk_printer_get_name (printer)) == 0)
+ gtk_printer_set_is_default (printer, TRUE);
+
+#ifdef HAVE_AVAHI_BROWSING
+ cups_printer->avahi_browsed = info->avahi_printer;
+#endif
+
+ gtk_print_backend_add_printer (backend, printer);
+ return printer;
+}
+
+static void
+set_printer_icon_name_from_info (GtkPrinter *printer,
+ PrinterSetupInfo *info)
+{
+ /* Set printer icon according to importance
+ (none, report, warning, error - report is omitted). */
+ if (info->reason_level == GTK_PRINTER_STATE_LEVEL_ERROR)
+ gtk_printer_set_icon_name (printer, "printer-error");
+ else if (info->reason_level == GTK_PRINTER_STATE_LEVEL_WARNING)
+ gtk_printer_set_icon_name (printer, "printer-warning");
+ else if (gtk_printer_is_paused (printer))
+ gtk_printer_set_icon_name (printer, "printer-paused");
+ else
+ gtk_printer_set_icon_name (printer, "printer");
+}
+
+static void
+set_info_state_message (PrinterSetupInfo *info)
+{
+ gint i;
+
+ if (info->state_msg && strlen (info->state_msg) == 0)
+ {
+ gchar *tmp_msg2 = NULL;
+ if (info->is_paused && !info->is_accepting_jobs)
+ /* Translators: this is a printer status. */
+ tmp_msg2 = g_strdup ( _("Paused; Rejecting Jobs"));
+ if (info->is_paused && info->is_accepting_jobs)
+ /* Translators: this is a printer status. */
+ tmp_msg2 = g_strdup ( _("Paused"));
+ if (!info->is_paused && !info->is_accepting_jobs)
+ /* Translators: this is a printer status. */
+ tmp_msg2 = g_strdup ( _("Rejecting Jobs"));
+
+ if (tmp_msg2 != NULL)
+ {
+ g_free (info->state_msg);
+ info->state_msg = tmp_msg2;
+ }
+ }
+
+ /* Set description of the reason and combine it with printer-state-message. */
+ if (info->reason_msg)
+ {
+ gchar *reason_msg_desc = NULL;
+ gboolean found = FALSE;
+
+ for (i = 0; i < G_N_ELEMENTS (printer_messages); i++)
+ {
+ if (strncmp (info->reason_msg, printer_messages[i],
+ strlen (printer_messages[i])) == 0)
+ {
+ reason_msg_desc = g_strdup_printf (printer_strings[i],
+ info->printer_name);
+ found = TRUE;
+ break;
+ }
+ }
+
+ if (!found)
+ info->reason_level = GTK_PRINTER_STATE_LEVEL_NONE;
+
+ if (info->reason_level >= GTK_PRINTER_STATE_LEVEL_WARNING)
+ {
+ if (strlen (info->state_msg) == 0)
+ {
+ g_free (info->state_msg);
+ info->state_msg = reason_msg_desc;
+ reason_msg_desc = NULL;
+ }
+ else
+ {
+ gchar *tmp_msg = NULL;
+ /* Translators: this string connects multiple printer states together. */
+ tmp_msg = g_strjoin ( _("; "), info->state_msg,
+ reason_msg_desc, NULL);
+ g_free (info->state_msg);
+ info->state_msg = tmp_msg;
+ }
+ }
+
+ g_free (reason_msg_desc);
+ }
+}
+
+static void
+set_default_printer (GtkPrintBackendCups *cups_backend,
+ const gchar *default_printer_name)
+{
+ cups_backend->default_printer = g_strdup (default_printer_name);
+ cups_backend->got_default_printer = TRUE;
+
+ if (cups_backend->default_printer != NULL)
+ {
+ GtkPrinter *default_printer = NULL;
+ default_printer = gtk_print_backend_find_printer (GTK_PRINT_BACKEND (cups_backend),
+ cups_backend->default_printer);
+ if (default_printer != NULL)
+ {
+ gtk_printer_set_is_default (default_printer, TRUE);
+ g_signal_emit_by_name (GTK_PRINT_BACKEND (cups_backend),
+ "printer-status-changed", default_printer);
+ }
+ }
+}
+
+#ifdef HAVE_AVAHI_BROWSING
+typedef struct
+{
+ gchar *name;
+ gchar *type;
+ gchar *domain;
+ gchar *host;
+ gint port;
+} AvahiService;
+
+void
+avahi_service_free (AvahiService *service)
+{
+ if (service)
+ {
+ g_free (service->name);
+ g_free (service->type);
+ g_free (service->domain);
+ g_free (service->host);
+ g_free (service);
+ }
+}
+
+static void
+avahi_data_free (GtkPrintBackendCups *cups_backend)
+{
+ if (cups_backend)
+ {
+ g_clear_pointer (&cups_backend->avahi_default_printer, g_free);
+ g_list_free_full (cups_backend->avahi_resolvers, g_object_unref);
+ cups_backend->avahi_resolvers = NULL;
+ g_clear_object (&cups_backend->avahi_ipp_browser);
+ g_clear_object (&cups_backend->avahi_ipps_browser);
+ g_clear_object (&cups_backend->avahi_client);
+ }
+}
+
+static void
+cups_request_avahi_printer_info_cb (GtkPrintBackendCups *cups_backend,
+ GtkCupsResult *result,
+ gpointer user_data)
+{
+ PrinterSetupInfo *info = g_slice_new0 (PrinterSetupInfo);
+ GtkPrintBackend *backend = GTK_PRINT_BACKEND (cups_backend);
+ ipp_attribute_t *attr;
+ AvahiService *service = (AvahiService *) user_data;
+ GtkPrinter *printer;
+ gboolean list_has_changed = FALSE;
+ gboolean status_changed = FALSE;
+ ipp_t *response;
+
+ gdk_threads_enter ();
+
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
+ if (gtk_cups_result_is_error (result))
+ {
+ GTK_NOTE (PRINTING,
+ g_warning ("CUPS Backend: Error getting printer info: %s %d %d",
+ gtk_cups_result_get_error_string (result),
+ gtk_cups_result_get_error_type (result),
+ gtk_cups_result_get_error_code (result)));
+
+ goto done;
+ }
+
+ response = gtk_cups_result_get_response (result);
+ attr = ippFirstAttribute (response);
+ while (attr && ippGetGroupTag (attr) != IPP_TAG_PRINTER)
+ attr = ippNextAttribute (response);
+
+ if (attr)
+ {
+ while (attr && ippGetGroupTag (attr) == IPP_TAG_PRINTER)
+ {
+ cups_printer_handle_attribute (cups_backend, attr, info);
+ attr = ippNextAttribute (response);
+ }
+
+ if (info->printer_name && info->printer_uri)
+ {
+ info->avahi_printer = TRUE;
+
+ if (info->got_printer_type &&
+ info->default_printer &&
+ cups_backend->avahi_default_printer == NULL)
+ cups_backend->avahi_default_printer = g_strdup (info->printer_name);
+
+ set_info_state_message (info);
+
+ printer = gtk_print_backend_find_printer (backend, info->printer_name);
+ if (!printer)
+ {
+ printer = cups_create_printer (cups_backend, info);
+ list_has_changed = TRUE;
+ }
+ else
+ {
+ g_object_ref (printer);
+ }
+
+ gtk_printer_set_is_paused (printer, info->is_paused);
+ gtk_printer_set_is_accepting_jobs (printer, info->is_accepting_jobs);
+
+ if (!gtk_printer_is_active (printer))
+ {
+ gtk_printer_set_is_active (printer, TRUE);
+ gtk_printer_set_is_new (printer, TRUE);
+ list_has_changed = TRUE;
+ }
+
+ GTK_PRINTER_CUPS (printer)->remote = info->remote_printer;
+ GTK_PRINTER_CUPS (printer)->avahi_name = g_strdup (service->name);
+ GTK_PRINTER_CUPS (printer)->avahi_type = g_strdup (service->type);
+ GTK_PRINTER_CUPS (printer)->avahi_domain = g_strdup (service->domain);
+ GTK_PRINTER_CUPS (printer)->hostname = g_strdup (service->host);
+ GTK_PRINTER_CUPS (printer)->port = service->port;
+ GTK_PRINTER_CUPS (printer)->state = info->state;
+ GTK_PRINTER_CUPS (printer)->ipp_version_major = info->ipp_version_major;
+ GTK_PRINTER_CUPS (printer)->ipp_version_minor = info->ipp_version_minor;
+ GTK_PRINTER_CUPS (printer)->supports_copies = info->supports_copies;
+ GTK_PRINTER_CUPS (printer)->supports_collate = info->supports_collate;
+ GTK_PRINTER_CUPS (printer)->supports_number_up = info->supports_number_up;
+ status_changed = gtk_printer_set_job_count (printer, info->job_count);
+ status_changed |= gtk_printer_set_location (printer, info->location);
+ status_changed |= gtk_printer_set_description (printer, info->description);
+ status_changed |= gtk_printer_set_state_message (printer, info->state_msg);
+ status_changed |= gtk_printer_set_is_accepting_jobs (printer, info->is_accepting_jobs);
+
+ set_printer_icon_name_from_info (printer, info);
+
+ if (gtk_printer_is_new (printer))
+ {
+ g_signal_emit_by_name (backend, "printer-added", printer);
+ gtk_printer_set_is_new (printer, FALSE);
+ }
+
+ if (status_changed)
+ g_signal_emit_by_name (GTK_PRINT_BACKEND (backend),
+ "printer-status-changed", printer);
+
+ /* The ref is held by GtkPrintBackend, in add_printer() */
+ g_object_unref (printer);
+ }
+ }
+
+done:
+ if (list_has_changed)
+ g_signal_emit_by_name (backend, "printer-list-changed");
+
+ if (!cups_backend->got_default_printer &&
+ gtk_print_backend_printer_list_is_done (backend) &&
+ cups_backend->avahi_default_printer != NULL)
+ {
+ set_default_printer (cups_backend, cups_backend->avahi_default_printer);
+ }
+
+ g_slice_free (PrinterSetupInfo, info);
+
+ gdk_threads_leave ();
+}
+
+static void
+cups_request_avahi_printer_info (const gchar *printer_uri,
+ const gchar *host,
+ gint port,
+ const gchar *name,
+ const gchar *type,
+ const gchar *domain,
+ GtkPrintBackendCups *backend)
+{
+ GtkCupsRequest *request;
+ AvahiService *service;
+ http_t *http;
+
+ http = httpConnect (host, port);
+ if (http)
+ {
+ service = (AvahiService *) g_new0 (AvahiService, 1);
+ service->name = g_strdup (name);
+ service->type = g_strdup (type);
+ service->domain = g_strdup (domain);
+ service->host = g_strdup (host);
+ service->port = port;
+
+ request = gtk_cups_request_new_with_username (http,
+ GTK_CUPS_POST,
+ IPP_GET_PRINTER_ATTRIBUTES,
+ NULL,
+ NULL,
+ NULL,
+ backend->username);
+
+ gtk_cups_request_set_ipp_version (request, 1, 1);
+
+ gtk_cups_request_ipp_add_string (request, IPP_TAG_OPERATION, IPP_TAG_URI,
+ "printer-uri", NULL, printer_uri);
+
+ gtk_cups_request_ipp_add_strings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+ "requested-attributes", G_N_ELEMENTS (printer_attrs),
+ NULL, printer_attrs);
+
+ cups_request_execute (backend,
+ request,
+ (GtkPrintCupsResponseCallbackFunc) cups_request_avahi_printer_info_cb,
+ service,
+ (GDestroyNotify) avahi_service_free);
+ }
+}
+
+static void
+avahi_resolver_found_cb (GaServiceResolver *resolver,
+ int interface,
+ GaProtocol protocol,
+ const char *name,
+ const char *type,
+ const char *domain,
+ const char *host_name,
+ const AvahiAddress *address,
+ guint16 port,
+ AvahiStringList *txt,
+ glong flags,
+ gpointer *user_data)
+{
+ GtkPrintBackendCups *backend = GTK_PRINT_BACKEND_CUPS (user_data);
+ AvahiStringList *item;
+ const gchar *protocol_string;
+ gchar host[AVAHI_ADDRESS_STR_MAX];
+ gchar *suffix = NULL;
+ gchar *printer_uri;
+
+ avahi_address_snprint (host, sizeof (host), address);
+
+ item = avahi_string_list_find (txt, "rp");
+ if (item)
+ avahi_string_list_get_pair (item, NULL, &suffix, NULL);
+
+ if (suffix)
+ {
+ if (g_strcmp0 (type, "_ipp._tcp") == 0)
+ protocol_string = "ipp";
+ else
+ protocol_string = "ipps";
+
+ if (protocol == GA_PROTOCOL_INET6)
+ printer_uri = g_strdup_printf ("%s://[%s]:%u/%s", protocol_string, host, port, suffix);
+ else
+ printer_uri = g_strdup_printf ("%s://%s:%u/%s", protocol_string, host, port, suffix);
+
+ cups_request_avahi_printer_info (printer_uri,
+ host,
+ port,
+ name,
+ type,
+ domain,
+ backend);
+
+ g_free (printer_uri);
+ g_free (suffix);
+ }
+}
+
+static void
+avahi_browser_new_service_cb (GaServiceBrowser *browser,
+ int interface,
+ GaProtocol protocol,
+ const char *name,
+ const char *type,
+ const char *domain,
+ glong flags,
+ gpointer user_data)
+{
+ GtkPrintBackendCups *backend = GTK_PRINT_BACKEND_CUPS (user_data);
+ GaServiceResolver *resolver;
+ GError *error = NULL;
+
+ resolver = ga_service_resolver_new (AVAHI_IF_UNSPEC,
+ AVAHI_PROTO_UNSPEC,
+ name, type, domain,
+ AVAHI_PROTO_UNSPEC,
+ GA_LOOKUP_USE_MULTICAST);
+
+ g_signal_connect (resolver, "found",
+ G_CALLBACK (avahi_resolver_found_cb), user_data);
+
+ if (!ga_service_resolver_attach (resolver,
+ backend->avahi_client,
+ &error))
+ {
+ GTK_NOTE (PRINTING,
+ g_warning ("CUPS Backend: Error resolving Avahi service %s: %s",
+ name, error->message));
+ g_clear_object (&resolver);
+ g_clear_error (&error);
+ return;
+ }
+
+ backend->avahi_resolvers = g_list_append (backend->avahi_resolvers, resolver);
+}
+
+static void
+avahi_browser_removed_service_cb (GaServiceBrowser *browser,
+ int interface,
+ GaProtocol protocol,
+ const char *name,
+ const char *type,
+ const char *domain,
+ glong flags,
+ gpointer user_data)
+{
+ GtkPrintBackendCups *backend = GTK_PRINT_BACKEND_CUPS (user_data);
+ GtkPrinterCups *printer;
+ GList *list;
+ GList *iter;
+
+ list = gtk_print_backend_get_printer_list (GTK_PRINT_BACKEND (backend));
+ for (iter = list; iter; iter = iter->next)
+ {
+ printer = GTK_PRINTER_CUPS (iter->data);
+ if (g_strcmp0 (printer->avahi_name, name) == 0 &&
+ g_strcmp0 (printer->avahi_type, type) == 0 &&
+ g_strcmp0 (printer->avahi_domain, domain) == 0)
+ {
+ if (g_strcmp0 (gtk_printer_get_name (GTK_PRINTER (printer)),
+ backend->avahi_default_printer) == 0)
+ g_clear_pointer (&backend->avahi_default_printer, g_free);
+
+ g_signal_emit_by_name (backend, "printer-removed", printer);
+ gtk_print_backend_remove_printer (GTK_PRINT_BACKEND (backend),
+ GTK_PRINTER (printer));
+ g_signal_emit_by_name (backend, "printer-list-changed");
+ break;
+ }
+ }
+
+ g_list_free (list);
+}
+
+static gboolean
+avahi_client_renew (gpointer user_data)
+{
+ GtkPrintBackendCups *backend = GTK_PRINT_BACKEND_CUPS (user_data);
+ gboolean avahi_printers_removed = TRUE;
+ GList *list;
+ GList *iter;
+
+ list = gtk_print_backend_get_printer_list (GTK_PRINT_BACKEND (backend));
+ for (iter = list; iter; iter = iter->next)
+ if (GTK_PRINTER_CUPS (iter->data)->avahi_browsed)
+ avahi_printers_removed = FALSE;
+
+ g_list_free (list);
+
+ if (avahi_printers_removed)
+ {
+ avahi_data_free (backend);
+ avahi_request_printer_list (backend);
+ return FALSE;
+ }
+ else
+ {
+ return TRUE;
+ }
+}
+
+static void
+avahi_client_state_changed_cb (GaClient *ga_client,
+ GaClientState state,
+ gpointer user_data)
+{
+ GtkPrintBackendCups *backend = GTK_PRINT_BACKEND_CUPS (user_data);
+ GtkPrinterCups *printer;
+ gboolean list_has_changed = FALSE;
+ GError *error = NULL;
+ GList *list;
+ GList *iter;
+
+ switch (state)
+ {
+ case GA_CLIENT_STATE_FAILURE:
+ if (avahi_client_errno (ga_client->avahi_client) == AVAHI_ERR_DISCONNECTED)
+ {
+ list = gtk_print_backend_get_printer_list (GTK_PRINT_BACKEND (backend));
+
+ for (iter = list; iter; iter = iter->next)
+ {
+ printer = GTK_PRINTER_CUPS (iter->data);
+ if (printer->avahi_browsed)
+ {
+ g_signal_emit_by_name (backend, "printer-removed", printer);
+ gtk_print_backend_remove_printer (GTK_PRINT_BACKEND (backend),
+ GTK_PRINTER (printer));
+ list_has_changed = TRUE;
+ }
+ }
+
+ if (list_has_changed)
+ g_signal_emit_by_name (backend, "printer-list-changed");
+
+ g_idle_add (avahi_client_renew, backend);
+
+ g_list_free (list);
+ }
+ break;
+
+ case GA_CLIENT_STATE_S_RUNNING:
+ backend->avahi_ipp_browser = ga_service_browser_new ("_ipp._tcp");
+
+ g_signal_connect (backend->avahi_ipp_browser, "new-service",
+ G_CALLBACK (avahi_browser_new_service_cb),
+ user_data);
+
+ g_signal_connect (backend->avahi_ipp_browser, "removed-service",
+ G_CALLBACK (avahi_browser_removed_service_cb),
+ user_data);
+
+ if (!ga_service_browser_attach (backend->avahi_ipp_browser,
+ backend->avahi_client,
+ &error))
+ {
+ GTK_NOTE (PRINTING,
+ g_warning ("CUPS Backend: Error getting printer list from Avahi: %s",
+ error->message));
+ g_clear_object (&backend->avahi_ipp_browser);
+ g_clear_error (&error);
+ }
+
+ backend->avahi_ipps_browser = ga_service_browser_new ("_ipps._tcp");
+
+ g_signal_connect (backend->avahi_ipps_browser, "new-service",
+ G_CALLBACK (avahi_browser_new_service_cb),
+ user_data);
+
+ g_signal_connect (backend->avahi_ipps_browser, "removed-service",
+ G_CALLBACK (avahi_browser_removed_service_cb),
+ user_data);
+
+ if (!ga_service_browser_attach (backend->avahi_ipps_browser,
+ backend->avahi_client,
+ &error))
+ {
+ GTK_NOTE (PRINTING,
+ g_warning ("CUPS Backend: Error getting printer list from Avahi: %s",
+ error->message));
+ g_clear_object (&backend->avahi_ipps_browser);
+ g_clear_error (&error);
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void
+avahi_request_printer_list (GtkPrintBackendCups *cups_backend)
+{
+ GError *error = NULL;
+
+ if (!cups_backend->avahi_client)
+ {
+ cups_backend->avahi_client = ga_client_new (GA_CLIENT_FLAG_NO_FAIL);
+
+ g_signal_connect (cups_backend->avahi_client, "state-changed",
+ G_CALLBACK (avahi_client_state_changed_cb),
+ cups_backend);
+
+ if (!ga_client_start (cups_backend->avahi_client, &error))
+ {
+ GTK_NOTE (PRINTING,
+ g_warning ("CUPS Backend: Error getting printer list from Avahi: %s",
+ error->message));
+ g_clear_object (&cups_backend->avahi_client);
+ g_clear_error (&error);
+ }
+ }
+}
+#endif
+
+static void
+cups_request_printer_list_cb (GtkPrintBackendCups *cups_backend,
+ GtkCupsResult *result,
+ gpointer user_data)
+{
+ GtkPrintBackend *backend = GTK_PRINT_BACKEND (cups_backend);
+ ipp_attribute_t *attr;