openkylin
/
glib2.0
mirror of https://gitee.com/openkylin/glib2.0.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity
glib2.0/gio/gnetworkmonitornm.c

377 lines
11 KiB
C
Raw Blame History

/* GIO - GLib Input, Output and Streaming Library
*
* Copyright 2014 Red Hat, Inc.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include "gnetworkmonitornm.h"
#include "gioerror.h"
#include "ginitable.h"
#include "giomodule-priv.h"
#include "glibintl.h"
#include "glib/gstdio.h"
#include "gnetworkingprivate.h"
#include "gnetworkmonitor.h"
#include "gdbusproxy.h"
static void g_network_monitor_nm_iface_init (GNetworkMonitorInterface *iface);
static void g_network_monitor_nm_initable_iface_init (GInitableIface *iface);
enum
{
PROP_0,
PROP_NETWORK_AVAILABLE,
PROP_NETWORK_METERED,
PROP_CONNECTIVITY
};
typedef enum {
NM_CONNECTIVITY_UNKNOWN,
NM_CONNECTIVITY_NONE,
NM_CONNECTIVITY_PORTAL,
NM_CONNECTIVITY_LIMITED,
NM_CONNECTIVITY_FULL
} NMConnectivityState;
/* Copied from https://developer.gnome.org/libnm-util/stable/libnm-util-NetworkManager.html#NMState;
* used inline to avoid a NetworkManager dependency from GLib. */
typedef enum {
NM_STATE_UNKNOWN = 0,
NM_STATE_ASLEEP = 10,
NM_STATE_DISCONNECTED = 20,
NM_STATE_DISCONNECTING = 30,
NM_STATE_CONNECTING = 40,
NM_STATE_CONNECTED_LOCAL = 50,
NM_STATE_CONNECTED_SITE = 60,
NM_STATE_CONNECTED_GLOBAL = 70,
} NMState;
struct _GNetworkMonitorNMPrivate
{
GDBusProxy *proxy;
guint signal_id;
GNetworkConnectivity connectivity;
gboolean network_available;
gboolean network_metered;
};
#define g_network_monitor_nm_get_type _g_network_monitor_nm_get_type
G_DEFINE_TYPE_WITH_CODE (GNetworkMonitorNM, g_network_monitor_nm, G_TYPE_NETWORK_MONITOR_NETLINK,
G_ADD_PRIVATE (GNetworkMonitorNM)
G_IMPLEMENT_INTERFACE (G_TYPE_NETWORK_MONITOR,
g_network_monitor_nm_iface_init)
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
g_network_monitor_nm_initable_iface_init)
_g_io_modules_ensure_extension_points_registered ();
g_io_extension_point_implement (G_NETWORK_MONITOR_EXTENSION_POINT_NAME,
g_define_type_id,
"networkmanager",
30))
static void
g_network_monitor_nm_init (GNetworkMonitorNM *nm)
{
nm->priv = g_network_monitor_nm_get_instance_private (nm);
}
static void
g_network_monitor_nm_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GNetworkMonitorNM *nm = G_NETWORK_MONITOR_NM (object);
switch (prop_id)
{
case PROP_NETWORK_AVAILABLE:
g_value_set_boolean (value, nm->priv->network_available);
break;
case PROP_NETWORK_METERED:
g_value_set_boolean (value, nm->priv->network_metered);
break;
case PROP_CONNECTIVITY:
g_value_set_enum (value, nm->priv->connectivity);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GNetworkConnectivity
nm_conn_to_g_conn (int nm_state)
{
switch (nm_state)
{
case NM_CONNECTIVITY_UNKNOWN:
return G_NETWORK_CONNECTIVITY_LOCAL;
case NM_CONNECTIVITY_NONE:
return G_NETWORK_CONNECTIVITY_LOCAL;
case NM_CONNECTIVITY_PORTAL:
return G_NETWORK_CONNECTIVITY_PORTAL;
case NM_CONNECTIVITY_LIMITED:
return G_NETWORK_CONNECTIVITY_LIMITED;
case NM_CONNECTIVITY_FULL:
return G_NETWORK_CONNECTIVITY_FULL;
default:
g_warning ("Unknown NM connectivity state %d", nm_state);
return G_NETWORK_CONNECTIVITY_LOCAL;
}
}
static gboolean
nm_metered_to_bool (guint nm_metered)
{
switch (nm_metered)
{
case 1: /* yes */
case 3: /* guess-yes */
return TRUE;
case 0: /* unknown */
/* We default to FALSE in the unknown-because-you're-not-running-NM
* case, so we should return FALSE in the
* unknown-when-you-are-running-NM case too. */
case 2: /* no */
case 4: /* guess-no */
return FALSE;
default:
g_warning ("Unknown NM metered state %d", nm_metered);
return FALSE;
}
}
static void
sync_properties (GNetworkMonitorNM *nm,
gboolean emit_signals)
{
GVariant *v;
NMState nm_state;
NMConnectivityState nm_connectivity;
gboolean new_network_available;
gboolean new_network_metered;
GNetworkConnectivity new_connectivity;
v = g_dbus_proxy_get_cached_property (nm->priv->proxy, "State");
if (!v)
return;
nm_state = g_variant_get_uint32 (v);
g_variant_unref (v);
v = g_dbus_proxy_get_cached_property (nm->priv->proxy, "Connectivity");
if (!v)
return;
nm_connectivity = g_variant_get_uint32 (v);
g_variant_unref (v);
if (nm_state <= NM_STATE_CONNECTED_LOCAL)
{
new_network_available = FALSE;
new_network_metered = FALSE;
new_connectivity = G_NETWORK_CONNECTIVITY_LOCAL;
}
else if (nm_state <= NM_STATE_CONNECTED_SITE)
{
new_network_available = TRUE;
new_network_metered = FALSE;
if (nm_connectivity == NM_CONNECTIVITY_PORTAL)
{
new_connectivity = G_NETWORK_CONNECTIVITY_PORTAL;
}
else
{
new_connectivity = G_NETWORK_CONNECTIVITY_LIMITED;
}
}
else /* nm_state == NM_STATE_CONNECTED_FULL */
{
/* this is only available post NM 1.0 */
v = g_dbus_proxy_get_cached_property (nm->priv->proxy, "Metered");
if (v == NULL)
{
new_network_metered = FALSE;
}
else
{
new_network_metered = nm_metered_to_bool (g_variant_get_uint32 (v));
g_variant_unref (v);
}
new_network_available = TRUE;
new_connectivity = nm_conn_to_g_conn (nm_connectivity);
}
if (!emit_signals)
{
nm->priv->network_metered = new_network_metered;
nm->priv->network_available = new_network_available;
nm->priv->connectivity = new_connectivity;
return;
}
if (new_network_available != nm->priv->network_available)
{
nm->priv->network_available = new_network_available;
g_object_notify (G_OBJECT (nm), "network-available");
}
if (new_network_metered != nm->priv->network_metered)
{
nm->priv->network_metered = new_network_metered;
g_object_notify (G_OBJECT (nm), "network-metered");
}
if (new_connectivity != nm->priv->connectivity)
{
nm->priv->connectivity = new_connectivity;
g_object_notify (G_OBJECT (nm), "connectivity");
}
}
static void
proxy_properties_changed_cb (GDBusProxy *proxy,
GVariant *changed_properties,
GStrv invalidated_properties,
GNetworkMonitorNM *nm)
{
sync_properties (nm, TRUE);
}
static gboolean
has_property (GDBusProxy *proxy,
const char *property_name)
{
char **props;
gboolean prop_found = FALSE;
props = g_dbus_proxy_get_cached_property_names (proxy);
if (!props)
return FALSE;
prop_found = g_strv_contains ((const gchar * const *) props, property_name);
g_strfreev (props);
return prop_found;
}
static gboolean
g_network_monitor_nm_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
GNetworkMonitorNM *nm = G_NETWORK_MONITOR_NM (initable);
GDBusProxy *proxy;
GInitableIface *parent_iface;
gchar *name_owner = NULL;
parent_iface = g_type_interface_peek_parent (G_NETWORK_MONITOR_NM_GET_INITABLE_IFACE (initable));
if (!parent_iface->init (initable, cancellable, error))
return FALSE;
proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START | G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
NULL,
"org.freedesktop.NetworkManager",
"/org/freedesktop/NetworkManager",
"org.freedesktop.NetworkManager",
cancellable,
error);
if (!proxy)
return FALSE;
name_owner = g_dbus_proxy_get_name_owner (proxy);
if (!name_owner)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("NetworkManager not running"));
g_object_unref (proxy);
return FALSE;
}
g_free (name_owner);
/* Verify it has the PrimaryConnection and Connectivity properties */
if (!has_property (proxy, "Connectivity"))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("NetworkManager version too old"));
g_object_unref (proxy);
return FALSE;
}
nm->priv->signal_id = g_signal_connect (G_OBJECT (proxy), "g-properties-changed",
G_CALLBACK (proxy_properties_changed_cb), nm);
nm->priv->proxy = proxy;
sync_properties (nm, FALSE);
return TRUE;
}
static void
g_network_monitor_nm_finalize (GObject *object)
{
GNetworkMonitorNM *nm = G_NETWORK_MONITOR_NM (object);
if (nm->priv->proxy != NULL &&
nm->priv->signal_id != 0)
{
g_signal_handler_disconnect (nm->priv->proxy,
nm->priv->signal_id);
nm->priv->signal_id = 0;
}
g_clear_object (&nm->priv->proxy);
G_OBJECT_CLASS (g_network_monitor_nm_parent_class)->finalize (object);
}
static void
g_network_monitor_nm_class_init (GNetworkMonitorNMClass *nl_class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (nl_class);
gobject_class->finalize = g_network_monitor_nm_finalize;
gobject_class->get_property = g_network_monitor_nm_get_property;
g_object_class_override_property (gobject_class, PROP_NETWORK_AVAILABLE, "network-available");
g_object_class_override_property (gobject_class, PROP_NETWORK_METERED, "network-metered");
g_object_class_override_property (gobject_class, PROP_CONNECTIVITY, "connectivity");
}
static void
g_network_monitor_nm_iface_init (GNetworkMonitorInterface *monitor_iface)
{
}
static void
g_network_monitor_nm_initable_iface_init (GInitableIface *iface)
{
iface->init = g_network_monitor_nm_initable_init;
}
Reference in New Issue View Git Blame Copy Permalink