gio/gnetworkmonitorportal.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright 2016 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "config.h"
  20
  21 #include "gnetworkmonitorportal.h"
  22 #include "ginitable.h"
  23 #include "giomodule-priv.h"
  24 #include "xdp-dbus.h"
  25 #include "gportalsupport.h"
  26
  27 static GInitableIface *initable_parent_iface;
  28 static void g_network_monitor_portal_iface_init (GNetworkMonitorInterface *iface);
  29 static void g_network_monitor_portal_initable_iface_init (GInitableIface *iface);
  30
  31 enum
  32 {
  33   PROP_0,
  34   PROP_NETWORK_AVAILABLE,
  35   PROP_NETWORK_METERED,
  36   PROP_CONNECTIVITY
  37 };
  38
  39 struct _GNetworkMonitorPortalPrivate
  40 {
  41   GDBusProxy *proxy;
  42   gboolean has_network;
  43   int version;
  44
  45   gboolean available;
  46   gboolean metered;
  47   GNetworkConnectivity connectivity;
  48 };
  49
  50 G_DEFINE_TYPE_WITH_CODE (GNetworkMonitorPortal, g_network_monitor_portal, G_TYPE_NETWORK_MONITOR_BASE,
  51                          G_ADD_PRIVATE (GNetworkMonitorPortal)
  52                          G_IMPLEMENT_INTERFACE (G_TYPE_NETWORK_MONITOR,
  53                                                 g_network_monitor_portal_iface_init)
  54                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
  55                                                 g_network_monitor_portal_initable_iface_init)
  56                          _g_io_modules_ensure_extension_points_registered ();
  57                          g_io_extension_point_implement (G_NETWORK_MONITOR_EXTENSION_POINT_NAME,
  58                                                          g_define_type_id,
  59                                                          "portal",
  60                                                          40))
  61
  62 static void
  63 g_network_monitor_portal_init (GNetworkMonitorPortal *nm)
  64 {
  65   nm->priv = g_network_monitor_portal_get_instance_private (nm);
  66 }
  67
  68 static void
  69 g_network_monitor_portal_get_property (GObject    *object,
  70                                        guint       prop_id,
  71                                        GValue     *value,
  72                                        GParamSpec *pspec)
  73 {
  74   GNetworkMonitorPortal *nm = G_NETWORK_MONITOR_PORTAL (object);
  75
  76   switch (prop_id)
  77     {
  78     case PROP_NETWORK_AVAILABLE:
  79       g_value_set_boolean (value, nm->priv->available);
  80       break;
  81
  82     case PROP_NETWORK_METERED:
  83       g_value_set_boolean (value, nm->priv->metered);
  84       break;
  85
  86     case PROP_CONNECTIVITY:
  87       g_value_set_enum (value, nm->priv->connectivity);
  88       break;
  89
  90     default:
  91       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  92       break;
  93     }
  94 }
  95
  96 static void
  97 got_available (GObject *source,
  98                GAsyncResult *res,
  99                gpointer data)
 100 {
 101   GDBusProxy *proxy = G_DBUS_PROXY (source);
 102   GNetworkMonitorPortal *nm = G_NETWORK_MONITOR_PORTAL (data);
 103   GError *error = NULL;
 104   GVariant *ret;
 105   gboolean available;
 106
 107   ret = g_dbus_proxy_call_finish (proxy, res, &error);
 108   if (ret == NULL)
 109     {
 110       g_warning ("%s", error->message);
 111       g_clear_error (&error);
 112       return;
 113     }
 114
 115   g_variant_get (ret, "(b)", &available);
 116   g_variant_unref (ret);
 117
 118   if (nm->priv->available != available)
 119     {
 120       nm->priv->available = available;
 121       g_object_notify (G_OBJECT (nm), "network-available");
 122       g_signal_emit_by_name (nm, "network-changed", available);
 123     }
 124 }
 125
 126 static void
 127 got_metered (GObject *source,
 128              GAsyncResult *res,
 129              gpointer data)
 130 {
 131   GDBusProxy *proxy = G_DBUS_PROXY (source);
 132   GNetworkMonitorPortal *nm = G_NETWORK_MONITOR_PORTAL (data);
 133   GError *error = NULL;
 134   GVariant *ret;
 135   gboolean metered;
 136
 137   ret = g_dbus_proxy_call_finish (proxy, res, &error);
 138   if (ret == NULL)
 139     {
 140       g_warning ("%s", error->message);
 141       g_clear_error (&error);
 142       return;
 143     }
 144
 145   g_variant_get (ret, "(b)", &metered);
 146   g_variant_unref (ret);
 147
 148   if (nm->priv->metered != metered)
 149     {
 150       nm->priv->metered = metered;
 151       g_object_notify (G_OBJECT (nm), "network-metered");
 152     }
 153 }
 154
 155 static void
 156 got_connectivity (GObject *source,
 157                   GAsyncResult *res,
 158                   gpointer data)
 159 {
 160   GDBusProxy *proxy = G_DBUS_PROXY (source);
 161   GNetworkMonitorPortal *nm = G_NETWORK_MONITOR_PORTAL (data);
 162   GError *error = NULL;
 163   GVariant *ret;
 164   GNetworkConnectivity connectivity;
 165
 166   ret = g_dbus_proxy_call_finish (proxy, res, &error);
 167   if (ret == NULL)
 168     {
 169       g_warning ("%s", error->message);
 170       g_clear_error (&error);
 171       return;
 172     }
 173
 174   g_variant_get (ret, "(u)", &connectivity);
 175   g_variant_unref (ret);
 176
 177   if (nm->priv->connectivity != connectivity)
 178     {
 179       nm->priv->connectivity = connectivity;
 180       g_object_notify (G_OBJECT (nm), "connectivity");
 181     }
 182 }
 183
 184 static void
 185 proxy_signal (GDBusProxy *proxy,
 186               const char *sender,
 187               const char *signal,
 188               GVariant *parameters,
 189               GNetworkMonitorPortal *nm)
 190 {
 191   if (!nm->priv->has_network)
 192     return;
 193
 194   if (nm->priv->version == 1)
 195     {
 196       gboolean available;
 197
 198       g_variant_get (parameters, "(b)", &available);
 199       g_signal_emit_by_name (nm, "network-changed", available);
 200     }
 201   else if (nm->priv->version == 2)
 202     {
 203       g_dbus_proxy_call (proxy, "GetConnectivity", NULL, 0, -1, NULL, got_connectivity, nm);
 204       g_dbus_proxy_call (proxy, "GetMetered", NULL, 0, -1, NULL, got_metered, nm);
 205       g_dbus_proxy_call (proxy, "GetAvailable", NULL, 0, -1, NULL, got_available, nm);
 206     }
 207 }
 208
 209 static void
 210 proxy_properties_changed (GDBusProxy *proxy,
 211                           GVariant *changed,
 212                           GVariant *invalidated,
 213                           GNetworkMonitorPortal *nm)
 214 {
 215   if (!nm->priv->has_network)
 216     return;
 217
 218   if (nm->priv->version == 1)
 219     {
 220       GVariant *ret;
 221
 222       ret = g_dbus_proxy_get_cached_property (proxy, "connectivity");
 223       if (ret)
 224         {
 225           GNetworkConnectivity connectivity = g_variant_get_uint32 (ret);
 226           if (nm->priv->connectivity != connectivity)
 227             {
 228               nm->priv->connectivity = connectivity;
 229               g_object_notify (G_OBJECT (nm), "connectivity");
 230             }
 231           g_variant_unref (ret);
 232         }
 233
 234       ret = g_dbus_proxy_get_cached_property (proxy, "metered");
 235       if (ret)
 236         {
 237           gboolean metered = g_variant_get_boolean (ret);
 238           if (nm->priv->metered != metered)
 239             {
 240               nm->priv->metered = metered;
 241               g_object_notify (G_OBJECT (nm), "network-metered");
 242             }
 243           g_variant_unref (ret);
 244         }
 245
 246       ret = g_dbus_proxy_get_cached_property (proxy, "available");
 247       if (ret)
 248         {
 249           gboolean available = g_variant_get_boolean (ret);
 250           if (nm->priv->available != available)
 251             {
 252               nm->priv->available = available;
 253               g_object_notify (G_OBJECT (nm), "network-available");
 254               g_signal_emit_by_name (nm, "network-changed", available);
 255             }
 256           g_variant_unref (ret);
 257         }
 258     }
 259 }
 260
 261 static gboolean
 262 g_network_monitor_portal_initable_init (GInitable     *initable,
 263                                         GCancellable  *cancellable,
 264                                         GError       **error)
 265 {
 266   GNetworkMonitorPortal *nm = G_NETWORK_MONITOR_PORTAL (initable);
 267   GDBusProxy *proxy;
 268   gchar *name_owner = NULL;
 269   int version;
 270   GVariant *ret;
 271
 272   nm->priv->available = FALSE;
 273   nm->priv->metered = FALSE;
 274   nm->priv->connectivity = G_NETWORK_CONNECTIVITY_LOCAL;
 275
 276   if (!glib_should_use_portal ())
 277     {
 278       g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Not using portals");
 279       return FALSE;
 280     }
 281
 282   proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
 283                                          G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START
 284                                          | G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
 285                                          NULL,
 286                                          "org.freedesktop.portal.Desktop",
 287                                          "/org/freedesktop/portal/desktop",
 288                                          "org.freedesktop.portal.NetworkMonitor",
 289                                          cancellable,
 290                                          error);
 291   if (!proxy)
 292     return FALSE;
 293
 294   name_owner = g_dbus_proxy_get_name_owner (proxy);
 295
 296   if (!name_owner)
 297     {
 298       g_object_unref (proxy);
 299       g_set_error (error,
 300                    G_DBUS_ERROR,
 301                    G_DBUS_ERROR_NAME_HAS_NO_OWNER,
 302                    "Desktop portal not found");
 303       return FALSE;
 304     }
 305
 306   g_free (name_owner);
 307
 308   ret = g_dbus_proxy_get_cached_property (proxy, "version");
 309   g_variant_get (ret, "u", &version);
 310   g_variant_unref (ret);
 311
 312   if (version != 1 && version != 2)
 313     {
 314       g_object_unref (proxy);
 315       g_set_error (error,
 316                    G_DBUS_ERROR,
 317                    G_DBUS_ERROR_NAME_HAS_NO_OWNER,
 318                    "NetworkMonitor portal unsupported version: %d", version);
 319       return FALSE;
 320     }
 321
 322   g_signal_connect (proxy, "g-signal", G_CALLBACK (proxy_signal), nm);
 323   g_signal_connect (proxy, "g-properties-changed", G_CALLBACK (proxy_properties_changed), nm);
 324
 325   nm->priv->proxy = proxy;
 326   nm->priv->has_network = glib_network_available_in_sandbox ();
 327   nm->priv->version = version;
 328
 329   return initable_parent_iface->init (initable, cancellable, error);
 330 }
 331
 332 static void
 333 g_network_monitor_portal_finalize (GObject *object)
 334 {
 335   GNetworkMonitorPortal *nm = G_NETWORK_MONITOR_PORTAL (object);
 336
 337   g_clear_object (&nm->priv->proxy);
 338
 339   G_OBJECT_CLASS (g_network_monitor_portal_parent_class)->finalize (object);
 340 }
 341
 342 static void
 343 g_network_monitor_portal_class_init (GNetworkMonitorPortalClass *class)
 344 {
 345   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 346
 347   gobject_class->finalize  = g_network_monitor_portal_finalize;
 348   gobject_class->get_property = g_network_monitor_portal_get_property;
 349
 350   g_object_class_override_property (gobject_class, PROP_NETWORK_AVAILABLE, "network-available");
 351   g_object_class_override_property (gobject_class, PROP_NETWORK_METERED, "network-metered");
 352   g_object_class_override_property (gobject_class, PROP_CONNECTIVITY, "connectivity");
 353 }
 354
 355 static void
 356 g_network_monitor_portal_iface_init (GNetworkMonitorInterface *monitor_iface)
 357 {
 358 }
 359
 360 static void
 361 g_network_monitor_portal_initable_iface_init (GInitableIface *iface)
 362 {
 363   initable_parent_iface = g_type_interface_peek_parent (iface);
 364
 365   iface->init = g_network_monitor_portal_initable_init;
 366 }