// SPDX-License-Identifier: GPL-2.0+

/* NetworkManager Applet -- allow user control over networking

 *

 * Copyright (C) 2004 - 2017 Red Hat, Inc.

 * Copyright (C) 2005 - 2008 Novell, Inc.

 *

 * This applet used the GNOME Wireless Applet as a skeleton to build from.

 *

 * GNOME Wireless Applet Authors:

 *		Eskil Heyn Olsen <eskil@eskil.dk>

 *		Bastien Nocera <hadess@hadess.net> (Gnome2 port)

 *

 * Copyright 2001, 2002 Free Software Foundation

 */

#include "nm-default.h"

#include <time.h>

#include <string.h>

#include <strings.h>

#include <unistd.h>

#include <sys/socket.h>

#include <stdlib.h>

#include <libnotify/notify.h>

#include "applet.h"

#include "applet-device-bt.h"

#include "applet-device-ethernet.h"

#include "applet-device-wifi.h"

#include "applet-dialogs.h"

#include "nma-wifi-dialog.h"

#include "applet-vpn-request.h"

#include "utils.h"

#if WITH_WWAN

# include "applet-device-broadband.h"

#endif

#define NOTIFY_CAPS_ACTIONS_KEY "actions"

extern gboolean shell_debug;

extern gboolean with_agent;

extern gboolean with_appindicator;

G_DEFINE_TYPE (NMApplet, nma, G_TYPE_APPLICATION)

/********************************************************************/

static gboolean

applet_request_wifi_scan (NMApplet *applet)

{

	const GPtrArray *devices;

	NMDevice *device;

	int i;

	g_debug ("requesting wifi scan");

	/* Request scan for all wifi devices */

	devices = nm_client_get_devices (applet->nm_client);

	for (i = 0; devices && i < devices->len; i++) {

		device = g_ptr_array_index (devices, i);

		if (NM_IS_DEVICE_WIFI (device))

			nm_device_wifi_request_scan ((NMDeviceWifi *) device, NULL, NULL);

	}

	return G_SOURCE_CONTINUE;

}

static void

applet_start_wifi_scan (NMApplet *applet, gpointer unused)

{

	nm_clear_g_source (&applet->wifi_scan_id);

	applet->wifi_scan_id = g_timeout_add_seconds (15,

	                                              (GSourceFunc) applet_request_wifi_scan,

	                                              applet);

	applet_request_wifi_scan (applet);

}

static void

applet_stop_wifi_scan (NMApplet *applet, gpointer unused)

{

	nm_clear_g_source (&applet->wifi_scan_id);

}

static inline NMADeviceClass *

get_device_class (NMDevice *device, NMApplet *applet)

{

	g_return_val_if_fail (device != NULL, NULL);

	g_return_val_if_fail (applet != NULL, NULL);

	if (NM_IS_DEVICE_ETHERNET (device))

		return applet->ethernet_class;

	else if (NM_IS_DEVICE_WIFI (device))

		return applet->wifi_class;

	else if (NM_IS_DEVICE_MODEM (device)) {

#if WITH_WWAN

		return applet->broadband_class;

#else

		g_debug ("%s: modem found but WWAN support not enabled", __func__);

#endif

	} else if (NM_IS_DEVICE_BT (device))

		return applet->bt_class;

	else

		g_debug ("%s: Unknown device type '%s'", __func__, G_OBJECT_TYPE_NAME (device));

	return NULL;

}

static inline NMADeviceClass *

get_device_class_from_connection (NMConnection *connection, NMApplet *applet)

{

	NMSettingConnection *s_con;

	const char *ctype;

	g_return_val_if_fail (connection != NULL, NULL);

	g_return_val_if_fail (applet != NULL, NULL);

	s_con = nm_connection_get_setting_connection (connection);

	g_return_val_if_fail (s_con != NULL, NULL);

	ctype = nm_setting_connection_get_connection_type (s_con);

	g_return_val_if_fail (ctype != NULL, NULL);

	if (!strcmp (ctype, NM_SETTING_WIRED_SETTING_NAME) || !strcmp (ctype, NM_SETTING_PPPOE_SETTING_NAME))

		return applet->ethernet_class;

	else if (!strcmp (ctype, NM_SETTING_WIRELESS_SETTING_NAME))

		return applet->wifi_class;

#if WITH_WWAN

	else if (!strcmp (ctype, NM_SETTING_GSM_SETTING_NAME) || !strcmp (ctype, NM_SETTING_CDMA_SETTING_NAME))

		return applet->broadband_class;

#endif

	else if (!strcmp (ctype, NM_SETTING_BLUETOOTH_SETTING_NAME))

		return applet->bt_class;

	else

		g_warning ("%s: unhandled connection type '%s'", __func__, ctype);

	return NULL;

}

static NMActiveConnection *

applet_get_best_activating_connection (NMApplet *applet, NMDevice **device)

{

	NMActiveConnection *best = NULL;

	NMDevice *best_dev = NULL;

	const GPtrArray *connections;

	int i;

	g_return_val_if_fail (NM_IS_APPLET (applet), NULL);

	g_return_val_if_fail (device != NULL, NULL);

	g_return_val_if_fail (*device == NULL, NULL);

	connections = nm_client_get_active_connections (applet->nm_client);

	for (i = 0; connections && (i < connections->len); i++) {

		NMActiveConnection *candidate = g_ptr_array_index (connections, i);

		const GPtrArray *devices;

		NMDevice *candidate_dev;

		if (nm_active_connection_get_state (candidate) != NM_ACTIVE_CONNECTION_STATE_ACTIVATING)

			continue;

		devices = nm_active_connection_get_devices (candidate);

		if (!devices || !devices->len)

			continue;

		candidate_dev = g_ptr_array_index (devices, 0);

		if (!get_device_class (candidate_dev, applet))

			continue;

		if (!best_dev) {

			best_dev = candidate_dev;

			best = candidate;

			continue;

		}

		if (NM_IS_DEVICE_WIFI (best_dev)) {

			if (NM_IS_DEVICE_ETHERNET (candidate_dev)) {

				best_dev = candidate_dev;

				best = candidate;

			}

		} else if (NM_IS_DEVICE_MODEM (best_dev)) {

			NMDeviceModemCapabilities best_caps;

			NMDeviceModemCapabilities candidate_caps = NM_DEVICE_MODEM_CAPABILITY_NONE;

			best_caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (best_dev));

			if (NM_IS_DEVICE_MODEM (candidate_dev))

				candidate_caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (candidate_dev));

			if (best_caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO) {

				if (   NM_IS_DEVICE_ETHERNET (candidate_dev)

				    || NM_IS_DEVICE_WIFI (candidate_dev)) {

					best_dev = candidate_dev;

					best = candidate;

				}

			} else if (best_caps & NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS) {

				if (   NM_IS_DEVICE_ETHERNET (candidate_dev)

					|| NM_IS_DEVICE_WIFI (candidate_dev)

					|| (candidate_caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO)) {

					best_dev = candidate_dev;

					best = candidate;

				}

			}

		}

	}

	*device = best_dev;

	return best;

}

static NMActiveConnection *

applet_get_default_active_connection (NMApplet *applet, NMDevice **device,

                                      gboolean only_known_devices)

{

	NMActiveConnection *default_ac = NULL;

	NMDevice *non_default_device = NULL;

	NMActiveConnection *non_default_ac = NULL;

	const GPtrArray *connections;

	int i;

	g_return_val_if_fail (NM_IS_APPLET (applet), NULL);

	g_return_val_if_fail (device != NULL, NULL);

	g_return_val_if_fail (*device == NULL, NULL);

	connections = nm_client_get_active_connections (applet->nm_client);

	for (i = 0; connections && (i < connections->len); i++) {

		NMActiveConnection *candidate = g_ptr_array_index (connections, i);

		NMDevice *candidate_dev;

		const GPtrArray *devices;

		devices = nm_active_connection_get_devices (candidate);

		if (!devices || !devices->len)

			continue;

		candidate_dev = g_ptr_array_index (devices, 0);

		if (   only_known_devices

		    && !get_device_class (candidate_dev, applet))

			continue;

		/* We have to return default connection/device even if they are of an

		 * unknown class - otherwise we may end up returning non

		 * default interface which has nothing to do with our default

		 * route, e.g. we may return slave ethernet when we have

		 * defult route going through bond */

		if (nm_active_connection_get_default (candidate)) {

			if (!default_ac) {

				*device = candidate_dev;

				default_ac = candidate;

			}

		} else {

			if (!non_default_ac) {

				non_default_device = candidate_dev;

				non_default_ac = candidate;

			}

		}

	}

	/* Prefer the default connection if one exists, otherwise return the first

	 * non-default connection.

	 */

	if (!default_ac && non_default_ac) {

		default_ac = non_default_ac;

		*device = non_default_device;

	}

	return default_ac;

}

GPtrArray *

applet_get_all_connections (NMApplet *applet)

{

	const GPtrArray *all_connections;

	GPtrArray *connections;

	int i;

	NMConnection *connection;

	NMSettingConnection *s_con;

	all_connections = nm_client_get_connections (applet->nm_client);

	connections = g_ptr_array_new_full (all_connections->len, g_object_unref);

	/* Ignore slave connections unless they are wifi connections */

	for (i = 0; i < all_connections->len; i++) {

		connection = all_connections->pdata[i];

		s_con = nm_connection_get_setting_connection (connection);

		if (   s_con

		    && (   !nm_setting_connection_get_master (s_con)

		        || nm_connection_get_setting_wireless (connection)))

			g_ptr_array_add (connections, g_object_ref (connection));

	}

	return connections;

}

static NMActiveConnection *

applet_get_active_for_connection (NMApplet *applet, NMConnection *connection)

{

	const GPtrArray *active_list;

	int i;

	const char *cpath;

	cpath = nm_connection_get_path (connection);

	g_return_val_if_fail (cpath != NULL, NULL);

	active_list = nm_client_get_active_connections (applet->nm_client);

	for (i = 0; active_list && (i < active_list->len); i++) {

		NMActiveConnection *active = NM_ACTIVE_CONNECTION (g_ptr_array_index (active_list, i));

		NMRemoteConnection *conn = nm_active_connection_get_connection (active);

		if (conn) {

			const char *active_cpath = nm_connection_get_path (NM_CONNECTION (conn));

			if (active_cpath && !strcmp (active_cpath, cpath))

				return active;

		}

	}

	return NULL;

}

NMDevice *

applet_get_device_for_connection (NMApplet *applet, NMConnection *connection)

{

	const GPtrArray *active_list;

	const char *cpath;

	int i;

	cpath = nm_connection_get_path (connection);

	g_return_val_if_fail (cpath != NULL, NULL);

	active_list = nm_client_get_active_connections (applet->nm_client);

	for (i = 0; active_list && (i < active_list->len); i++) {

		NMActiveConnection *active = NM_ACTIVE_CONNECTION (g_ptr_array_index (active_list, i));

		NMRemoteConnection *ac_conn = nm_active_connection_get_connection (active);

		if (!g_strcmp0 (nm_connection_get_path (NM_CONNECTION (ac_conn)), cpath))

			return g_ptr_array_index (nm_active_connection_get_devices (active), 0);

	}

	return NULL;

}

typedef struct {

	NMApplet *applet;

	NMDevice *device;

	char *specific_object;

	NMConnection *connection;

} AppletItemActivateInfo;

static void

applet_item_activate_info_destroy (AppletItemActivateInfo *info)

{

	g_return_if_fail (info != NULL);

	if (info->device)

		g_object_unref (info->device);

	g_free (info->specific_object);

	if (info->connection)

		g_object_unref (info->connection);

	memset (info, 0, sizeof (AppletItemActivateInfo));

	g_free (info);

}

static void

add_and_activate_cb (GObject *client,

                     GAsyncResult *result,

                     gpointer user_data)

{

	NMApplet *applet = NM_APPLET (user_data);

	GError *error = NULL;

	NMActiveConnection *active;

	active = nm_client_add_and_activate_connection_finish (NM_CLIENT (client), result, &error);

	g_clear_object (&active);

	if (error) {

		const char *text = _("Failed to add/activate connection");

		char *err_text = g_strdup_printf ("(%d) %s", error->code,

		                                  error->message ? error->message : _("Unknown error"));

		g_warning ("%s: %s", text, err_text);

		utils_show_error_dialog (_("Connection failure"), text, err_text, FALSE, NULL);

		g_free (err_text);

		g_error_free (error);

	}

	applet_schedule_update_icon (applet);

	applet_schedule_update_menu (applet);

}

static void

applet_menu_item_activate_helper_new_connection (NMConnection *connection,

                                                 gboolean auto_created,

                                                 gboolean canceled,

                                                 gpointer user_data)

{

	AppletItemActivateInfo *info = user_data;

	if (canceled) {

		applet_item_activate_info_destroy (info);

		return;

	}

	g_return_if_fail (connection != NULL);

	/* Ask NM to add the new connection and activate it; NM will fill in the

	 * missing details based on the specific object and the device.

	 */

	nm_client_add_and_activate_connection_async (info->applet->nm_client,

	                                             connection,

	                                             info->device,

	                                             info->specific_object,

	                                             NULL,

	                                             add_and_activate_cb,

	                                             info->applet);

	applet_item_activate_info_destroy (info);

}

static void

disconnect_cb (GObject *device,

               GAsyncResult *result,

               gpointer user_data)

{

	NMApplet *applet = NM_APPLET (user_data);

	GError *error = NULL;

	nm_device_disconnect_finish (NM_DEVICE (device), result, &error);

	if (error) {

		const char *text = _("Device disconnect failed");

		char *err_text = g_strdup_printf ("(%d) %s", error->code,

		                                  error->message ? error->message : _("Unknown error"));

		g_warning ("%s: %s: %s", __func__, text, err_text);

		utils_show_error_dialog (_("Disconnect failure"), text, err_text, FALSE, NULL);

		g_free (err_text);

		g_error_free (error);

	}

	applet_schedule_update_icon (applet);

	applet_schedule_update_menu (applet);

}

void

applet_menu_item_disconnect_helper (NMDevice *device,

                                    NMApplet *applet)

{

	g_return_if_fail (NM_IS_DEVICE (device));

	nm_device_disconnect_async (device, NULL, disconnect_cb, applet);

}

static void

activate_connection_cb (GObject *client,

                        GAsyncResult *result,

                        gpointer user_data)

{

	GError *error = NULL;

	NMActiveConnection *active;

	active = nm_client_activate_connection_finish (NM_CLIENT (client), result, &error);

	g_clear_object (&active);

	if (error) {

		const char *text = _("Connection activation failed");

		char *err_text = g_strdup_printf ("(%d) %s", error->code,

		                                  error->message ? error->message : _("Unknown error"));

		g_warning ("%s: %s", text, err_text);

		utils_show_error_dialog (_("Connection failure"), text, err_text, FALSE, NULL);

		g_free (err_text);

		g_error_free (error);

	}

	applet_schedule_update_icon (NM_APPLET (user_data));

}

void

applet_menu_item_activate_helper (NMDevice *device,

                                  NMConnection *connection,

                                  const char *specific_object,

                                  NMApplet *applet,

                                  gpointer dclass_data)

{

	AppletItemActivateInfo *info;

	NMADeviceClass *dclass;

	if (connection) {

		/* If the menu item had an associated connection already, just tell

		 * NM to activate that connection.

		 */

		nm_client_activate_connection_async (applet->nm_client,

		                                     connection,

		                                     device,

		                                     specific_object,

		                                     NULL,

		                                     activate_connection_cb,

		                                     applet);

		return;

	}

	g_return_if_fail (NM_IS_DEVICE (device));

	/* If no connection was given, ask the device class to create a new

	 * default connection for this device type.  This could be a wizard,

	 * and thus take a while.

	 */

	info = g_malloc0 (sizeof (AppletItemActivateInfo));

	info->applet = applet;

	info->specific_object = g_strdup (specific_object);

	info->device = g_object_ref (device);

	dclass = get_device_class (device, applet);

	g_assert (dclass);

	if (!dclass->new_auto_connection (device, dclass_data,

	                                  applet_menu_item_activate_helper_new_connection,

	                                  info))

		applet_item_activate_info_destroy (info);

}

void

applet_menu_item_add_complex_separator_helper (GtkWidget *menu,

                                               NMApplet *applet,

                                               const gchar *label)

{

	GtkWidget *menu_item, *box, *xlabel, *separator;

	if (INDICATOR_ENABLED (applet)) {

		/* Indicator doesn't draw complex separators */

		return;

	}

	menu_item = gtk_menu_item_new ();

	box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

	if (label) {

		xlabel = gtk_label_new (NULL);

		gtk_label_set_markup (GTK_LABEL (xlabel), label);

		separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);

		g_object_set (G_OBJECT (separator), "valign", GTK_ALIGN_CENTER, NULL);

		gtk_box_pack_start (GTK_BOX (box), separator, TRUE, TRUE, 0);

		gtk_box_pack_start (GTK_BOX (box), xlabel, FALSE, FALSE, 2);

	}

	separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);

	g_object_set (G_OBJECT (separator), "valign", GTK_ALIGN_CENTER, NULL);

	gtk_box_pack_start (GTK_BOX (box), separator, TRUE, TRUE, 0);

	g_object_set (G_OBJECT (menu_item),

		          "child", box,

		          "sensitive", FALSE,

		          NULL);

	gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);

}

GtkWidget *

applet_new_menu_item_helper (NMConnection *connection,

                             NMConnection *active,

                             gboolean add_active)

{

	GtkWidget *item = gtk_menu_item_new_with_label ("");

	if (add_active && (active == connection)) {

		char *markup;

		GtkWidget *label;

		/* Pure evil */

		label = gtk_bin_get_child (GTK_BIN (item));

		gtk_label_set_use_markup (GTK_LABEL (label), TRUE);

		markup = g_markup_printf_escaped ("%s", nm_connection_get_id (connection));

		gtk_label_set_markup (GTK_LABEL (label), markup);

		g_free (markup);

	} else

		gtk_menu_item_set_label (GTK_MENU_ITEM (item), nm_connection_get_id (connection));

	return item;

}

#define TITLE_TEXT_R ((double) 0x5e / 255.0 )

#define TITLE_TEXT_G ((double) 0x5e / 255.0 )

#define TITLE_TEXT_B ((double) 0x5e / 255.0 )

static void

menu_item_draw_generic (GtkWidget *widget, cairo_t *cr)

{

	GtkWidget *label;

	PangoFontDescription *desc;

	PangoLayout *layout;

	GtkStyleContext *style;

	int width = 0, height = 0, owidth, oheight;

	gdouble extraheight = 0, extrawidth = 0;

	const char *text;

	gdouble xpadding = 10.0;

	gdouble ypadding = 5.0;

	gdouble postpadding = 0.0;

	label = gtk_bin_get_child (GTK_BIN (widget));

	text = gtk_label_get_text (GTK_LABEL (label));

	layout = pango_cairo_create_layout (cr);

	style = gtk_widget_get_style_context (widget);

	gtk_style_context_get (style, gtk_style_context_get_state (style),

	                       "font", &desc,

	                       NULL);

	pango_font_description_set_variant (desc, PANGO_VARIANT_SMALL_CAPS);

	pango_font_description_set_weight (desc, PANGO_WEIGHT_SEMIBOLD);

	pango_layout_set_font_description (layout, desc);

	pango_layout_set_text (layout, text, -1);

	pango_cairo_update_layout (cr, layout);

	pango_layout_get_size (layout, &owidth, &oheight);

	width = owidth / PANGO_SCALE;

	height += oheight / PANGO_SCALE;

	cairo_save (cr);

	cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0);

	cairo_rectangle (cr, 0, 0,

	                 (double) (width + 2 * xpadding),

	                 (double) (height + ypadding + postpadding));

	cairo_fill (cr);

	/* now the in-padding content */

	cairo_translate (cr, xpadding , ypadding);

	cairo_set_source_rgb (cr, TITLE_TEXT_R, TITLE_TEXT_G, TITLE_TEXT_B);

	cairo_move_to (cr, extrawidth, extraheight);

	pango_cairo_show_layout (cr, layout);

	cairo_restore(cr);

	pango_font_description_free (desc);

	g_object_unref (layout);

	gtk_widget_set_size_request (widget, width + 2 * xpadding, height + ypadding + postpadding);

}

static gboolean

menu_title_item_draw (GtkWidget *widget, cairo_t *cr, gpointer user_data)

{

	menu_item_draw_generic (widget, cr);

	return TRUE;

}

GtkWidget *

applet_menu_item_create_device_item_helper (NMDevice *device,

                                            NMApplet *applet,

                                            const gchar *text)

{

	GtkWidget *item;

	item = gtk_menu_item_new_with_label (text);

	gtk_widget_set_sensitive (item, FALSE);

	if (!INDICATOR_ENABLED (applet))

		g_signal_connect (item, "draw", G_CALLBACK (menu_title_item_draw), NULL);

	return item;

}

static void

applet_clear_notify (NMApplet *applet)

{

	if (applet->notification == NULL)

		return;

	notify_notification_close (applet->notification, NULL);

	g_object_unref (applet->notification);

	applet->notification = NULL;

}

static gboolean

applet_notify_server_has_actions (void)

{

	static gboolean has_actions = FALSE;

	static gboolean initialized = FALSE;

	GList *server_caps, *iter;

	if (initialized)

		return has_actions;

	initialized = TRUE;

	server_caps = notify_get_server_caps();

	for (iter = server_caps; iter; iter = g_list_next (iter)) {

		if (!strcmp ((const char *) iter->data, NOTIFY_CAPS_ACTIONS_KEY)) {

			has_actions = TRUE;

			break;

		}

	}

	g_list_free_full (server_caps, g_free);

	return has_actions;

}

void

applet_do_notify (NMApplet *applet,

                  NotifyUrgency urgency,

                  const char *summary,

                  const char *message,

                  const char *icon,

                  const char *action1,

                  const char *action1_label,

                  NotifyActionCallback action1_cb,

                  gpointer action1_user_data)

{

	NotifyNotification *notify;

	GError *error = NULL;

	char *escaped;

	g_return_if_fail (applet != NULL);

	g_return_if_fail (summary != NULL);

	g_return_if_fail (message != NULL);

	if (INDICATOR_ENABLED (applet)) {

#ifdef WITH_APPINDICATOR

		if (app_indicator_get_status (applet->app_indicator) == APP_INDICATOR_STATUS_PASSIVE)

			return;

#endif  /* WITH_APPINDICATOR */

	} else {

		if (!gtk_status_icon_is_embedded (applet->status_icon))

			return;

	}

	/* if we're not acting as a secret agent, don't notify either */

	if (!applet->agent)

		return;

	applet_clear_notify (applet);

	escaped = utils_escape_notify_message (message);

	notify = notify_notification_new (summary,

	                                  escaped,

	                                  icon ? icon : "network-workgroup"

#if HAVE_LIBNOTIFY_07

	                                  );

#else

	                                  , NULL);

#endif

	g_free (escaped);

	applet->notification = notify;

#if HAVE_LIBNOTIFY_07

	notify_notification_set_hint (notify, "transient", g_variant_new_boolean (TRUE));

	notify_notification_set_hint (notify, "desktop-entry", g_variant_new_string ("nm-applet"));

#else

	notify_notification_attach_to_status_icon (notify, applet->status_icon);

#endif

	notify_notification_set_urgency (notify, urgency);

	notify_notification_set_timeout (notify, NOTIFY_EXPIRES_DEFAULT);

	if (applet_notify_server_has_actions () && action1) {

		notify_notification_clear_actions (notify);

		notify_notification_add_action (notify, action1, action1_label,

		                                action1_cb, action1_user_data, NULL);

	}

	if (!notify_notification_show (notify, &error)) {

		g_warning ("Failed to show notification: %s",

		           error && error->message ? error->message : "(unknown)");

		g_clear_error (&error);

	}

}

static void

notify_dont_show_cb (NotifyNotification *notify,

                     gchar *id,

                     gpointer user_data)

{

	NMApplet *applet = NM_APPLET (user_data);

	if (!id)

		return;

	if (   strcmp (id, PREF_DISABLE_CONNECTED_NOTIFICATIONS)

	    && strcmp (id, PREF_DISABLE_DISCONNECTED_NOTIFICATIONS)

	    && strcmp (id, PREF_DISABLE_VPN_NOTIFICATIONS))

		return;

	g_settings_set_boolean (applet->gsettings, id, TRUE);

}

void applet_do_notify_with_pref (NMApplet *applet,

                                 const char *summary,

                                 const char *message,

                                 const char *icon,

                                 const char *pref)

{

	if (g_settings_get_boolean (applet->gsettings, pref))

		return;

	applet_do_notify (applet, NOTIFY_URGENCY_LOW, summary, message, icon, pref,

	                  _("Don’t show this message again"),

	                  notify_dont_show_cb,

	                  applet);

}

static gboolean

animation_timeout (gpointer data)

{

	applet_schedule_update_icon (NM_APPLET (data));

	return TRUE;

}

static void

start_animation_timeout (NMApplet *applet)

{

	if (applet->animation_id == 0) {

		applet->animation_step = 0;

		applet->animation_id = g_timeout_add (100, animation_timeout, applet);

	}

}

static void

clear_animation_timeout (NMApplet *applet)

{

	if (applet->animation_id) {

		g_source_remove (applet->animation_id);

		applet->animation_id = 0;

		applet->animation_step = 0;

	}

}

static gboolean

applet_is_any_device_activating (NMApplet *applet)

{

	const GPtrArray *devices;

	int i;

	/* Check for activating devices */

	devices = nm_client_get_devices (applet->nm_client);

	for (i = 0; devices && (i < devices->len); i++) {

		NMDevice *candidate = NM_DEVICE (g_ptr_array_index (devices, i));

		NMDeviceState state;

		state = nm_device_get_state (candidate);

		if (state > NM_DEVICE_STATE_DISCONNECTED && state < NM_DEVICE_STATE_ACTIVATED)

			return TRUE;

	}

	return FALSE;

}

static gboolean

applet_is_any_vpn_activating (NMApplet *applet)

{

	const GPtrArray *connections;

	int i;

	connections = nm_client_get_active_connections (applet->nm_client);

	for (i = 0; connections && (i < connections->len); i++) {

		NMActiveConnection *candidate = NM_ACTIVE_CONNECTION (g_ptr_array_index (connections, i));

		NMActiveConnectionState state;

		if (NM_IS_VPN_CONNECTION (candidate)) {

			state = nm_active_connection_get_state (candidate);

			if (state == NM_ACTIVE_CONNECTION_STATE_ACTIVATING)

				return TRUE;

		}

	}

	return FALSE;

}

static char *

make_active_failure_message (NMActiveConnection *active,

                             NMActiveConnectionStateReason reason,

                             NMApplet *applet)

{

	NMConnection *connection;

	const GPtrArray *devices;

	NMDevice *device;

	const char *id;

	g_return_val_if_fail (active != NULL, NULL);

	connection = (NMConnection *) nm_active_connection_get_connection (active);

	id = nm_connection_get_id (connection);

	switch (reason) {

	case NM_ACTIVE_CONNECTION_STATE_REASON_DEVICE_DISCONNECTED:

		devices = nm_active_connection_get_devices (active);

		device = devices && devices->len > 0 ? devices->pdata[0] : NULL;

		if (device && nm_device_get_state (device) == NM_DEVICE_STATE_DISCONNECTED)

			return g_strdup_printf (_("\nThe VPN connection “%s” disconnected because the network connection was interrupted."), id);

		else

			return g_strdup_printf (_("\nThe VPN connection “%s” failed because the network connection was interrupted."), id);