gio/gnetworkmonitornm.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright 2014 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 <errno.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24
  25 #include "gnetworkmonitornm.h"
  26 #include "gioerror.h"
  27 #include "ginitable.h"
  28 #include "giomodule-priv.h"
  29 #include "glibintl.h"
  30 #include "glib/gstdio.h"
  31 #include "gnetworkingprivate.h"
  32 #include "gnetworkmonitor.h"
  33 #include "gdbusproxy.h"
  34
  35 static void g_network_monitor_nm_iface_init (GNetworkMonitorInterface *iface);
  36 static void g_network_monitor_nm_initable_iface_init (GInitableIface *iface);
  37
  38 enum
  39 {
  40   PROP_0,
  41
  42   PROP_NETWORK_AVAILABLE,
  43   PROP_NETWORK_METERED,
  44   PROP_CONNECTIVITY
  45 };
  46
  47 typedef enum {
  48   NM_CONNECTIVITY_UNKNOWN,
  49   NM_CONNECTIVITY_NONE,
  50   NM_CONNECTIVITY_PORTAL,
  51   NM_CONNECTIVITY_LIMITED,
  52   NM_CONNECTIVITY_FULL
  53 } NMConnectivityState;
  54
  55 struct _GNetworkMonitorNMPrivate
  56 {
  57   GDBusProxy *proxy;
  58
  59   GNetworkConnectivity connectivity;
  60   gboolean network_available;
  61   gboolean network_metered;
  62 };
  63
  64 #define g_network_monitor_nm_get_type _g_network_monitor_nm_get_type
  65 G_DEFINE_TYPE_WITH_CODE (GNetworkMonitorNM, g_network_monitor_nm, G_TYPE_NETWORK_MONITOR_NETLINK,
  66                          G_ADD_PRIVATE (GNetworkMonitorNM)
  67                          G_IMPLEMENT_INTERFACE (G_TYPE_NETWORK_MONITOR,
  68                                                 g_network_monitor_nm_iface_init)
  69                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
  70                                                 g_network_monitor_nm_initable_iface_init)
  71                          _g_io_modules_ensure_extension_points_registered ();
  72                          g_io_extension_point_implement (G_NETWORK_MONITOR_EXTENSION_POINT_NAME,
  73                                                          g_define_type_id,
  74                                                          "networkmanager",
  75                                                          30))
  76
  77 static void
  78 g_network_monitor_nm_init (GNetworkMonitorNM *nm)
  79 {
  80   nm->priv = g_network_monitor_nm_get_instance_private (nm);
  81 }
  82
  83 static void
  84 g_network_monitor_nm_get_property (GObject    *object,
  85                                    guint       prop_id,
  86                                    GValue     *value,
  87                                    GParamSpec *pspec)
  88 {
  89   GNetworkMonitorNM *nm = G_NETWORK_MONITOR_NM (object);
  90
  91   switch (prop_id)
  92     {
  93     case PROP_NETWORK_AVAILABLE:
  94       g_value_set_boolean (value, nm->priv->network_available);
  95       break;
  96
  97     case PROP_NETWORK_METERED:
  98       g_value_set_boolean (value, nm->priv->network_metered);
  99       break;
 100
 101     case PROP_CONNECTIVITY:
 102       g_value_set_enum (value, nm->priv->connectivity);
 103       break;
 104
 105     default:
 106       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 107       break;
 108     }
 109 }
 110
 111 static GNetworkConnectivity
 112 nm_conn_to_g_conn (int nm_state)
 113 {
 114   switch (nm_state)
 115     {
 116       case NM_CONNECTIVITY_UNKNOWN:
 117         return G_NETWORK_CONNECTIVITY_LOCAL;
 118       case NM_CONNECTIVITY_NONE:
 119         return G_NETWORK_CONNECTIVITY_LOCAL;
 120       case NM_CONNECTIVITY_PORTAL:
 121         return G_NETWORK_CONNECTIVITY_PORTAL;
 122       case NM_CONNECTIVITY_LIMITED:
 123         return G_NETWORK_CONNECTIVITY_LIMITED;
 124       case NM_CONNECTIVITY_FULL:
 125         return G_NETWORK_CONNECTIVITY_FULL;
 126       default:
 127         g_warning ("Unknown NM connectivity state %d", nm_state);
 128         return G_NETWORK_CONNECTIVITY_LOCAL;
 129     }
 130 }
 131
 132 static gboolean
 133 nm_metered_to_bool (guint nm_metered)
 134 {
 135   switch (nm_metered)
 136     {
 137       case 1: /* yes */
 138       case 3: /* guess-yes */
 139         return TRUE;
 140       case 0: /* unknown */
 141         /* We default to FALSE in the unknown-because-you're-not-running-NM
 142          * case, so we should return FALSE in the
 143          * unknown-when-you-are-running-NM case too. */
 144       case 2: /* no */
 145       case 4: /* guess-no */
 146         return FALSE;
 147       default:
 148         g_warning ("Unknown NM metered state %d", nm_metered);
 149         return FALSE;
 150     }
 151 }
 152
 153 static void
 154 sync_properties (GNetworkMonitorNM *nm,
 155                  gboolean           emit_signals)
 156 {
 157   GVariant *v;
 158   NMConnectivityState nm_connectivity;
 159   gboolean new_network_available;
 160   gboolean new_network_metered;
 161   GNetworkConnectivity new_connectivity;
 162
 163   v = g_dbus_proxy_get_cached_property (nm->priv->proxy, "Connectivity");
 164   if (!v)
 165     return;
 166
 167   nm_connectivity = g_variant_get_uint32 (v);
 168   g_variant_unref (v);
 169
 170   if (nm_connectivity == NM_CONNECTIVITY_NONE)
 171     {
 172       new_network_available = FALSE;
 173       new_network_metered = FALSE;
 174       new_connectivity = G_NETWORK_CONNECTIVITY_LOCAL;
 175     }
 176   else
 177     {
 178
 179       /* this is only available post NM 1.0 */
 180       v = g_dbus_proxy_get_cached_property (nm->priv->proxy, "Metered");
 181       if (v == NULL)
 182         {
 183           new_network_metered = FALSE;
 184         }
 185       else
 186         {
 187           new_network_metered = nm_metered_to_bool (g_variant_get_uint32 (v));
 188           g_variant_unref (v);
 189         }
 190
 191       new_network_available = TRUE;
 192       new_connectivity = nm_conn_to_g_conn (nm_connectivity);
 193     }
 194
 195   if (!emit_signals)
 196     {
 197       nm->priv->network_metered = new_network_metered;
 198       nm->priv->network_available = new_network_available;
 199       nm->priv->connectivity = new_connectivity;
 200       return;
 201     }
 202
 203   if (new_network_available != nm->priv->network_available)
 204     {
 205       nm->priv->network_available = new_network_available;
 206       g_object_notify (G_OBJECT (nm), "network-available");
 207     }
 208   if (new_network_metered != nm->priv->network_metered)
 209     {
 210       nm->priv->network_metered = new_network_metered;
 211       g_object_notify (G_OBJECT (nm), "network-metered");
 212     }
 213   if (new_connectivity != nm->priv->connectivity)
 214     {
 215       nm->priv->connectivity = new_connectivity;
 216       g_object_notify (G_OBJECT (nm), "connectivity");
 217     }
 218 }
 219
 220 static void
 221 update_cached_property (GDBusProxy   *proxy,
 222                         const char   *property_name,
 223                         GVariantDict *dict)
 224 {
 225   GVariant *v;
 226
 227   v = g_variant_dict_lookup_value (dict, property_name, NULL);
 228   if (!v)
 229     return;
 230   g_dbus_proxy_set_cached_property (proxy, property_name, v);
 231 }
 232
 233 static void
 234 proxy_signal_cb (GDBusProxy        *proxy,
 235                  gchar             *sender_name,
 236                  gchar             *signal_name,
 237                  GVariant          *parameters,
 238                  GNetworkMonitorNM *nm)
 239 {
 240   GVariant *asv;
 241   GVariantDict *dict;
 242
 243   if (g_strcmp0 (signal_name, "PropertiesChanged") != 0)
 244     return;
 245
 246   g_variant_get (parameters, "(@a{sv})", &asv);
 247   if (!asv)
 248     return;
 249
 250   dict = g_variant_dict_new (asv);
 251   if (!dict)
 252     {
 253       g_warning ("Failed to handle PropertiesChanged signal from NetworkManager");
 254       return;
 255     }
 256
 257   update_cached_property (nm->priv->proxy, "Connectivity", dict);
 258
 259   g_variant_dict_unref (dict);
 260
 261   sync_properties (nm, TRUE);
 262 }
 263
 264 static gboolean
 265 has_property (GDBusProxy *proxy,
 266               const char *property_name)
 267 {
 268   char **props;
 269   guint i;
 270   gboolean prop_found = FALSE;
 271
 272   props = g_dbus_proxy_get_cached_property_names (proxy);
 273
 274   if (!props)
 275     return FALSE;
 276
 277   for (i = 0; props[i] != NULL; i++)
 278     {
 279       if (g_str_equal (props[i], property_name))
 280         {
 281           prop_found = TRUE;
 282           break;
 283         }
 284     }
 285
 286   g_strfreev (props);
 287   return prop_found;
 288 }
 289
 290 static gboolean
 291 g_network_monitor_nm_initable_init (GInitable     *initable,
 292                                     GCancellable  *cancellable,
 293                                     GError       **error)
 294 {
 295   GNetworkMonitorNM *nm = G_NETWORK_MONITOR_NM (initable);
 296   GDBusProxy *proxy;
 297   GInitableIface *parent_iface;
 298   gchar *name_owner = NULL;
 299
 300   parent_iface = g_type_interface_peek_parent (G_NETWORK_MONITOR_NM_GET_INITABLE_IFACE (initable));
 301   if (!parent_iface->init (initable, cancellable, error))
 302     return FALSE;
 303
 304   proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
 305                                          G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START | G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
 306                                          NULL,
 307                                          "org.freedesktop.NetworkManager",
 308                                          "/org/freedesktop/NetworkManager",
 309                                          "org.freedesktop.NetworkManager",
 310                                          cancellable,
 311                                          error);
 312   if (!proxy)
 313     return FALSE;
 314
 315   name_owner = g_dbus_proxy_get_name_owner (proxy);
 316
 317   if (!name_owner)
 318     {
 319       g_object_unref (proxy);
 320       return FALSE;
 321     }
 322
 323   g_free (name_owner);
 324
 325   /* Verify it has the PrimaryConnection and Connectivity properties */
 326   if (!has_property (proxy, "Connectivity"))
 327     {
 328       g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 329                    _("NetworkManager version too old"));
 330       g_object_unref (proxy);
 331       return FALSE;
 332     }
 333
 334   g_signal_connect (G_OBJECT (proxy), "g-signal",
 335                     G_CALLBACK (proxy_signal_cb), nm);
 336   nm->priv->proxy = proxy;
 337   sync_properties (nm, FALSE);
 338
 339   return TRUE;
 340 }
 341
 342 static void
 343 g_network_monitor_nm_finalize (GObject *object)
 344 {
 345   GNetworkMonitorNM *nm = G_NETWORK_MONITOR_NM (object);
 346
 347   g_clear_object (&nm->priv->proxy);
 348
 349   G_OBJECT_CLASS (g_network_monitor_nm_parent_class)->finalize (object);
 350 }
 351
 352 static void
 353 g_network_monitor_nm_class_init (GNetworkMonitorNMClass *nl_class)
 354 {
 355   GObjectClass *gobject_class = G_OBJECT_CLASS (nl_class);
 356
 357   gobject_class->finalize  = g_network_monitor_nm_finalize;
 358   gobject_class->get_property = g_network_monitor_nm_get_property;
 359
 360   g_object_class_override_property (gobject_class, PROP_NETWORK_AVAILABLE, "network-available");
 361   g_object_class_override_property (gobject_class, PROP_NETWORK_METERED, "network-metered");
 362   g_object_class_override_property (gobject_class, PROP_CONNECTIVITY, "connectivity");
 363 }
 364
 365 static void
 366 g_network_monitor_nm_iface_init (GNetworkMonitorInterface *monitor_iface)
 367 {
 368 }
 369
 370 static void
 371 g_network_monitor_nm_initable_iface_init (GInitableIface *iface)
 372 {
 373   iface->init = g_network_monitor_nm_initable_init;
 374 }